I build agent-native systems — workflow runtimes, LLM serving pipelines, and the evals that keep them honest — and write about the seam between a model and a product.
Bet that reliability comes from STRUCTURE, not model intelligence — constrained generation, atomic decomposition, a validated IR spine, type contracts.
Small models (down to 8B-class) reliably write workflows that look like they need a frontier model — far fewer tokens, far higher pass rate.
Made the visual graph a read-only projection of typed functions — parsed from the AST — instead of a thing you edit both ways.
Killed the 20-year round-trip drift by construction; the model authors typed code, the compiler is the gate.
Built recall + cross-encoder rerank for an agent calling it in a loop — a summary plus structured pages, not a search box.
Recall gains proven with paired significance tests on a public set — real, not a vibe.
Two-layer agent: an OS-level brain for intent + a safety countdown, an editor-level executor for the edits — driven by voice from AR glasses.
Hands-free, glanceable multi-step engineering, away from a keyboard.
The single move that mattered most across every version of my workflow engine — drag the hard-coded facts out of the prompt and let them arrive at runtime, so the prompt only ever teaches shape.
I rebuilt a workflow engine around one rule — code is the single source of truth, the visual graph is a projection of it. Twenty years of round-trip tools say that's the only direction that holds.
Turning natural language into an executable workflow with one agent is a slog. I split it into a fast agent that scopes and a heavy one that builds — and the win came from giving each its own clean context.
Everything I write circles one problem — turning a probability distribution into something a person can trust. This is the throughline. Start here.
Most AI products don't fail on the model. They fail on the absence of a way to know whether a change made things better. The eval harness — not the model — is the asset you own.
A search box is built for a human who scans one page of results. A retriever for an agent is a function it calls in a loop. That one difference changes the whole pipeline — and how you prove it got better.
A backend that "survives concurrency" is making a tail-latency claim, not an average one. Here is the staged pipeline I run behind an AI answer box, and the three boring guardrails that keep the slow tail from eating everyone.
Constrained generation, atomic decomposition, a validated IR. Make a small model reliable by building the reliability into the structure — not by buying it with a bigger model.
Code as the source of truth — typed workflows, read-only graph projections, designers that author skills. Built for models as the primary author.
Paired significance tests, probe suites, honest baselines — the net that confirms an intuition, not the gate that replaces it. Range over the whole stack, from TTS to retrieval to LLMs.