It usually starts with an orchestration you want to push through in one go: one brief in, a chain of agents working together, a finished result out. And it works, until it doesn't — and then you're left with output that looks convincing but where you can't say what went wrong. Somewhere in step three of seven something quietly went sideways, and the rest of the chain calmly built on top of it.
Most people run agents like a slot machine: type a prompt, pull the lever, hope. The way out isn't more hoping, and it isn't smarter agents — it's a layer between intent and output that refuses to let bad output through. Treat agents like a compiler. Here's the whole idea in fifty seconds:
https://kris-media.fsn1.your-objectstorage.com/kriscoelus/mini-courses/agent-compiler-en-001.mp4
poster: https://kris-media.fsn1.your-objectstorage.com/kriscoelus/mini-courses/agent-compiler-en-001-poster.jpg
The mapping is exact, not poetic. The source is intent — a brief in structured text, not prompt-poetry. The passes are the agents, each with one narrow job. Contracts are the intermediate representation. The typechecker is made of eval gates: the cheap deterministic checks first (does it build, do the tests pass, does it match the schema), and a critic agent where judgment is needed, scoring the previous step and sending it back the moment it falls short. The linker aggregates the loose parts into one whole. And the release gate is a human.
Step by step, that's this:
agent-compiler-flow
AI that only produces is an intern on caffeine. A system that knows which steps must exist, which checks each one has to survive, and what happens when one fails — that starts to look like a factory. Two already run on this architecture: a research engine, where five agents work five angles in parallel, each shadowed by a critic, then a coherence pass and a synthesis pass turn it into one document; and a product engine that builds software phase by phase, with tests gating each phase. It's early work — the research engine runs, the product engine has a first version and isn't autonomous end to end — and non-deterministic by design: the same brief gives slightly different output, and crushing that variation would kill the value. The goal isn't identical output, but output that passes every gate, every time.
The shift that matters isn't making the agents smarter. It's admitting they're unreliable and building the verification around that fact. A compiler doesn't trust the programmer. It checks, and then it checks again.