Chapter 22 · agent-neuron · Lab
Running my business like a video game
The jobs I hand to agents, on one screen like a strategy game’s: every job a card, each move picked from what the job can do, a model per step, and the turn drawn live while it plays, down to the minutes it waited on me.
Why a game
Six jobs, one terminal. A daily search review of a site, a feature from the ask to a reviewed branch, a three-way review of a branch, a batch of small changes, a marketing brief, and a hello that proves the engine still starts. Each one took a line of JSON. Its shape lived in my head.
The fix wasn’t another command. It was one screen, opened by one command. It knows what each job needs and draws each run while it happens. It looks less like a control panel than a strategy game: my units on a board, the moves each one can make, a turn that plays out on its own. And a pause when it needs me.
Everything below is the studio as I run it, shot the day I wrote this. The interactive figures run on a recording and on invented data. Never on a live run.

The ladder under the board
The rules of this game aren’t all mine. m4lkxx’s piece on harnesses, loops and graphs names three jobs a person does for an agent, until a system does them: give it a place to work, tell whether it was right, decide what happens next [m4lkxx]. The studio turned out to be the screen over all three.
- The board is the harness made visible, what’s left when you take the model out of the picture: the place it works, its files and its walls [m4lkxx].
- Each job is a graph: every step does one thing, and an arrow goes in only where a step really waits on another [m4lkxx].
- Each step that can be wrong runs in a loop whose check can fail [m4lkxx].
- And the desk is where the graph spends my attention, the thing he saves for places with no undo [m4lkxx].
The board
Each job is a card. Before I touch any of them, every card answers the same questions:
- What it does: the first paragraph of the job’s own README.
- What it touches: the step count, “writes” when a step declares an effect and “asks you” when one is a person, all badges the engine works out from the network file.
- What it takes: its inputs, and the model mode.
- What it did: its last runs, each with what it answered and how many model calls it made. Its trace and result are one click away.
A job that writes asks twice. The first click shows, word for word, the job’s own paragraph about what it changes. Only “Run it” starts it. It’s the one place the studio slows me down on purpose.
A job that only reads runs on one click, and one that writes waits for a person to say so. That’s his gate on what an undo costs, pointed at me [m4lkxx].


Choosing a move
A good game never makes you type a move. It offers the moves this unit can make. A job’s form does the same. Each job names only the fields a person types (the site, the ask, the branch), and each time the form opens the studio asks the jobs repo for the lists.
- The sites come from the checkouts on this machine: a new one shows up the day it’s cloned.
- The branches are the picked site’s own. Pick another site and they’re asked for again.
- Until I type my own, the branch name is made from the sentence.
- The job’s example fills in everything else a request carries (the site’s conventions, its rules files), and all of it stays editable under the form.
The form shows the exact lines it will send before anything runs. Tick two sites, get two lines. Two runs of the same job.

2 runs, these lines
{"at":0,"source":"request","payload":{"dataClass":"P1","feature":"Show a hint under the missed-calls calculator when the share is over 100","slug":"show-hint-under-missed-calls","site":"harlow-vale"}}
{"at":0,"source":"request","payload":{"dataClass":"P1","feature":"Show a hint under the missed-calls calculator when the share is over 100","slug":"show-hint-under-missed-calls","site":"northdock-bakery"}}The loadout
Every model step in a job has its own name. That lets a run move any step to another model, for that run only. The plan on a bigger model this time, the edit on a cheaper one, the rest left as they were.
The loadout has rules the game won’t let me break. A pick changes the model, never where the data may go: each channel has a limit, and a step runs under the lower of the pick’s and its channel’s. Whatever I picked, work that reads private material is refused by a cloud model before anything is sent. Only models on a short list can be picked.
That’s his rule for where a model belongs: anything deterministic is code, and a model goes in only where a different answer could also be right [m4lkxx]. The feature job has twenty-six program steps. Five call a model. The other twenty-one are code.
In his terms, the class limit is a wall. It’s code the engine runs, not an instruction the model reads, so it holds even when the model is wrong [m4lkxx].

- termsnames the words to search the repo forsent, masked
- planpicks the files and the approachsent, masked
- replanplans again after a person says nosent, masked
- editwrites the exact editssent
- repairfixes an edit that did not applysent, masked
5 sent (4 masked), 0 refused
The turn plays out
Run sends the job through the jobs repo’s own runner, the one a terminal uses too, and the engine streams every event as it happens. Each step lights up on the page as its input arrives, and the card keeps the log’s last lines. I can close the tab. The run goes on, and a reload picks it up again.
Figure 3 is one real turn, the feature run that built issue 36 on this site: a hint under the missed-calls calculator. It’s slimmed down to the steps’ names and the times. Nothing of the code or the site is in it.
Inside the turn, the steps keep score the way his loop does: what failed and what was seen go back to the step with the failure, and the same failure twice stops the run for me instead of spending the budget on it [m4lkxx]. The feature card’s history has one of those stops.

- Events so far
- 175 of 175
- The desk
- closed
- Waited on me
- 6 min 32 s
- The whole run
- 11 min 12 s, 8 model calls, my waits 58%
Your move
The feature job stops twice for me: once to approve the plan, once to sign off the result. Each stop is a card on the desk. The engine serves it as a page, and the studio shows it in place. In that run I kept the plan waiting four minutes, the result two. Together that’s more than half the turn.
The day before I wrote this, a run passed every gate. Then it lost its result. The sign-off sat behind a step that joins my answer with the run’s summary, and that join could hold the summary an hour at most: a card that may wait a day, behind a join that waits an hour, is an hour-long card (decision 0024). A turn that waits on a person has to be allowed to wait.
A join holds each input for its own time, and drops it once the time is up (SPEC 5.2). The fix let that time be a day, as long as a person’s card may wait. It also has every card announce itself as it opens.
He puts the goal as “a system that needs you once, at the right place” [m4lkxx]. That run needed me twice, at the plan and at the result. The two waits were more than half the turn.

- Now (a day)the turn completes
- Before decision 0024 (an hour)the summary expired first: the result is lost
The replay and the rulebook
Every run leaves a trace. The Trace view lists every event, filterable, and shows the payload of whichever one I pick. Replay draws the run again on the network, at any speed. When a turn goes wrong, that’s where I watch it go wrong.
The network file is the rulebook. In the Design view it’s a form built from the engine’s own schema, with every field the file may carry, and the engine judges it on every edit. If I can’t write a rule into the file, the run won’t keep it.
He ends on learning: fix each failure at the layer that owns it, so the same class of failure never costs twice [m4lkxx]. Not a note to be more careful, but a change to the engine’s rules and a test that a join may wait a day (decision 0024). That’s how the lost result above got fixed.


The rules underneath
The studio decides nothing about a network. The engine does. Its check judges the file on every edit, and its describe draws the network before any traffic. Its live stream is the trace itself, every event once and in order, so the page can only show what happened (SPEC 9.1).
The pause for a person belongs to the engine too. A human neuron shows its input to a person and takes a typed reply, and an empty reply is quiet (SPEC 3.4, decision 0008). The engine’s tool surface refuses any network that has one: the desk is the person’s, not a tool call’s. So the studio runs those jobs on the command line, where the desk opens.
A step that writes says so in its file. Once a call of one has started, the engine never cuts it, whatever newer input arrives (SPEC 11). That’s what the badge on a card reads. It’s also why the card asks twice.
Run it
npm run studio # in the jobs repo: the studio on 127.0.0.1, its Jobs view open
npm run doctor -- --fix # a new machine: the repos beside it, the engine at its pinned commit, the guard hooks
npm run job -- hello # the same run the Jobs view starts, from a terminalWhat it is not
Not a product. The studio and the jobs repo are private tools, and local ones. The page listens on this machine only and has no accounts. Another machine reaches it through a tunnel, or runs its own copy.
Not a scoreboard. The run history counts calls and shows answers. The game is in how the screen feels, and it makes no claim that the work goes faster, costs less or is any fun. Nobody wins.
Not confined everywhere. Only on macOS can the engine hold a program to the files it names (decision 0018). So a run on the Linux machine I’m setting up is unconfined, and so is a run on the Mac without the flag. And a run’s history stays on the machine that ran it.
Not his system. The piece names no product and no model. Nothing here says he’d recognise the studio as his ladder, either. I’ve borrowed his rungs to describe what I built [m4lkxx].
Sources
m4lkxx Harness, Loops, Graphs: What Each Layer Fixes and What It Breaks. An article posted on X, 2026-10-25, read in full through its public embed; read 2026-11-18.
Three jobs a person does for an agent until a system does them: a place to work (the harness), whether it was right (the loop), what happens next (the graph); a wall is not an instruction; feedback that names what failed, and the same failure twice stops; deterministic steps are code and a model only where another answer could also be right; gate on what an undo costs; fix a failure at the layer that owns it.
- the three jobs; the harness and its walls; the loop and its feedback; the graph, its gates on what an undo costs; learning at the layer that owns a failure; the close
The piece named is paraphrased, but for one quotation, and was read on the date shown. Everything else on this page is my own tool and my own runs, shown in shots and one slimmed recording, which are not sources.
