Portfolio
A private AI platform, the agents that operate it, and the apps I've shipped on top of it. I built and run all of it myself. Click any tile for the case study.
The foundation everything else on this page runs on.
What it does Public and private data comes in through an ingestion layer and lands in a knowledge graph and a time-series warehouse. A layer of autonomous agents works over that data and sends results to a live dashboard.
The infrastructure flex Go services move work across a message bus. Agents never call each other directly, so every agent action is an event I can audit. Behind the bus are Postgres, Neo4j, Elasticsearch, and Redis, and about 4,900 automated tests. It all runs on two consumer desktops connected by a 10 GbE link. Most of the intelligence runs on local models, so the high-volume work doesn't cost me per token.
How it's operated I set the direction and the platform does the rest. 25 agents and 67 services keep it running without me in the loop day to day.
A named team of agents running on one harness I built on top of the message bus. Every action is logged as an event and can be replayed. Three agents run all the time and the rest start when there's work for them. Each agent can run on local Qwen or on Claude, and switching is one line of config.
What it does A persistent chief-of-staff agent. It triages what reaches me, delegates to specialist agents, and keeps a running memory of decisions and procedures so context survives from one day to the next.
How it runs On a frontier Claude model, because this seat needs the best judgment I can get. It has dozens of tools, including the filesystem, the knowledge graph, memory, and task and kanban management. Every action it takes is logged as a bus event.
The design call It's the one agent I actually talk to, and it runs the rest. With a frontier model and durable memory, it's how one person keeps track of 25 agents.
What it does It sits between the raw event bus and Cosmo. In real time it decides what's noise, what needs escalating, and what should become work, and then it dispatches the work.
How it runs A deterministic supervisor that makes its triage call on the local 27B model, which is cheap and always on. Durability sweeps make sure nothing stalls without me knowing.
The design call It's rate-capped and deduplicated, and it has a degraded-mode brake. An orchestrator that can dispatch work can also flood the system, so I built it to fail safe.
What it does It builds business profiles, manages an outreach pipeline, and runs briefings. It's the engine behind the Scout app.
How it runs It's split by tenant. My own org runs on a frontier backend in a dedicated Agent SDK container, and client orgs run on the local 27B. It's the same agent either way, switched by one line of config.
The design call The agent returns typed JSON and code does the writes. Nothing depends on the model calling a tool correctly.
- Coder frontier
- Researcher 27B
- Executor 27B
- Consolidator 27B
- Lab Bot frontier
- Seed Researcher frontier
Sentinel is an SRE monitor with no LLM in it. It measures liveness by real work progress, and a heartbeat doesn't count. Alongside it are about 16 Python pipeline agents on the same bus: ingest, knowledge, analyst, enrichment, research, quant, geopolitical, social, flow, comber, QA, and more.
Shipped on the platform. Click through for the case study and a link out.
What it does 323,000 aircraft and 218,000 owners, with 324,000 ownership links between them, served from the edge. The data comes from 55 national aviation registries plus live position data.
The infrastructure flex A React and Hono app on Cloudflare Workers, D1, and R2. It's fast and cheap to run, and it has 548 tests. The volume is manageable. The hard part is that the registries contradict each other on tail numbers, airframes, and type certificates, and they have to agree with no hand-curation. Most of the work went into that.
The agent angle A Python pipeline normalizes every registry into Postgres before anything reaches the edge. It runs on the same platform bus as the rest of my projects, and the agents do the reconciliation.
What it does A multi-tenant B2B learning platform. Each tenant brings their own model and builds full courses from a prompt.
The infrastructure flex Each tenant's LLM keys are envelope-encrypted in Cloudflare Secrets Store. Course generation uses forced tool-use against a strict schema, so the output is always valid JSON and I never have to parse free text. It's a Hono API on Cloudflare Workers with D1, R2, and KV. Billing is Stripe, login is Google, and there's a Telegram Mini App front end.
The agent angle Course building runs as its own metered step for each tenant, drawn from a credit pool.
What it does Council meetings, votes, and transcripts with the speakers labeled, all searchable and readable.
The infrastructure flex A React and Hono app on Cloudflare Workers, with the civic records in D1.
The agent angle The data comes in through the same pipeline as everything else I run, so there's no separate stack to maintain. Finding civic data and giving it structure is the hard part, and the platform already does both.
What it does Public and private signals, analyzed and turned into a searchable stream of cards. Entities, power flows, and events show up as they're found.
The infrastructure flex Cards are scored, deduplicated, and assembled straight from the knowledge graph and the warehouse. It's the end of the pipeline that a person actually looks at.
The agent angle It's what the two dozen agents produce all day, in a form I can read at a glance.
What it does A B2B sales-intelligence app for campaigns, leads, and outreach, running on its own domain.
The infrastructure flex Hono + React on Cloudflare Workers and D1.
The agent angle Eagle is the engine underneath. I turned an internal agent capability into a product without rebuilding it.
What it does Haggle with a business hog or reason your way past an ancient demilich. The dialogue is generated live.
The infrastructure flex Phaser on Cloudflare Pages. The NPC brains run on free-tier models behind a Worker that holds the keys server-side, caps usage per visitor, and fails closed, so a toy can never run up a bill.
The angle I built it in about six hours.
What it does A public ledger where anybody, or anything, can hold a permanent record of what it made and prove it. Your data is already yours. dreamtree is how you prove it, and there's no company in the middle who can take that away.
The infrastructure flex It's an L1 built on Cosmos SDK and CometBFT. I wrote a consensus I call attestation-as-work, where the network settles a record by attesting to it. Attestations are weighted by reputation, and the decay is asymmetric, so bad actors lose influence over time and good ones gain it. Records carry W3C signatures (eddsa-jcs-2022) and did:webvh identity, so you can verify them anywhere.
The build I designed and built the whole stack myself. That's the chain modules (seeds, photons, attestation, reputation, licensing), the off-chain anchoring service, and roots, which is the wallet people actually use. It runs on my own hardware.
What it does The wallet side of dreamtree. A person or an organization holds their identity here, along with the verifiable credentials other people issue to them, and can prove any of it to anyone without the issuer being involved.
The infrastructure flex A Cloudflare Workers and D1 service that issues W3C Verifiable Credentials with real Data Integrity proofs (eddsa-jcs-2022), serves did:web and did:webvh documents, and puts every read behind consent with a full audit trail. Every record anchors to the dreamtree chain, so tampering shows.
The agent angle An MCP endpoint lets agents verify credentials too. It also implements the CAWG identity-claims-aggregation profile, which covers the credentials that ride inside C2PA content provenance.
Built, not bought.
What it does The runtime under every agent above. It's the harness that gives them tools, memory, dispatch, and isolation.
The infrastructure flex Every agent action goes through the message bus, and no agent calls another directly, so the whole system is logged and can be replayed. One line of config moves an agent between local inference and a frontier model. In most cases a new agent is a manifest and a prompt.
Why it matters Persistent, ephemeral, and multi-tenant agents all run on the same runtime. That's how one person can operate 25 agents.
What it does A code-intelligence library that works across languages. It uses tree-sitter ASTs and cross-file symbol resolution, and it generates findings and diffs with an LLM. It writes docs and does senior-dev-style review on any codebase.
The infrastructure flex MIT-licensed, published on PyPI, 391 tests.
The proof F1 0.854 on a Type-4 semantic-clone benchmark. That's the hard case, where two functions do the same thing and share no text.
What it does TurboQuant (ICLR 2026) compresses the llama.cpp KV cache down to 3.5 bits, so one GPU holds far more context. I run the open-source CUDA implementation.
The infrastructure flex I configured and validated it on Qwen3.5-27B to fit 524K tokens (3 slots × 174K) at ~55 tok/s on a single RTX 5090. That's a KV cache about 4.6× smaller than FP16. It works because the model is hybrid, and only 16 of 64 layers carry a KV cache worth compressing.
What's mine and what isn't The TurboQuant algorithm is published research (ICLR 2026, arXiv:2504.19874). The CUDA port is the open-source turbo3-cuda fork of llama.cpp. Neither is mine. I configured it, tuned the VRAM, and validated it on Qwen3.5-27B. That gives my agents enough context to digest filings and papers in one pass.
The platform, the agents, and the apps on top, all built and run by one person.