tutti

tutti

Terraform-style agent operations for AI coding tools. Define your agent team, run repeatable workflows, track every artifact and gate, and move from messy terminal sessions to versioned engineering operations.

cargo install tutti

Tutti is the operations layer above Claude Code, Codex, Aider, OpenClaw, and API-direct agents. It gives each agent a role, worktree, workflow, audit trail, and dashboard so issue intake, implementation, review, CI, and merge gates happen as repeatable "org code" in tutti.toml.

Agent SDKs help you build agents. Tutti helps you run agent work.

Factory floor: 3 agents working simultaneously, work-item dots flowing through the pipeline, dispatch panel to trigger runs from the browser.

Agent Focus Mode: live terminal output, token usage stats (985K input, 41.6M cache read), prompt bar to send instructions.

Quick Start

cargo install tutti        # install the CLI (requires Rust)
cd your-project
tt init --template rust-cli # generate a Rust CLI agent-ops config
tt run --list              # see workflows generated for this repo
tt run verify --strict     # first successful workflow: cargo test + clippy
tt up                      # launch your persistent agent team
tt serve --port 4040       # inspect runs, agents, logs, and handoffs

Or pick a template explicitly:

tt init --template gstack-startup   # 5-agent interactive SDLC team
tt init --template rust-cli         # 3-agent Rust project team
tt init --template minimal          # 2-agent starter

Prerequisites: Rust toolchain, tmux, and at least one AI coding CLI installed for agent sessions (Claude Code, Codex, or Aider). Command-only workflows such as the Rust template's verify can run before you launch agents. For non-Rust repos, start with tt init or tt init --template minimal, then add the smallest verification command your project already trusts.

The Agent Ops Loop

Tutti models the engineering loop as pluggable operational stages:

1. Intake: GitHub issue, Linear ticket, Jira ticket, local queue, or webhook event.
2. Execution: Claude Code, Codex, Aider, OpenClaw, or API-direct model providers.
3. Review: CodeRabbit, Claude/Codex reviewer packets, human approval, CI, or policy checks.
4. Gate: required checks, resolved review threads, approval state, cost/policy limits.
5. Record: run ledger, artifacts, logs, dashboard events, and replayable state.

The built-in Tutti-for-Tutti workflow uses GitHub issue intake and CodeRabbit review because that is the first concrete adapter pair. It is not the product boundary. The product boundary is the loop.

What Tutti Does

• Defines agent operations as code in tutti.toml: roles, runtimes, workflows, hooks, gates, and policies
• Spawns and manages multiple AI coding agent sessions (Claude Code, Codex, Aider) in tmux
• Isolates each agent in its own git worktree to prevent merge conflicts
• Orchestrates workflows — chain prompt steps, shell commands, and agent coordination into repeatable pipelines defined in tutti.toml
• Web dashboard at :4040 — factory-floor view of all agents with real-time SSE updates, state-driven visuals (working/idle/stopped/blocked), and workflow run tracking
• Agent Focus Mode — click any agent to zoom into full-screen view with live terminal output, token usage, git diff, context health, and a prompt input bar
• Automated SDLC — claim work, plan, implement, test, open PRs, collect reviews, resolve feedback, and enforce merge gates
• API-direct agent loop — optional ModelProvider path with built-in tools, policy gates, SQLite event log, and cost tracking
• Resilience — detects auth failures, rate limits, and provider outages; auto-recovers sessions based on configured strategies
• Issue claim leases — exclusive locks on GitHub issues for autonomous workflow runs

What Tutti Does Not Do

• Not another generic agent framework. Tutti is the operations layer around agent work: lifecycle, workflow, state, review, policy, and observability.
• Not tied to one provider. It can orchestrate terminal agents and, where configured, run API-direct model providers through the same operational controls.
• No API keys required for CLI-agent mode. Existing Claude Code, Codex, Aider, or OpenClaw authentication keeps working. API-direct runs opt into provider credentials explicitly.
• No vendor lock-in. Your agent operations live in a versioned tutti.toml file you can review, fork, and move.

When To Use Tutti

Tutti is strongest when coordination is the bottleneck, not raw model quality:

• You already run multiple agent sessions and the human is doing the routing, tracking, and merge management by hand
• Work splits cleanly into separable lanes: implementation, testing, docs, review
• You want persistent specialists working through a backlog, not five agents crowding one change
• The work contains waiting states that parallel agents can hide: test runs, review loops, CI, retries

A single agent is often the better choice when the repo is small, the task is tightly coupled, or the coordination tax would outweigh any throughput gain.

Configuration

Your agent team topology is defined in tutti.toml — who does what, which runtime, what workflows:

[workspace]
name = "my-project"

[roles]
implementer = "claude-code"
tester = "claude-code"
reviewer = "codex"

[[agent]]
name = "implementer"
role = "implementer"

[[agent]]
name = "tester"
role = "tester"

[[workflow]]
name = "verify"
[[workflow.step]]
type = "prompt"
agent = "tester"
text = "Run the test suite and report results."
wait_for_idle = true

Swap claude-code for codex in [roles] and every agent using that role switches runtime — no per-agent edits. Version it. Share it. Fork someone else's.

Alternative Installation

# Install from crates.io
cargo install tutti

# Or install from source
git clone https://github.com/nutthouse/tutti.git
cd tutti
cargo install --path . --locked

# Initialize in your project
cd your-project
tt init

# Edit your team config
$EDITOR tutti.toml

# Launch
tt up

If tt is not found after install, add Cargo bin to your shell PATH:

echo 'export PATH="$HOME/.cargo/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

Project Status (v0.10.0+ — May 2026)

Built and usable now

• Core CLI commands: init, up, down, status, voices, watch, switch, diff, detect, land, review, send, handoff, attach, peek, logs, usage, run, verify, doctor, permissions, workspaces, issue-claim
• Runtime adapters: Claude Code, Codex CLI, Aider, OpenClaw
• API-direct spine: ModelProvider, OpenAI-compatible provider, tool execution loop, policy gate, SQLite event log
• Template packs: tt init --template gstack-startup generates a fully configured team from built-in or custom templates, with repo auto-detection
• Role mapping: [roles] table maps logical roles to runtimes — swap providers without editing every agent
• Artifact pipeline: prompt steps capture and pass typed artifacts between workflow stages via artifact_glob/artifact_name
• Artifact-polling mode: interactive skills (e.g. /office-hours) wait for artifact files instead of idle detection, enabling human-in-the-loop workflows
• Dependency-aware startup order (depends_on)
• Per-agent git worktree isolation
• Cross-workspace registry (tt workspaces, tt up --all, tt down --all)
• Token/capacity reporting via tt usage for API profiles (plan = "api") from local Claude Code + Codex session logs
• max_concurrent launch guardrails per profile (tt up refuses launches above limit)
• Workspace [[tool_pack]] declarations + tt doctor prerequisite checks (