Portfolio
A private AI platform, the autonomous workforce that operates it, and the apps shipped on top — built and run solo. Click any tile for the case study.
The foundation everything else on this page runs on.
What it does Public and private data flows through an ingestion layer into a knowledge graph and a time-series warehouse, where an autonomous agent layer reasons over it and ships results to a live dashboard.
The infrastructure flex Go services move work across a message bus where every agent action is an auditable event — no agent calls another directly. Postgres, Neo4j, Elasticsearch, and Redis sit behind it, held together by ~2,200 automated tests. It runs on two consumer desktops over a 10 GbE link — most of the intelligence is local, so there's no per-token bill for the volume work.
How it's operated I set direction; the platform runs the loop — roughly two dozen agents and services keep it moving without me in the path.
A named team on one custom, bus-native harness — every action a logged, replayable event. Three run persistently; the rest spawn on demand. Backend (local Qwen or frontier Claude) is a config line, switchable per agent.
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 across days.
How it runs On a frontier model (Claude Opus 4.8) because this is the judgment seat. Dozens of tools — filesystem, the knowledge graph, memory, task and kanban management — and every action is a logged bus event.
The design call One agent I actually talk to, running the rest. Frontier-backed and given durable memory, it's what makes a 20+-agent operation legible to one person.
What it does Sits between the raw event bus and Cosmo, deciding in real time what's noise, what's an escalation, and what should become work — then dispatching it.
How it runs A deterministic supervisor with a local-27B triage call (cheap, always-on) and durability sweeps so nothing stalls silently.
The design call Built to fail safe — rate-capped, deduplicated, with a degraded-mode brake — because an orchestrator that can dispatch is an orchestrator that can flood.
What it does Builds business profiles, manages an outreach pipeline, and runs briefings — the engine behind the Scout app.
How it runs Split by tenant: my own org routes to a frontier backend (a dedicated Agent-SDK container); client orgs run on local 27B. The same agent, swapped by a config line.
The design call Structured by contract — the agent returns typed JSON and code does the writes, so nothing depends on the model calling a tool correctly.
- Coder frontier
- Researcher 27B
- Executor 27B
- Consolidator 27B
- Lab Bot frontier
- Seed Researcher frontier
Sentinel (a non-LLM SRE monitor — it measures liveness by real work progress, not heartbeats) plus ~16 Python pipeline agents on the same bus: ingest, knowledge, warehouse, 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 710,000 aircraft and 313,000 owners served at the edge — 1.25M entity relationships — assembled from dozens of aviation registries plus live position data.
The infrastructure flex A React + Hono app on Cloudflare Workers, D1, and R2 — fast and cheap, with 435 tests. The volume isn't the hard part; making tail numbers, airframes, and type certificates agree across contradictory sources with no hand-curation is. That resolution layer is the product.
The agent angle A Python pipeline normalizes every registry over the same platform bus into Postgres before the edge ever sees it — the workforce does the reconciliation.
What it does A multi-tenant B2B LMS — "tools, not cards" — where each tenant brings their own model and builds full courses from a prompt.
The infrastructure flex Per-tenant LLM keys are envelope-encrypted in Cloudflare Secrets Store, and course generation uses forced tool-use against a strict schema, so the output is always valid JSON — never a parsing gamble. A Hono API on Cloudflare Workers with D1, R2, and KV; Stripe billing, Google auth, a Telegram Mini App front end.
The agent angle Course-building runs as a dedicated, metered, per-tenant generation step gated by a credit pool — productized AI, not a demo.
What it does Council meetings, votes, and speaker-labeled transcripts, made searchable and readable.
The infrastructure flex A React + Hono app on Cloudflare Workers over a civic corpus in D1.
The agent angle The data lands through the same platform pipeline as everything else, as additive handlers — no separate stack to maintain. The hard part of civic data is sourcing and structuring it; the platform already does both.
What it does Public and private signals analyzed into a searchable card stream — entities, power flows, and events surfaced as they're found.
The infrastructure flex Cards are scored, deduplicated, and assembled straight from the knowledge graph and warehouse — the human-facing end of the whole pipeline.
The agent angle It's what the two-dozen-odd agents produce all day: the platform's output, made legible at a glance.
What it does A B2B sales-intelligence app — campaigns, leads, and outreach — on its own domain.
The infrastructure flex Hono + React on Cloudflare Workers and D1.
The agent angle Eagle is the engine underneath — a clean example of productizing an internal agent capability without rebuilding it.
What it does Haggle with a business hog, 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 Built in about six hours — a sample of the velocity, not the headline.
What it does A public ledger where every person, organization, agent, or thing holds the permanent, verifiable record of what it creates. Your data is already yours; dreamtree is how you prove it — with no company in the middle who can revoke it.
The infrastructure flex An L1 on Cosmos SDK + CometBFT with a novel attestation-as-work consensus: the network settles records by attesting to them, weighted by a reputation signal with asymmetric decay so bad actors fade and good ones compound. Records carry W3C signatures (eddsa-jcs-2022) and did:webvh identity, so they verify anywhere, not only inside dreamtree.
The build Designed and built the whole stack solo — the chain modules (seeds, photons, attestation, reputation, licensing), the off-chain anchoring service, and roots, the wallet at the human edge. Running on private infrastructure.
What it does The wallet at the human edge of dreamtree: where a person or organization holds their identity and the verifiable credentials others issue them, and can prove any of it to anyone — without the issuer in the loop.
The infrastructure flex A Cloudflare Workers + D1 service that issues W3C Verifiable Credentials with real Data Integrity proofs (eddsa-jcs-2022), serves did:web / did:webvh documents, and gates every read behind consent with a full audit trail. Every record anchors to the dreamtree chain for tamper-evidence.
The agent angle An MCP endpoint lets agents verify credentials too, and it implements the CAWG identity-claims-aggregation profile — the credentials that ride inside C2PA content provenance.
Built, not bought.
What it does The runtime under every agent above — the harness that gives them tools, memory, dispatch, and isolation.
The infrastructure flex Every agent action flows through the message bus and is auditable — no agent calls another directly, so the whole system is logged and replayable. One config line swaps an agent between local inference and a frontier model; a new agent is a manifest plus a prompt, no runtime code.
Why it matters It runs persistent, ephemeral, and multi-tenant agents on one substrate — the reason one person can operate a 20+-agent organization.
What it does A polyglot code-intelligence library — tree-sitter ASTs, cross-file symbol resolution, and LLM-generated findings and diffs. Auto-docs and senior-dev-style review that run on any codebase, not just mine.
The infrastructure flex MIT-licensed, published on PyPI, 354 tests.
The proof F1 0.854 on a Type-4 semantic-clone benchmark — the hard case, where two functions do the same thing with no shared text.
What it does A CUDA implementation of TurboQuant (ICLR 2026) KV-cache compression for llama.cpp — squeezing the KV cache down to 3.5 bits so one GPU holds far more context.
The infrastructure flex Configured and validated on Qwen3.5-27B to fit 524K tokens (3 slots × 174K) at ~55 tok/s on a single RTX 5090 — ~4.6× smaller KV than FP16. It works because the model is hybrid: only 16 of 64 layers carry a KV cache worth compressing.
What's mine vs. what isn't The TurboQuant algorithm and its 3.5-bit math are published research (ICLR 2026, arXiv:2504.19874) — not mine. The CUDA port to llama.cpp, the VRAM tuning, and the validation on Qwen3.5-27B are — which is what gives the agents the long context to digest filings and papers in one pass.
The platform, the workforce, and the apps on top — built and run by one person.