Do I have to write agent prompts from scratch?

No. Fleet ships over 120 built-in templates. Run `fleet template list` to browse them and create an agent from one with `fleet agent create --name --vendor claude-code --template `.

Why does `fleet agent start dev-1` say there is no such agent?

Because `fleet agent start` works on agents that already exist in Fleet's database. Create the agent first with `fleet agent create`, then start it by name. Creation and start are deliberately separate steps.

How do I start every agent in a team together?

Set the same `team` value on each agent in `.fleet/config.yaml`, then run `fleet agent start --team `. Each agent launches in its own tmux session.

Does the team start reacting to GitHub work on its own?

Only after you start the watcher with `fleet watcher start`. The watcher polls GitHub labels roughly every two minutes and dispatches the matching agent. Without it, the team is started but idle.

How to Set Up an AI Agent Team from Scratch

Name: Fleet
Author: Fleet

Going from zero to a working team of AI coding agents sounds like it should require a platform account, a dashboard, and a day of setup. It does not. With Fleet you install a single Go binary, create a few agents from built-in templates, group them into a team, and start the whole team with one command.

This guide walks the complete zero-to-team flow: install, initialize, create agents from the catalog, organize them into a team, start them together, and turn on the watcher so the team reacts to work automatically. Every step is a real command. The one rule that trips people up — you must create an agent before you can start it by name — is called out where it matters.

Before you start

A Linux or macOS machine with tmux installed and on your PATH
Claude Code (`claude`) installed and authenticated — it is the only supported agent runner
Git and the GitHub CLI (`gh`) installed and authenticated
A Git repository you want the team to work in

Install the Fleet binary

Fleet is a single statically-compiled Go binary. There is no Docker, no Node.js, and no package manager requirement. Install it with the one-line script and verify it is on your PATH.

curl -fsSL https://fleetctl.ai/install | sh

# Verify
fleet --version

Initialize Fleet in your repository

Run fleet init inside the repository you want the team to work on. This creates a .fleet/config.yaml file with starter defaults. This is the file where your team lives — every agent, its role, and its team membership is defined here.

cd /path/to/your/repo
fleet init

Browse the built-in templates

Fleet ships over 120 ready-to-use agent templates covering common engineering roles. Each template is a prompt plus a sensible role mapping. Use fleet template list to see the catalog and pick the templates that match the team you want to build.

fleet template list

# Filter for what you need, e.g. reviewers:
fleet template list | grep -i review

Create agents from templates

Create each agent from a catalog template. The --vendor claude-code flag is required (Claude Code is the only supported runner) and --template points at a catalog name. This is the step people skip: fleet agent start <name> only works once the agent has been created in the database. Creating an agent does not start it — it registers it so it can be started, grouped, and configured.

fleet agent create --name backend-dev --vendor claude-code --template backend-developer
fleet agent create --name frontend-dev --vendor claude-code --template frontend-developer
fleet agent create --name tech-lead --vendor claude-code --template tech-lead
fleet agent create --name release-manager --vendor claude-code --template release-manager

# Equivalent alternative using a template id:
# fleet template spawn <template-id> --name backend-dev

Group the agents into a team

Open .fleet/config.yaml and add a team field to each agent that should belong to the same team. Agents that share a team value can be started, stopped, and reasoned about as a unit. Make sure each agent uses a real role string — backend-developer, frontend-developer, tech-lead, release-manager — because the role determines which Fleet skill directive is injected into the agent's handbook. Generic strings like developer inject nothing.

agents:
  - name: backend-dev
    role: backend-developer
    department: engineering
    reports_to: tech-lead
    team: core
    model: claude-opus-4-5
  - name: frontend-dev
    role: frontend-developer
    department: engineering
    reports_to: tech-lead
    team: core
    model: claude-sonnet-4-5
  - name: tech-lead
    role: tech-lead
    department: engineering
    team: core
    model: claude-opus-4-5
  - name: release-manager
    role: release-manager
    department: engineering
    team: core
    model: claude-sonnet-4-5

Start the whole team at once

Use fleet agent start --team <name> to launch every agent in that team. Each agent gets its own tmux session with environment variables like FLEET_AGENT_NAME and FLEET_AGENT_ROLE set automatically. Confirm they came up with fleet status, which reads live tmux state rather than a stored flag.

fleet agent start --team core

# Confirm the team is live:
fleet status

Start the watcher so the team reacts to work

Starting agents launches them once. To make the team react to GitHub activity — picking up labeled issues, reviewing PRs, merging — start the watcher daemon. It polls GitHub labels about every two minutes and processes the Fabric event bus every ten seconds, dispatching the right agent when work appears.

fleet watcher start --supervised

# Verify the daemon is running:
fleet watcher status

Common pitfalls

`fleet agent start <name>` fails if the agent was never created. Run `fleet agent create --name <n> --vendor claude-code --template <catalog-name>` first, then start it. Creating and starting are two separate steps.
Role strings are load-bearing. Only specific roles like `backend-developer`, `frontend-developer`, `tech-lead`, `qa-engineer`, `qa-lead`, `pr-reviewer`, and `release-manager` inject a skill directive into the handbook. Generic strings like `developer` or `qa` hit the default case and inject nothing.
Agents in the same team share the repository's working directory by default. Two developer agents editing the same files concurrently will collide. Give each developer its own git worktree via the `worktree` field if they work in parallel.
Starting a team does not make it autonomous. Without the watcher running, no GitHub label change will trigger an agent. Always confirm `fleet watcher status` after `fleet agent start --team`.
The `--vendor claude-code` flag is required on `fleet agent create`. Claude Code is the only supported runner — do not expect other runners to work.

When Fleet is the right tool

Setting up a full team is worth it once you have more than one stream of work that benefits from distinct roles — for example a developer producing PRs and a reviewer that should pick them up automatically. If you are still validating what a single agent can do on one task, start with one agent and grow the team only when a specific bottleneck appears. A team adds coordination value, not raw speed, so add roles to remove hand-offs rather than to look busy.