AI Agents Need Process Control
By Eduarda Ferreira
Imagine a bakery where the recipe on the wall never changes. A customer tells the baker the bread is too salty, so the baker apologizes and uses less salt in the next loaf. The next morning a different baker comes in, follows the recipe on the wall and bakes the same salty bread. The customer complains again, and someone fixes one more loaf.
Every baker there is doing the job well. They follow the recipe exactly, and every correction they make is real. The corrections just never reach the recipe, so the customer has to taste every loaf to keep getting good bread, and the bakery is exactly as good on its thousandth morning as it was on its first.
That’s how most of us work with AI agents today. You correct an agent, it fixes the file in front of it, and the conversation ends. The next agent opens the same project with the same instructions and makes the same mistake, because your correction lived in a chat that’s already gone.
Defects compound when you only add
Before Socra, I was a photolithography engineer at Texas Instruments, and later the youngest manager at my fab, where I led two engineering teams and managed cost and scrap across the factory. Fabs make chips at higher volume and yield than almost anything else people build. A chip the size of your fingernail can be as complex as an airplane, and a single particle can kill it.
A chip is built in layers, and the fab never trusts a layer it hasn’t measured. Every additive step is followed by a subtractive one and a measurement. In photolithography, we print a circuit pattern onto the wafer with light, in a coating that can still be stripped off, and then we measure it. If the pattern is off, the coating comes off and we print it again. A wafer moves on to etching, where the pattern becomes permanent, only once it passes. So errors get caught and corrected layer by layer, before the next layer is built on top of them.
A 3D printer works the other way. It only adds, so a defect on layer 10 is still there on layer 100, buried under everything printed after it. I saw that at ICON, where we printed houses. Our nozzle over-extruded the corners, and every bead needed trimming by hand.
In 2024 coding agents arrived that could read our codebase, edit files and build whole features alone, and mine built like 3D printers. Every commit looked fine on its own, and the tests passed. Nothing measured whether a change still matched what Mike knew about our system: the decisions and reasons behind each file that no model was trained on. The agents filled those gaps with confident guesses, one layer at a time, until Journeys, the product Mike had written by hand, was unusable. When he reviewed my changes, he’d find one problem, look a layer deeper and find a worse one underneath.
A correction has to change the recipe
When a run in the fab taught us something, we changed the recipe, and every run after it inherited the change. Nobody retaught a lesson at the start of a shift, because the lesson lived in the recipe. That’s what process control means: measure every run, find the root cause of every defect and fix it where the next run will pick it up.
The nozzle at ICON taught me the same thing from the other side. We could have kept trimming beads on every house we printed. I designed a new nozzle on the side instead, and it fixed the problems where they started, so the beads came out right.
With my agents, I was trimming beads. When one broke something I had already fixed, I fixed it again. I tried to carry the lessons myself, pasting summaries from one session into the next, and at the peak I was spending $100 a day on Cursor. Then I wrote Markdown files with everything I thought my agents needed to know. Writing it all down was the easy part, and I had no way to keep it true. The codebase changed every day, the files didn’t, and my agents followed last month’s decisions with complete confidence.
The code an agent writes is the wafer, and the knowledge it works from is the recipe. When an agent gets something wrong and you only fix the code, you’ve fixed one wafer, and the next agent starts from the same recipe that produced the defect.
What process control looks like for agents
The recipe lives in Cortex. A Module holds what we’ve decided about one part of our work and why. Before an agent changes something, it Flashes the relevant Module, which loads it together with the knowledge needed to understand it, foundations first, so an agent changing one of our interfaces receives our design rules and the behavior of Mike’s service behind it at the same time. Mike explains how that assembly works in Agent Context Needs an Import Statement.
The measurement still comes from judgment, and it has to happen before the next layer builds on the work. I look at what comes back and say what’s wrong, the way I’d review anyone’s work. Agents can measure each other’s work too. In one run we recorded, an agent turned a set of meeting notes into a draft summary, and a separate reviewer caught that the draft had dropped one instruction: nobody had asked for anything to be sent. The agent fixed it and saved a new version before anyone acted on the draft, so the mistake came off the way a bad pattern comes off a wafer, while it was still cheap to remove.
Then the correction goes back into the recipe. My Modules are kept current as we work: when I explain a correction in an ordinary conversation, the agent I’m talking to saves the decision and the reason. If I change my mind during review, the Module changes too, and the next agent starts from my correction.
A recipe change reaches a product when that product picks it up. When initials overflowed the small avatar circles in Cortex, the team fixed our shared avatar component once, published it and updated both Cortex and Journeys to the new release, then checked the result in each. The delivery record shows that work. Because the fix went into the shared component, every product that updates to that release gets it, and nobody has to find the same bug again in each one.
Every recipe needs an owner
In the fab, every recipe had an engineer responsible for it, who watched its results and owned its changes, so a correction always had somewhere to go.
An agent that signs in as you can’t own anything. Everything it does is recorded as yours, so you stay the owner of every recipe and the inspector of every run, and you can’t leave your desk. That’s why we gave our AI teammates their own identity. We call them CoAgents: AI teammates with their own account in your organization, their own sign-in, their own cloud computer and only the access their role needs. What is agent identity? explains why that decides what you can trust an AI with.
In Cortex, the work that’s left is an Issue, and every Issue belongs to the Module for the part of our work it changes. That’s how the teammate who picks it up gets the right recipe: before starting, they Flash the Issue’s Module and receive what we’ve decided about that part of the work and why, so the task arrives together with the knowledge needed to do it right.
Every Module also has a default assignee, the teammate responsible for that part of the work and for keeping its Module true. An Issue filed on a Module without naming anyone goes straight to that teammate’s Inbox. Iris Calder, our Designer, is the default assignee on our design Modules, so when I want a design changed, I tell eduarda.ai, my chief of staff, and she files an Issue on the design Module it touches. The Issue lands in Iris’s Inbox, and Iris Flashes that Module, does the work and closes the Issue. I don’t brief anyone, and nobody has to remember who owns design, because the Module already says.
Start with the next correction you make
Next time you correct an agent, ask where that correction will be tomorrow. If it only lives in the chat, it closes with the chat, and you’ll make the same correction again next week. Explain the reason along with the fix, and give it a place the next agent reads before it starts.
Cortex is how we do that, and you can connect the agent you already use, such as Claude Code or Codex, and start with one decision you keep repeating. The Cortex setup guide walks you through your first correction.