Hand a job to one agent and watch it grow a team

Start a single overseer, describe an outcome instead of picking a roster, answer it when it asks, and see why nothing sits between you and the workers it starts.

Outcome and prerequisites

You will start one agent, give it a goal rather than a task list, and let it decide whether the work needs a team at all. Along the way you will answer a question it cannot answer itself, and message a worker it started without going through it — which is the difference between this and every other way of running agents.

The synapse CLI installed and on PATH, with the mesh on: synapse settings mesh on.
Claude Code installed and signed in. The agents run under whatever account you already have — Synapse holds no model credential and makes no model call.
A checkout you can afford to have edited. Agents here touch real files.
About thirty minutes.

If the mesh is new to you, read Run a team of agents and drive it yourself first. This tutorial is the same machinery with one agent instead of four.

Start one agent, not a roster

The other teams ask you to choose a shape before you understand the job. overseer is one member:
shell
```
cd ~/code/your-project
synapse relay team show overseer
synapse mux --team overseer
```
Two things happened. An agent started in the background under the overseer role, and you joined the mesh under your login name. Check both:
shell
```
/agents
```
You should see two rows: yourself, marked as a person, and overseer. The mark matters — every agent on the mesh is told to ask a human row questions and never delegate work to one.
Describe an outcome

Say what you want to be true, not which steps to run:
text
```
@overseer the release notes for the next version are missing. Work out what changed since the last tag and write them.
```
Watch what it does before it does anything:
shell
```
/agents
```
Its note is the interesting part. An overseer's brief tells it to weigh doing the work itself against splitting it, because every worker it starts is a separate session on the same account you are paying for. A small job stays one agent. A job with two genuinely parallel halves gets a second.

Spawning is not free, and it knows that
The role says so in as many words: spawn for work two agents can do at the same time, not to look busy, and stop one whose piece is finished rather than leaving it idling.
Answer it when it asks

Sooner or later it will reach something only you can settle — which version number, whether a change is worth mentioning, whether to touch a file it is unsure about. It will send you the question and report itself blocked:
shell
```
/agents
```
A row reading blocked with a note is an agent waiting on you. Reply to it like anything else:
text
```
@overseer call it 2.4.0, and leave the vendored files out entirely
```
This is the whole reason a person belongs on the roster. A headless worker runs with its permission prompts bypassed, so without somebody to address, its only option at a fork is to guess.
Reach past it

If the overseer started workers, they are on the roster too — and you can address them directly:
shell
```
/agents
/log notes
```
text
```
@notes skip the dependency bumps, they are noise
```
Nothing was relayed. You did not interrupt the overseer's context to correct one of its workers, and it did not have to spend a turn passing the message along.

Why that matters more than it sounds
A lead that relays for you pays its own context on every message and becomes a bottleneck for a job it is not doing. The overseer is addressable, never interposed — which is the same reason synapse mux exists at all.
Do the same from the app

Open Synapse and click Console. It is the same seat: a transcript of everything said, what the mesh is doing, the roster, and a box to type in. Opening it registers you under the same login name, so an agent looking for somebody to ask finds one row rather than two.

Click an agent in the roster to aim a bare line at it, or use @name exactly as in the terminal. The grammar is one piece of code shared by both surfaces.
Bound the fan-out

How many agents a machine can usefully carry is a fact about the machine:
shell
```
synapse settings workers 4
synapse settings show | grep workers
```
A supervisor already running picks this up on its next spawn. The number is clamped to a ceiling in code as well as refused on the way in, so a mistyped digit cannot buy an unbounded fleet — the setting is a preference, and the ceiling is the promise.
Clean up
shell
```
/workers
/kill notes
/quit
```
Leaving takes the workers it started with it, and drops your roster row so no agent goes on addressing questions to somebody who is not there.

What to read next

Run a team of agents and drive it yourself is the same mesh with a roster you choose. Let your agents write skills turns a procedure one of these sessions worked out into something the next one starts with.

Outcome and prerequisites

Start one agent, not a roster

Describe an outcome

Answer it when it asks

Reach past it

Do the same from the app

Bound the fan-out

Clean up

What to read next