Blog

This morning the one Slack message I actually rely on never arrived. The cause was a worker that ran four minutes too long — and had already succeeded by the time my own safety timer declared it dead. The fix wasn't a bigger timeout. It was admitting the briefing had been waiting on forty minutes of work it never reads.

Last time I counted from an index. This time I went straight to the 2,608 transcript files on disk: 91,908 turns, 15.58 billion tokens, six models, and the same three patterns that keep reproducing no matter how I measure.

Every night a worker reads about eighteen sources, scores them with a local model, and files code-change proposals against my own repos. Last week it read the announcement of a map of the AI ecosystem's gaps — and proposed using it to find its own.

I pointed roughly 105 read-only agents at my entire homelab and AI stack, made each finding survive an adversarial verifier before it counted, and triaged the result into a real backlog. 165 confirmed findings. The top one was my own exposed API key.

15.6 billion tokens in a quarter. Metered at API rates, that's about $19,000 — except 90.5% of it was cache reads, and without caching the same work would have cost $88,000. The receipts, and what they say about model routing.

I'm job hunting in AI Product. So I built a Forge worker that scrapes RemoteOK and Hacker News every morning, scores every posting against my preferences with a local LLM, and Slacks me only the real matches. The product decisions mattered more than the code.

My AI wrote code with a server-side request forgery hole, an inverted build config, and the wrong OAuth defaults. Then it shipped — safely — because a second model, told to break it, caught all three before I did. The generator doesn't have to be clean. The verifier has to be ruthless.

The vaguest, most-skipped part of any project is the kickoff — turning a fuzzy idea into something a team, or an agent, can actually build. So I built the kickoff as a product, with a real input→output contract: idea in, populated project board out. The highest-leverage PM work is removing ambiguity at the start, and you can systematize it.

I spent about fifteen years designing product and UX across studios and startups, then delivered enterprise Salesforce platforms as a program and project manager, and now I build agentic AI infrastructure. The throughlines surprised me. Designing for users and designing for agents turn out to be closer than they look.

My busiest user is an AI agent that never opens the dashboard — designing for a model calling tools is the same craft as designing for a person tapping a screen.

People ask how one person ships this much alone. It isn't the AI. It's twenty years of range — a trained eye and builder's hands that the tooling finally stopped making wait.

In three months, one model — Claude Fable 5 — burned 2.1 billion tokens across my stack. It's my most expensive model, and I pointed it at exactly one job. Here's where every token landed.

One of my dashboards showed all-clear while 4,278 tasks piled up in queues it never checked — the fix wasn't better monitoring but teaching the software to admit what it can't see.

The Postgres lake now holds 145,481 Claude Code turns across 342 sessions and five months. Bash is still half of everything, cache_read crossed 18 billion tokens, and 62% of the work lives in one project. A second look at what the receipts say about how an AI builder actually works.

Coquina's dashboard has one user and no marketing funnel — just a login screen for a front door, and a decade of enterprise UI design pointed inward.

Of 49,030 tool calls my AI logged across 342 sessions, Bash is 23,979 — almost exactly half. That number isn't an accident. It's what agentic work actually looks like once you strip away the demos: the shell is the universal interface, and the lesson for anyone building agent tooling falls straight out of it.

My Claude Code telemetry lake holds ~20M fresh input tokens and ~92.5M output tokens — and ~18.4 billion cache_read tokens. That ratio is the whole reason solo AI infrastructure work is affordable on consumer hardware. Here's what prompt caching at that scale actually buys you, what it doesn't, and how it changes the way you structure a long agent session.

A solo operator can't babysit infrastructure. So I built systems that monitor and repair themselves — embedding-drift detection, forgetting metrics, two-stage diffusion retrieval, graph-diffusion consensus, three-tier self-healing, and RL edge-tuning. Reliability isn't a chore you do later. It's a feature you build in.

Forge isn't one big agent that does everything. It's 32 small single-purpose workers coordinated by a 25-step nightly chain. This is the case for a fleet you can reason about — single responsibility, composition, and why I'd rather debug thirty-two narrow workers than one clever one.

After three years living in pro-tier AI tools as a daily driver, the most consistent thing I've found isn't a model limitation. It's the gap between the demo and what survives contact with real work. This is a buyer's discipline, not a teardown — judge an AI product by day 30, not minute 3.

I run 30 local models on a single Apple M4 through Ollama, with no cloud API calls anywhere in the stack. The real lesson wasn't how to fit them on the hardware. It was that you pick the model for the task — and you find out which model by benchmarking, not by guessing.

I once orchestrated a multi-state Go Live for a Salesforce-integrated insurance portal that launched with zero errors and held 98% success over six months. In enterprise delivery the launch is the proof — a launch that breaks is a strategy that failed. That discipline is exactly what I now apply to autonomous AI systems that have to be right by morning with no one watching.

A reasoning model in thinking mode will silently sabotage a structured-output task by spending its whole budget on a reasoning trace. The fix isn't a better prompt — it's matching model class to task class. A short, sharp lesson from a worker that failed green.

I named the parts of my AI infrastructure after brain regions — Hippocampus for memory, Prefrontal Cortex for orchestration, Thalamus for the sensory gate. It started as a joke and became a design tool. A good metaphor makes a complex system legible, tells each part what it's allowed to do, and is, quietly, an information-architecture decision you'll live with for years.

A second Postgres database for raw session telemetry. Why curated memory and raw evidence want different homes, and how to federate search across both.

What 92,653 indexed Claude Code conversation turns reveal about how a single developer actually uses AI tools. 11 billion cache_read tokens, top tools, biggest sessions, and the workflow shape that emerges from the data.

An operating philosophy made explicit: when stuck, just keep moving. Why momentum compounds in solo infrastructure work, and the three disciplines (branch-first, code-review, reversibility) that prevent it from becoming recklessness.

The discipline of shipping every infrastructure change with its own undo. Paired up/down migrations, env-gated features, and why the cost of being wrong should always be bounded.

A regex pattern that almost wrote live API keys into a searchable database in cleartext. A code review caught it in five minutes. Defense-in-depth for privacy redactors.

The afternoon I discovered I'd been about to launch a product into a CNCF-graduated project's namespace. Six hours of naming, a Stripe-style sub-brand architecture, and the discipline of namespace-checks at commercial inflection points.

What happens when you give a data lake a nervous system. Schema-on-read, auto-embedding, auto-linking, and a knowledge graph that learns from what works.

How a homelab project turned into an auto-data lake for AI agent memory, and what it looks like to build infrastructure that might become a company.

Zero dollars per month on AI API calls. Local-first isn't a limitation — it's an architecture decision with real technical advantages.

Whisper STT, GLaDOS TTS, Gemma 4 function calling, and Home Assistant. A fully local voice pipeline across a homelab.

32 autonomous workers, a 25-step DAG pipeline, and GPU coordination on Apple Silicon. Security reviews, code reviews, and tech digests ready by morning.

I mapped my homelab infrastructure to neuroscience. Coquina is the hippocampus, the thalamus filters MQTT events, and the amygdala runs a nightly security review. Here's how it works.