I build AI systems for the kind of company that can't hand its data to a third party. Treasury. Legal. Medical. Defense. The architecture stays on your infra. Credentials stay on the device. Memory stays in your database. The only thing that touches a vendor is the model, and even that is one config line away from being swapped.
Most AI vendors win by abstracting your data, your models, and your interface away from you. I invert all three.
Architecture before features.
Every system I build starts with a residency map. Where does each byte live and who can read it. Credentials stay on the device. Memory lives in your database. The model is the only thing that talks to a vendor, and that vendor is one env var away from being replaced.
Compiled, cached, swappable.
LLMs are expensive at runtime and cheap at compile time. I generate the extractor once, cache the deterministic JS, and run it free forever. Frontier prices for code-gen. Nano prices for classification. The right model for the right job, not one model for everything.
Conversational by default.
MCP is not a feature. It is a substrate. Every system I ship exposes a typed tool surface so Claude, ChatGPT, or your internal agent can read, write, and reason over it from day one. The dashboard is a side effect.
I have been consulting since 2018. Happy to share references on a call.
One person, so I say no to most work. These are the systems where the architecture actually matters. Where the difference between a good answer and a bad one is whether you can defend the data path.
“Generate code once. Run it free forever.”
DOM extractors, structured-output pipelines, document parsers, code-mod tools. The LLM writes a pure function. You cache it. You run it deterministically for the next year. Frontier costs at the compile step, nano costs at runtime. Most teams reach for an LLM at every request. That is how budgets disappear.
10x to 1000x cost reduction vs per-request LLM calls
“Make Claude remember. Make ChatGPT remember. Make your agent remember.”
A persistent memory layer that lives in your infrastructure and connects to every Claude and ChatGPT surface via MCP. Tokenized recall. Tag-weighted scoring. Postgres or self-host. Same memory across CLI, GUI, web. The opposite of vendor-locked Project Memory.
Cross-surface continuity. Switch vendors without losing context.
“Pull from the source without selling it.”
WebView-based on-device extraction for bank portals, healthcare records, internal admin tools. No Plaid. No Persona. No data processor sitting between you and the source. Credentials live in the device session and nowhere else. The same architecture serves a household and a fifty million dollar family office.
Zero credential brokering. Zero per-user vendor cost.
“Your books, queryable in plain English.”
Multi-source aggregation, automatic categorization, recurring-charge detection, anomaly surfacing. Wired to a typed MCP so any LLM agent can answer “what is our cash position across all entities” in one query. It replaces the spreadsheet, not the controller.
Hours of monthly close compressed to one conversation.
“Bring the agent to the workstation, not the workstation to the cloud.”
Desktop and mobile clients that run Claude Code, MCP servers, and tool permission flows entirely on-device. Worktree git ops. Custom permission prompts. Conversation history. All local. Approved for environments where the cloud desktop apps are not.
Use Claude where Slack and Notion and Codex cannot go.
“Internal tools that scale with your engineers, not against them.”
Rust execution services, semantic-merge version control, file-tree IDEs, streaming terminal UIs. Built for teams who want a Linear-grade interior for the engineering work that today lives in fifteen disconnected tabs.
One surface for the whole inner loop.
Five systems I have built and run. All owned by the people they serve, not by me. Each link opens a full case study with the architecture, the trade-offs, and the receipts.
AI-native treasury for households and institutions that can't use Plaid.
A sovereign personal-finance and treasury system. The native iOS app pulls transactions straight from bank portals through an on-device WKWebView. Credentials never leave the phone. An LLM-as-compiler pipeline writes a JavaScript extractor once per bank, caches it, and runs it deterministically forever. An MCP server exposes the whole dataset to Claude and ChatGPT for conversational queries.
A persistent memory primitive that follows you across Claude.ai, ChatGPT, the CLI, and your tools.
A user-owned memory layer with tokenized recall, tag-weighted scoring, and a single MCP endpoint that every Anthropic and OpenAI surface can mount. It replaces the labs’ built-in memory with something that lives in your Postgres and survives the next vendor switch.
An AI copilot for the inbox that briefs, drafts, and remembers, without becoming the inbox.
Daily briefings, draft generation, and conversational search on top of Gmail. Auth, briefing, chat, and memory modules wired through a clean NestJS service. OpenAI for generation. The memory module makes the assistant feel like it actually knows you instead of starting from scratch every morning.
A local Electron surface for Claude Code in environments where the official desktop app isn't allowed.
Native UI on top of the Claude Code CLI. Conversation history, worktree git operations, markdown rendering, and an MCP permission bridge that surfaces tool approvals as modal dialogs. Approved for enterprise environments where Anthropic’s desktop client is blocked. Distributed inside teams. Not a SaaS.
A version-control platform built around semantic merge and an embedded agent runtime.
A Rust monorepo with three services. API, collab, and a WebSocket-based execution streamer. Together they host a file-tree IDE, run buttons, streaming terminals, and a semantic merge engine. Substrate for the next generation of agent-friendly developer tools.
Some of these I have shipped. Some I have only sketched. The architecture is the same in every room. If your data already lives in OpenAI’s context window, you do not need me. If it does not, or if it should not, here is what the pattern looks like in your vertical.
Family offices, VC firms, multi-entity holdcos, regulated SMBs. Replace Plaid-bound aggregators with on-device extraction. Conversational queries across the whole capital stack.
Firms whose discovery, contracts, and matter notes cannot enter a third-party LLM context window. The same architecture that keeps bank credentials on-device keeps privileged matter on-tenant.
Clinics and providers under HIPAA / PHIPA who need AI on top of EHR data without giving the EHR data to a vendor. The on-device + MCP-gated pattern fits cleanly. Domain compliance work would partner with someone cleared.
Air-gapped or sovereign-cloud environments where the model itself is a contract decision. Architecture that swaps inference providers in one config line. Cleared engagements would require a cleared partner.
Engineering teams who want a Linear-grade interior for the inner loop. IDE, runtime, version control, agent dispatch. Without buying into a SaaS roadmap.
Startups building vertical agents who need the substrate beneath the agent to be production-grade and theirs. Memory. MCP tools. Conversational data layer.
No discovery deck. No SOW novel. We talk for an hour. If it fits, the engagement starts with a four-week paid sketch. If the sketch reveals the project is wrong-shaped, you stop there with an artifact and no sunk cost. If it’s right-shaped, we move into a build sprint. Fee is fixed at each phase. Scope is fixed at each phase.
A free 60-minute call. I read the codebase, the threat model, and the data-flow constraints. You leave with a written architecture sketch and a yes or no on whether I am the right person, even when the answer is no.
A four-week paid engagement. I write the full architecture spec and build a pilot of the riskiest piece end-to-end. Lower commitment than a full sprint. If the sketch reveals the project is wrong-shaped, you stop here with a useful artifact and no sunk cost.
Optional. A seven-week sprint to a working production system, at fractional cadence. One Slack channel. One git repo. One weekly demo. Code lands on your infra from day one. No staging-vs-real divergence. No agency theatre.
I write the docs your team will actually use. Runbooks, ADRs, an operator’s guide. I walk your engineers through the substrate. Optional retainer for a quarterly architecture review.
Phase priced.
Fixed at each step.
No hourly · No retainer trap
The architectural shapes that keep recurring in the work. Written for engineers, not buyers.
Most teams pay frontier prices to do work that should have been compiled once and cached forever. Here is the pattern that turned a $400 a month parsing bill into eight cents.
Project Memory, ChatGPT Memory, Claude Memory. Three vendors converging on the same lock-in. The architecture that wins is the one you own.
Open banking is still slipping in Canada. Family offices do not trust per-user data processors. WKWebView and LLM-as-compiler is the architecture that ships now.
One Slack channel. One git repo. One demo a week. Fractional cadence, 10 to 12 hours a week. One slot open this quarter. Send me what you are trying to ship and what the data path looks like. I write back within a few days.