One command runs the plan

In October, Metis learned to draft a plan: every step, the agent that takes it, and the steps that are yours. But the plan still moved one agent at a time, and you started each one. You ran the agent, waited for its pull request, merged it, and ran the next.

That post ended with this line: “it does not run your agents.” This post is about what changed. You now start one agent, the coordinator. It starts the others, inside the session you started.

What you type, and what happens next

In the repository, run:

zeus run coordinator P-n

P-n is the plan’s number. Then the coordinator works in a loop:

the plan
  └─▶ the coordinator takes the next ready step
        └─▶ it starts that step's agent as a worker
              └─▶ the worker opens one pull request, on the plan's branch
                    └─▶ the pull request merges, Zeus completes the task
                          └─▶ the coordinator wakes, and takes the next step

A worker is the step’s own agent: worker A for a daemon step, worker B for an app step, and so on. It works the way that agent always works — its own copy of the code, its own rules, the tests once at the push, and one pull request. You do not open a window for it.

The pull request goes to the plan’s own branch, plan/P-n, not to main. If the tests passed at the push and GitHub can merge it, the coordinator merges it into that branch. If not, it asks you to.

Several workers run at once: one per agent, up to the number of slots on your Mac. A slot is one place for a worker. Your Mac starts with 3, shared by every repository on it. The plan’s row in the app says what is running, in one line:

run by the coordinator · 1 of 3 slots held · building T-45 (worker B) · waiting: T-44 needs you

The coordinator keeps going until the plan reaches its next milestone. That can take days. Then it opens one pull request, from plan/P-n to main. From there, your own process takes over.

What reaches you, and what does not

Very little, on purpose.

Work a worker finds along the way does not come to you. It goes to Metis, which sorts it onto the plan.

A worker’s question goes to Metis first. If you already decided it — in the plan you approved, say — Metis answers it from there. If Metis cannot, the question comes to you in the Zeus app, in a list called Needs you, already prepared: what is being decided, why it came up, and what Metis recommends. The worker’s own words sit under it. You answer in the app, and the worker goes on.

Needs you is the one place where the decisions that are yours wait, each ready to make quickly. The coordinator keeps it fresh, and adds its own stops there too: a step that failed, a worker that stopped too many times, a task waiting on a merge.

Zeus builds Zeus

We build Zeus with Zeus, and the coordinator is no exception. We built a first version of the coordinator so that it could build the next one.

Every time it stopped to wait for a person, we changed it to move faster. It now begins its first step as soon as you start it. It starts a stopped worker again without asking, up to three times. And it no longer waits for you to merge each pull request.

That last change matters most. Workers’ pull requests merge into the plan’s own branch, so the plan keeps moving. The merge to main happens periodically, once per milestone, through your own CI/CD process.

Where the coordinator stops

The coordinator’s work ends at the milestone: one pull request from plan/P-n to main. From there, your own review and CI/CD process takes over, the way it does today.

It does not change your agents. Each worker keeps its own rules, and any gate an agent already has still comes to you, in the Zeus app.

How to get it

Then, in a repository with a plan in motion, run zeus run coordinator P-n. The guide Let the coordinator run the plan → walks through it, slots and all.