Many agents, one machine to share.

An agent is cheap to start, so you start several. What they work on is not cheap, and there is only so much of it: one live website, one phone on the desk, a handful of simulators, a processor that a local model can fill by itself.

Left alone, agents take what they need when they need it. One publishes over another's half-tested work. Two install onto the same simulator. Four ask the same local model to think at once and all four crawl. None of them is wrong, and nobody is in charge.

Trainyard is in charge. It knows what is shared on the machine, who is using it, and who is waiting, and it makes each agent take its turn.

Things that go out

Publishing the website, building the Mac app, installing on the phone. One at a time, in order, on a train.

Things in use

The phone you are testing on, the app the agents work inside. Held while they are busy, so nothing lands on top.

Things there are only so many of

Simulators, and turns on a local model. Lent out from a pool, with a queue for the rest.

A pool is a set of things on the Mac that only one agent can use at a time. An agent asks for one, is told which it got, and gives it back when it has finished. If none is free it waits in line, in the order agents asked.

Nothing is kept by an agent that has stopped. A loan lapses by itself when its holder goes quiet, so a stuck or forgotten agent cannot sit on a simulator all afternoon.

Simulators

Every simulator on the Mac is in a pool. An agent asks for the kind it needs, such as a recent iPhone, and gets one of its own, started if it was off. Another agent's install to that simulator waits.

A local model

A model running on your own machine has a ceiling: ask it for too much at once and everything slows. Set how many turns it may run together, and agents take a place and wait for one. Today an agent asks for its place; Ripul does not yet take one for it.

Per machine

Pools belong to the Mac, not to a project, so agents on different projects share the same simulators fairly.

Agents working side by side update the same website, rebuild the same Mac app and install onto the same phone. Trainyard takes those jobs one at a time, and waits for the right moment before doing anything that would interrupt someone.

Tracks

A track is a job, such as publishing the website or building the iPhone app. A project's tracks are saved with the project, so everyone working on it shares them.

Trains

A train is one run of a track. Every agent that asked while it was getting ready rides the same train, so one release serves them all.

Holds

Testing something? Hold it, and the trains that would disturb it wait. A hold lets go by itself after a while.

Held-back changes

Mark a change as not ready and no train will carry it out, nor anything built on top of it.

A step that interrupts people, such as restarting the app the agents are working inside, waits until those agents have finished what they are doing. Only saved work goes out.

Open Trainyard and you see what is going out now, what is waiting, what is held and by whom, and what went out last. An agent that asked for a release is told in its own conversation when it has gone out.

Hold with a swipe

Keep your phone or a test device undisturbed while you try something.

Run a job

Start a track yourself. It joins the queue like any other.

Skip the wait

Send a waiting train now. Ripul asks first, because the agents it was waiting for are interrupted.

Cancel

Stop a train at once.

A release train is a practice from teams that publish many times a day. Changes do not go out one by one: they ride a train that leaves from a known point and carries everything that was ready, and anything that misses it takes the next one. Agents change things faster, and more of them at once, than people do, so the practice matters more.