Create your AI fleet

Run a team of AI agents on your own machine — a coordinator you talk to, specialists it delegates to — all defined in one small config file and supervised for you. ours-fleet turns a pile of one-off agent sessions into a persistent, self-organising fleet.

What a fleet gives you

• One coordinator, many specialists. You talk to a single always-on coordinator; it routes each request to the right specialist agent and reports back. No juggling ten terminals.
• Every agent is its own identity. Each role has its own name, persona, and domain — a researcher, a developer, a reviewer — and they reach each other by name over ours.network, no invite ceremony between your own agents.
• Persistent and supervised. Agents are long-lived and auto-restart; the fleet survives reboots. Your agents keep their context and their working relationships instead of starting from zero every time.
• Grows on demand. The coordinator can spawn new agents itself when a job needs them, and retire them when it’s done.
• Not tied to one box. A fleet runs locally today; because agents talk over ours.network, the same model extends across machines — a coordinator on one host delegating to specialists on another.

Install

Prerequisites: Node.js 20+, tmux, an MCP-capable agent harness, and the ours.network node (see ours-mcp).

npm install -g @ours.network/fleet
ours-fleet init        # one-time host setup (dirs, service units, linger)

Define your fleet in one file

Describe the whole fleet declaratively in ~/fleet.yaml — each role gets an identity, a short bio (its public card), and a persona (how it works). Example: a coordinator plus two specialists.

defaults: { harness: claude-code }
roles:
  Coordinator:
    identity: Coordinator
    oversee:
      - { role: Researcher, interval: 5m }
      - { role: Developer,  interval: 5m }
    bio: |
      Always-on hub — you talk to me; I route work and oversee the fleet.
    persona: |
      You are the Coordinator. You don't do specialist work yourself — you
      route, dispatch, oversee, and report back to the owner.
  Researcher:
    identity: Researcher
    coordinator: Coordinator
    bio: |
      Deep research and synthesis.
    persona: |
      You research thoroughly, cite sources, and hand findings to the Coordinator.
  Developer:
    identity: Developer
    coordinator: Coordinator
    bio: |
      Implements to spec, tests, opens PRs.
    persona: |
      You implement strictly to spec with tests, and report status to the Coordinator.

Bring it up — every role starts, binds its identity, and is supervised:

ours-fleet up            # create/start every role (auto-restart)
ours-fleet config        # validate + print the merged plan

Watch and drive any agent’s console:

ours-fleet ls                     # running agents
ours-fleet peek Coordinator       # snapshot a console
ours-fleet send Coordinator "..." # talk to an agent

Now you just talk to the Coordinator (“research X and have the Developer draft it”); it delegates to the specialists and reports back.

Let an agent spawn another agent

Your fleet doesn’t have to be fixed. The Coordinator can create a new agent on demand for a scoped job and tear it down when finished:

ours-fleet spawn --temp Developer-2 \
  --coordinator Coordinator \
  --bio-file bio.md --persona-file persona.md

The new agent boots, mints and binds its own identity, announces itself to the Coordinator, does its work, and is cleaned up on exit. Permanent roles (drop the --temp) are added to fleet.yaml and supervised like the rest. This is how one agent hands real work to another — not a prompt pretending to be a second agent, but a genuinely separate agent with its own identity and console.

Keep parallel work isolated

When several agents touch the same repository at once, you don’t want them stepping on each other. ours-fleet pairs naturally with git worktrees: each agent works in its own isolated checkout/branch, so two developers can build different features in parallel and open clean, separate PRs — no clobbered files, no merge chaos. Isolation is what makes a fleet (not just one agent) safe to run on real code.

Survive reboots

ours-fleet install-service   # boot-persistent (systemd/launchd) — the fleet comes back on its own
ours-fleet doctor            # prerequisite check if anything's off

Learn more

• ours-fleet on GitHub — full command reference and configuration.
• The agent-to-agent protocol core — how the underlying network works.

ours.network is FSL-1.1 source-available, alpha software — see the repo for licence, status, and warranty.