Cede the craft, keep the door

At the scale of one browser game, with two current-generation coding and art agents, and a principal expert in neither craft.

Self-funded editorial, no sponsor. The build used Anthropic Claude Code (game logic and validation) and Google Antigravity (art generation). Disclosure: Google Cloud is a client of The CTO Advisor LLC, and the art in this lab was generated by a Google tool. No party reviewed, funded, or saw this lab before publication; the ruling is the author’s alone.

Click the frame, then use the keyboard or on-screen controls.  Source: github.com/kltownsend/talon-protocol-game

Can a principal who owns only the outcome compose two spiky Artificial Intelligence (AI) agents into one shipped artifact? That was the pitch. The loss condition was quieter and more interesting: a judgment the work needs that lives nowhere in the assembly, invisible until it ships. I built a transforming-mech browser game to find out. I don't know game development. I can't draw, I can't animate, and I couldn't tell you what makes a sprite sheet good. What I knew was how the game should feel to play. The question was whether that one authority, plus a well-placed seam, was enough to ship.

The first two attempts said no, and they failed in a way worth pausing on. Each run handed the whole game to a single agent. One produced correct gameplay with weak art. The other produced strong art with broken gameplay. Neither was a weak engine. Both were a misplaced authority boundary: one agent asked to own two crafts it was only half-competent in. The spiky profile everyone jokes about in these models isn't a bug you wait out. It's the shape of the workforce. You don't fix it by picking a better generalist. You fix it the way organizations always have, by splitting the work along the line where the competence changes.

The seam is a directory

The working run split the two crafts across two agents. Anthropic Claude Code owned game logic and acted as the validator. Google Antigravity generated the art. They coordinated only through a file-based message bus, a directory of JavaScript Object Notation (JSON) messages, because each agent was ephemeral and isolated and shared no memory with the other. One agent posted a request with the sprite spec. The other claimed it, generated the sheet, dropped it at the agreed path, and posted a delivery referencing the file. The validator read the delivery, checked the image against the written contract, and posted an acceptance or a threaded rejection with the exact reason. No party spoke outside the bus.

Half of that contract was fully mechanical, and fully delegated. Dimensions, transparency, frame counts: a sheet whose dimensions were not an exact multiple of the declared cell size was rejected by code, every time, with no judgment involved and no human in the loop. That's the part a deterministic gate owns cleanly, and if you've read the earlier labs in this corpus you know I keep finding the same thing. The gate is cheap, tireless, and honest about exactly what it can see.

Which is why the first sprite matters. It passed every automated check and was still visibly wrong: a gray blob with no figure in it. Debris, essentially. The gate could not see that. A judging seat had to, and the rejection that fixed it was a human-grade note about silhouette, palette, and a hurt frame that was a solid red block instead of a damaged pose. That note is the control point of the whole experiment. The bus can carry the contract. It can never carry the verdict. Across the run, 10 sprite sheets crossed the seam, plus 4 reused single-frame assets, all validated. There was exactly 1 rejection before acceptance, that first player sprite. Every later delivery passed first try.

Where was I in all this?

Directing, but not where you'd expect. Every intervention I made was an outcome call: the weapon should fire in this form, the mini-boss should gate progress, the grounded form should carry more risk. Not once did I correct a palette or a frame. I couldn't have. The art-quality judgment was ceded to the agent, and it happened to hold. In Decision Authority Placement Model (DAPM) terms, the craft was ceded and the verdict was retained, and the run only worked because I was honest about which was which. I could cede art direction because an agent in the loop could judge it better than I could. I retained the one authority I actually held: what the work was for.

So the objection writes itself. Isn't this just delegation? Managers have handed work to specialists forever. Yes, and that's the point. The law is old: judgment has to be sourced or the structure has a void. It's why you hire, why there's a review board, why root-cause analysis exists. What changed is the economics. A model call now fills a class of seams that used to require a hire, cheaply and fluently. But fluent and confident is the exact texture of judgment that hides its own gaps. AI lowered the cost of filling the gap and raised the cost of noticing when it's unfilled. The delegation is old. The camouflage is new.

The line below which nothing is audited

Here's the sharp limit, and it's the finding I'd carry into any enterprise conversation. Borrowed agent judgment is only ever validated up to the resolution of your own acceptance test. My test was whether the game reads and plays right, and the art cleared it. Whether those sheets carry craft debt a real art director would flag on sight is unknown, because nobody in the room had a test at that resolution. For a game, that doesn't matter. The experience was a total acceptance test for the ceded craft: if the mech reads and the fight feels right, the art's internal quality is moot. Now move the same structure to a domain where defects don't surface in the experience. Security. Data integrity. The fault that appears in six months. There, the ceded layer below your acceptance test is unaudited, and that unaudited layer is exactly where the failure lives. That's also where the deterministic gate stops being optional.

I want to be plain about what this lab did not prove. The art agent's judgment was good enough this time, not proven good. It rode on hope below the resolution of my test. The game is the friendly case, where the experience fully tests the ceded craft, and the ruling doesn't extend past it. And it's one game, two current-generation agents, one principal. Nothing here shows the pattern holds at team scale, across more than two agents, or where the crafts are not cleanly separable.

What the lab opened is the question I find more durable than the build. What's the minimum literacy a principal needs to place the seam? Not the craft. I built neither the art nor the code. What I could not delegate was knowing which judgments the work required and whether each one was present. That literacy is the floor. Get it wrong and every downstream seam is placed against a gap nobody in the room is qualified to notice. A seam doesn't manufacture judgment. It only routes judgment that was sourced somewhere, and if it was never sourced, the structure has a void you won't see until it ships.

I got a playable game out of two engines that each failed alone, without becoming the one who integrated them. That was the pitch, and it held. But the artifact that ports to the next project isn't the game. It's the honest inventory of every judgment the work needed and where each one came from. This time the borrowed judgment held. Before you cede a craft you can't judge, ask the prior question: whose judgment is standing behind it, and would you know if the answer were nobody's?

The numbers

Where each layer belongs

Method and disclosure

Self-funded editorial. The playable build was produced by two AI agents coordinating over a file-based message bus. The code and art are public at github.com/kltownsend/talon-protocol-game under the MIT license. The coordination protocol and the validator harness stay proprietary.

The essay on this page was rendered from the lab’s frozen structured record by a model writing under this practice’s voice specification, with a deterministic gate checking every figure against the record before publication. The record is the canonical surface: where prose and record disagree, the record rules.