Building an Agent Team I Will Never Have to Open

This week I built an agent team to take over a loop I had been running by hand. The loop was simple enough that I had never thought of it as a loop. I would talk through an issue with the agent until it was clear, then ask it to implement, then read what came back against what we had agreed. Three steps, every feature, over and over. I only noticed it was a procedure when I tried to hand it off.

So I built the team to run those steps without me. Now I describe the issue once and walk away, and ten minutes later there is a branch waiting. The interaction that used to be a two-minute back-and-forth is a single long run I do not sit and watch.

Except it does not work. It has not stopped not working. Every test run, something small and important breaks, and I go in and fix it. I am not running the team yet. I am shaping it, one failure at a time.

This is just the ladder we have always climbed

There is a comfortable way to read what I am doing, and I reached for it first. This is just the abstraction ladder, the one the whole history of the work has been climbing. We stopped writing machine code and let a compiler handle it. We stopped thinking about the engine and learned to drive the car. We left the factory floor and ran the factory from an office upstairs. Each step, we moved up a level and stopped looking at the one below, and each step was progress. Managing a box that writes the code instead of writing it myself is the next rung, and standing on it is supposed to feel like arriving.

I made this exact case myself, a few months ago, in From Prompts to Harnesses. I traced how the work kept moving up the stack, from wording a prompt to managing context to building the system around the model, and I treated each move as a clean gain. I still think that post had the direction right.

What it never asked is the question this week put in front of me. Not where the leverage goes, but how the person standing on the top rung ever learned to trust the rung underneath.

I trust the box because I have watched it break

Here is the part I did not expect. I do trust this team, more than I trusted the agent back when I was prompting it by hand. And the trust has almost nothing to do with reading its output.

It comes from the failures. For two weeks the team has broken in front of me in small, specific ways: a review step that waved through something it should have caught, an implementation that solved the wrong half of the issue, a handoff where the second agent quietly lost what the first one knew. Each time, I went and found the seam and closed it. None of those fixes were deep. I was not learning how the model works; that stays a black box to me, the same as it is to everyone. I was learning the gap between what I assumed the team did and what it actually did, which turns out to be a different thing entirely, and the only place that gap shows itself is in the wreckage of a run that went wrong.

That is what backed trust is. Not a belief that the box is correct, but a worn map of the exact ways it goes wrong and what I did about each one. I did not read my way to that map. I broke my way to it.

What sends you down the ladder is failure

Once I saw it that way, the pattern stopped being about me. Every abstraction works the same trick. It lets you ignore the level beneath it, right up until the moment it fails, and then it sends you down. The driver does not think about the engine until the car will not start. The web developer does not open the library source until it does something the documentation swore it would not. You can stand happily on a rung for years, and the thing that finally drives you to the one below is always the same: it broke.

Nobody descends an abstraction for fun. Curiosity carries a few of us part of the way, but the thing that reliably pushes a person down into a layer they would rather not understand is failure. It becomes a teacher only when it breaks in your hands.

Harness engineering is the craft of pulling the rungs out

Now hold that next to what I actually do all day. The name for this week’s work is harness engineering, and its definition is unforgiving: when the agent makes a mistake, you do not just fix the result, you re-engineer the system so it can never make that mistake again. That is the whole craft. You do not patch the output. You close the failure for good.

Look at what that means, rung by rung. Every failure I close is a descent that will never have to happen again. The review step that missed something now catches it, so nobody who runs this team after me gets sent down into that seam; for them, it does not break. The shape of the job is the thing I did not see coming. I climb down to each failure, understand it, and engineer the rung away so that neither I nor anyone after me ever has to make that climb again. Every rung I pull is a small permanent win, and every small permanent win is one less reason anyone will ever look.

None of it is hidden from the next person. The fixes are right there to read, in the config, in the prompts, in the notes I leave behind. They can see exactly what I changed and why. What they cannot read is the part that mattered, the two weeks of watching it fail that turned those changes from instructions into trust. They inherit my conclusions. They do not inherit the descent that earned them.

The ladder does not end here. New failures keep arriving at new layers, and every model upgrade re-breaks something I thought was settled. But each particular rung I pull stays pulled. The specific way the handoff used to drop context is gone for good, and gone with it is the specific lesson that failure used to teach.

I am the last one this team will force to learn it whole

For a while I told myself this was the next person’s problem, not mine. I had done the descent. The map was mine. Whatever the newcomers missed, I had already earned and got to keep.

That is the part that does not hold. Backed trust decays, because the box does not sit still. The model underneath gets upgraded and re-breaks things I had settled. The team drifts as I add to it. Keeping my trust current would mean going back down to the new failures as they surface, re-earning it against the box as it actually is now, not as it was the week I learned it.

And the work has quietly done something to me on top of that. The dense phase, the two weeks where the thing broke a dozen ways a day and every fix taught me something, happens once. I am living through it now, and I am closing it as fast as I can. After this, the failures will be rare and shallow, and rare shallow failures do not teach you a system the way a flood of them does. I built my trust in a fire I am busy putting out. Anyone who starts on this team later, including me a year from now, starts on a box that mostly works, and a box that mostly works never forces the whole descent. I am not the last person who will fix this team. I am the last who was made to learn all of it.

Keep one rung to climb down by hand

There is one more rung I could pull, and it is the one I keep being offered. I could point an agent at the team itself and let it do the shaping: watch its own runs, catch its own failures, write its own fixes. The tooling is nearly there. It would take the last manual thing off my plate, the going-in-and-fixing that eats my evenings.

I am not going to, for as long as the team still breaks. The reason is not that the agent would do it badly. It is that this loop, the breaking and the fixing, is the only rung I have left to climb down, and it is still the one thing teaching me the box. Hand it off, and I buy back my evenings at the price of the last descent I own.

So that is the small thing I am keeping while the breaking lasts. I fix it myself, by hand, slowly. Every other rung I will pull without looking back, because pulling them is the job. This one I climb down on purpose, for as long as it still holds my weight. I am building a box that no one, myself included, will ever need to open. I would like to be the last person who still could.