Cede the craft, keep the door
The pitch: a principal who owns only the outcome can compose two spiky AI agents into one shipped artifact across a file-based seam. The loss condition: a judgment the work needs that lives nowhere in the assembly, invisible until it ships.
By Keith Townsend
The verdict
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.
Play the build
Click the frame, then use the keyboard or on-screen controls. Source: github.com/kltownsend/talon-protocol-game
How I know
Two attempts to build the game with a single agent each failed on a different axis. 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 working run split the two crafts across two agents joined by a file-based message bus. One agent owned game logic and acted as the validator. The other generated art to a written contract, dropped each sheet at an agreed path, and posted the delivery to the bus. The validator checked it against the contract and either accepted it or replied with a specific rejection.
The deterministic half of the contract, the dimensions and transparency and frame counts, was enforced automatically on every delivery with no human in the loop. The first sprite passed every automated check and was still visibly wrong, a gray blob with no figure in it. The gate could not see that. A judging seat had to.
The principal directed the run without expertise in either craft. Every intervention 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 he correct a palette or a frame. The art-quality judgment was ceded to the agent, and it happened to hold.
What the bench measured
The detail
The seam was a directory of JSON messages. Each agent was ephemeral and isolated, sharing no memory, so a durable file-based bus stood in for the channel between them. One agent posted a request with the sprite spec. The other claimed it, generated the sheet, and posted a delivery referencing the file. The validator read the delivery, checked the image against the contract, and posted an acceptance or a threaded rejection with the exact reason. No party spoke outside the bus.
Format compliance was fully mechanical and fully delegated. A sheet whose dimensions were not an exact multiple of the declared cell size was rejected by code, every time, with no judgment involved. That is the part a deterministic gate owns cleanly.
Quality was not mechanical. The first mech sprite cleared every automated check and read as debris. 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. The bus can carry the contract, never the verdict.
The sharp limit is the resolution of the acceptance test. Borrowed agent judgment is only ever validated up to what the retained test can see. The test here 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 had a test at that resolution. For a game it does not matter. In a domain where the defect does not surface in the experience, that unaudited layer is where the failure lives.
Isn't this just delegation? Managers have handed work to specialists forever.
Yes, and that is the point. The law is old: judgment has to be sourced or the structure has a void. It is why you hire, why there is 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 is unfilled. The delegation is old. The camouflage is new.
Where each layer belongs
| Layer | Placement |
|---|---|
Layer 2B · Runtime Application Runtime & Execution The craft. Art generation and game-logic execution were handed to the agents. A deterministic contract gate enforced the mechanical part of each delivery; nothing below the acceptance test was audited. | Ceded |
Layer 2C · Reasoning Agentic Infrastructure — The Reasoning Plane The verdict. Is this good, is it right, does it play the way it should. Held by the human validator. Only judgments the principal had actually sourced could be placed at all. | Retained |
The two questions this lab now knows to ask
Here 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. In domains where defects do not surface in the experience, such as security, data integrity, or the fault that appears in six months, the ceded layer is unaudited, and that is where the deterministic gate stops being optional.
Not the craft. The principal built neither the art nor the code. What he could not delegate was knowing which judgments the work required and whether each 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.
What it did not prove
- The art agent’s judgment was good enough this time, not proven good. It was validated only up to the resolution of the acceptance test; the layer below that rode on hope.
- The game is the friendly case, where the experience fully tests the ceded craft. The ruling does not extend to domains where ceded judgment can harbor defects the experience never surfaces.
- One game, two current-generation agents, one principal. The pattern is not shown to hold at team scale, across more than two agents, or where the crafts are not cleanly separable.
Notes from the author, Keith Townsend
I do not know game development. I knew what I wanted the game to feel like, and that was enough to place the work. Two engines each got half of it, one the gameplay and one the art. The seam let me take the good half from each without being the one who integrated them.
What I keep coming back to is the gap. You cannot replace judgment that was never sourced. This time the borrowed art judgment happened to hold. If it had not, I would have had to find that judgment somewhere else, and that is one more seam. The artifact that ports to the next project is not the game. It is the honest inventory of every judgment the work needed and where each one came from.
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.
Download the raw lab detail (Markdown)