Skip to content

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 studio’s Jobs view: the advise and aeo cards with their summaries, badges, inputs, mode and Run buttons, their last runs below, and the advise network drawn on the right.
The board: every job a card, the selected one’s network on the right. Cost figures are masked in every shot.

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].

The aeo card: eight neurons and a writes badge, its README’s first paragraph, the form and mode pickers, Run, and its two last runs with what each answered.
One card: what the job does, what it touches, what it takes and what it did last.
The confirm on the aeo card: “This job has effects”, its own paragraph on what it changes, and the Run it and Cancel buttons.
A job that writes asks twice, in its own words.

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.

The feature job’s form: the site picked from a list, the ask typed in, the branch name made from it, the updates entry box, the branch to start from, and the collapsed sections below.
Choosing a move: the site from the checkouts on this machine, the branch name made from the sentence.
Sites

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"}}
Figure 1. Tick sites and write the ask: the lines a run would carry, one per ticked site, and the branch name made from the sentence until you type one. The sites are invented; the rules are the studio’s.

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].

The Models section of the feature form: five steps, four on their defaults and edit changed to Claude Opus, highlighted.
The loadout: one step changed for this run, the rest on their role’s model.
  • 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

Figure 2. The feature job’s five model steps, each on its role’s model or one you pick. Mark a step as reading private material and see which picks still send it. P1 is private work, P2 my own material; a cloud channel carries P1 at most, masked.

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.

The Jobs view with the feature card selected and its thirty-two step network on the right, replaying the recorded run at about the middle; the card’s last runs include a sign-off that timed out after an hour.
The turn, replayed on the board: the feature network mid-run. The card’s first row is the sign-off that timed out the day before (decision 0024). Paths are masked too.
11 min 12 s
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%
requestclocktermsgrepreproplanbriefplan-okgorefusedreplanopeneditannounceapplyrepairhandofffailedfullbrowseragainsmalllargelightreviewrecheckjudgereceiptsummaryreportresult-oksignoff
Figure 3. The recorded run, replayed: each step lights while its input is in hand and turns green when it answers; the two pink steps are me, at the desk. The marks on the scrubber are my two waits. A recording of one run on one small change, not a benchmark.

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.

The desk inside the studio: release-note proposals from the engine’s public example, each draft beside its proposal with Approve, No and a box for my own text.
Your move: the desk the engine serves, shown in place. The notes are the engine’s public example, invented.
2 h
  • Now (a day)the turn completes
  • Before decision 0024 (an hour)the summary expired first: the result is lost
Figure 4. Slide to when I answer the card. The join holding the run’s summary keeps it for its own time and drops it as expired at the end; my answer completes the turn only if the summary is still there. Before decision 0024 that time was an hour; now it is a day.

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 Trace view after the release-notes run: every event with its time, type, sender and payload, ending in finished, and the network on the right.
The replay: every event of the run, filterable, with Replay to draw it again.
The Design view of the release-notes network: its name and description, its four neurons with their kinds, the first neuron’s fields, and the links, the network drawn on the right.
The rulebook: the network file as a form, judged by the engine on every edit.

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 terminal
CommandThe jobs repo and the studio are private, so these run only on my machines. The engine underneath is public, and its README runs every demo of the series without either.

What 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].

overfocus/agent-neuron

Sources

  1. 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.