My method for working with coding agents

Frontier models are the scarce resource. I use the most capable one for the work only it can do: planning, consolidating findings, deciding, and writing prose that has to be right. Surveys, drafting, building, monitoring, and coordination go to cheaper models, in parallel, each spawned with an explicit model choice. The 235-billion-parameter model on my two DGX Sparks serves the local work, bounded behind gates, checks in code that decide what it's allowed to touch.

Where this came from: on one day in September five agents had to be stopped and relaunched because they'd all started on the expensive model by default. The rule and my exact words are in the record, the library of dated reports and decisions that every agent reads.

Several agents on the same repository at once, from different vendors, on different machines. Instead of locks, an optimistic check: note a file after reading it; check it before writing. Exit 0, go ahead. Exit 3, it changed under you, so re-read and re-apply. Claude Code runs this from a hook; everyone else calls it. A separate claim guards only Docker, config, and restarts, and it's held for minutes, never for a task.

Why not locks: an agent that waits on a lock held by an agent that died is the most expensive kind of idle. And a lock doesn't tell you what changed; the check does.

Every seat (one agent working on one machine) reads and writes one operator-memory library, a git repository synced hourly on each host. A new agent on any machine starts with the same three files and a router that maps the shape of a task to the one document that owns it. Decisions get numbers and a "why" so no agent re-litigates them. Traps get written up with their reintroduction vectors, and you grep that file before you touch the code it describes.

Tokens in and out from the usage block of every response, into a JSONL row. GPU consumers registered in one file, one row per standing lane (a job or service that keeps sending work to a model), added in the same change that creates the lane. Spend caps are computed from the ledger, not from a guess. When a service returns late, the late reply is ledgered too.

Never abort a request to a model you're hosting. Aborting killed the inference engine twice before I wrote this down, and a socket timeout is an abort whether you meant it or not. Race a generous deadline and walk away. Use a small max_tokens instead of a short timeout. Don't retry in a loop. When a caller has to leave, a carrier process holds the connection so the reply still lands.

A model-drafted change to a repository goes through scope, parse, and comment-preservation checks before anyone reads the diff. A model-drafted paragraph goes through a 13-rule linter before it ships (em-dash rate, filler and hedge words, spelled-out decimals, transition-word openers, and so on). A trained model goes through a written gate (a metric floor, a transfer bound, a margin over the previous checkpoint) that was set before training started. A memory claim goes through provenance and modality checks with no model on the verdict path.

The Spark code lane's own verdict was that only about a fifth of past work belonged there. The super-resolution result that cleared its gate was later found to be an artifact and was retracted in the same registry that announced it. The completion gate in Bob's evaluation is partially working, and it's what I'm working on now.

Every change gets a dated report: what was done, what was measured, what's still open. Numbers carry their date. When I'm wrong, the correction is in the record with the original, so the next reader can see both. This page is written under the same rule; the numbers on this site link to where they come from.