Participants and lanes

A participant is a file in your repository. A lane is its card in the panel. How a team is set up, what each one holds, and what the panel lets you do with them.

A participant is a file #

A participant is .autodev/participants/<id>.md: frontmatter, then the participant's own instructions in prose. The filename is the identity. A frontmatter id that disagrees with it is ignored.

.autodev/participants/<id>.md

---
provider: codex
failover: [claude]
moves: [say, work_done, handoff, wait, gate, done]
---
Your instructions to this participant.

Field	What it holds
`provider`	The agent CLI it runs on: `claude`, `codex` or `antigravity`. When it is absent, the run's `provider` applies.
`model`	A model name, as a free-form string. Absent means the CLI's own default.
`effort`	An effort level, as a free-form string. Absent means the CLI's own default.
`failover`	Where it runs when its provider is rate limited: `provider[:model]` entries, in order.
`moves`	The moves it may make. The default is all six.
`persona`	A path to a file whose body replaces this file's body.

model and effort are never checked against a list. AutoDev keeps no list of models, so a model that shipped this morning works this morning.

AutoDev's own commits leave .autodev/ out, so a participant file is versioned only if you commit it. That is your call.

Setting up a team #

There is no implicit team. A project with no participant files runs nothing, and the panel opens on team setup. Three ways lead to a team, and all of them write participant files:

Drag a provider from the providers row into the grid. It adds one participant, named after the provider.
Start from a template: solo is one participant that owns the objective, builder-reviewer adds a reviewer that checks each change before the run moves on, and manager-builder-reviewer adds a manager that splits the objective and hands out the blocks. The participant file format describes what each template writes.
Start with your default team, which is copied into the project. A team you set up is kept as the default when there is none yet, and Save as default team replaces it with this one. It lives in ~/.autodev/team/, so it is set up once and not per folder.

A team that came with the project does not run until you confirm it on this machine. Its files become CLI flags and instructions, and a file can name anything. The panel says This project came with a team, and Use this team confirms it. autodev team does all of this from the terminal.

Pinned or default #

A participant with no model and no effort is unpinned: AutoDev passes no model or effort flag, and the CLI's own default applies. Pin and unpin are on the lane, and they write the same two keys into the file. A pin applies from that participant's next turn, never mid-turn. It names a model of the participant's own provider, so on a failover hop it does not apply. The run-level model and effort are not a fallback: no participant's turn reads them.

Who speaks first #

The team is sorted by name. When nobody hands the turn on, the turns follow that order, and the first name opens a thread. Each lane carries its place as a number, and the panel spells the order out under the grid: They take turns in this order — <names> — because a team is sorted by name, and <first> opens a thread when nobody hands the turn on. Rename to reorder.

Adding a participant from the panel writes a file named after its provider, then claude-2, claude-3 and on. Renaming changes the order, and it moves the file with its pin and instructions, and the session with it. The thread keeps the old name on the posts already written: a post records who spoke.

A lane is a card #

The CLIs destination shows one card per participant. A card is that participant's lane. It shows:

the name and the provider;
the number of its place in the order;
its state: its turn, idle, open in an editor tab or not installed;
when it is running on another CLI, one line that says why, such as Running on codex: claude hit its usage limit and is back at <time>.;
a footer: default, default · <model it last ran> or default · model not reported by codex, or pinned · <model> · effort <effort>;
the last three things it said or ran.

The actions are Open or Focus tab, pin or unpin, rename, Edit prompt, which opens the participant's file in the editor, and Remove. Rename and Remove are refused while the participant is taking a turn, and the card says <id> is taking a turn — wait for it to finish, or stop the run first. A lane whose provider is missing says <provider> is not available on this machine. and offers Adopt a binary… and Copy install. The terminal does the same: autodev team edit prints the file's path, and pin, unpin, rename and remove do what the buttons do.

What Open does #

Open starts a terminal in an editor tab named AutoDev · <id>, running the participant's CLI interactively. The command line carries the participant's pin and AutoDev's own MCP server, added to yours and never replacing it. It is where you log in to a CLI or pick a model. It is not where a thread turn runs: turns run headless, from the daemon.

Open sends nothing to the run. The run does not pause, and a turn that is live keeps writing to the repository while you type in the terminal. The panel has no control that takes a lane's session away from the thread, or forks it.

The participant file format has the exact format of the file. The shared thread covers what a participant does on a turn, and Providers and failover covers failover. Every config key lists the run-level provider, which a participant that names none runs on.