AI teammates, not AI tools.

You decide. Agent delivers.

The autonomous loop

Human kickoff

You bring the goal — a rough idea, a bug, a feature.

Explorer agent

Refines the idea into a self-standing ticket.

Planner agent

Drafts the approach; the plan names real files and steps.

✓ Plan review

A reviewer signs off before a line of code is written.

Developer agent

Implements on a branch and opens the PR.

✓ Review

A reviewer signs off again before merge.

CI
✓ green → merge
✗ red → Developer
Merge agent

Squashed to main; the cycle re-arms for the next ticket.

Deploy optional

Optional — ship the merged change to staging or production.

Auditor files new tickets → back to Planner — the loop closes and the next cycle re-arms.

Seven session modes

team

Three-agent relay: planner writes the plan, reviewer gates it, developer implements, reviewer reviews and merges.

duo

Two agents: dev owns planning + implementation, an independent reviewer authored neither the plan nor the code.

adhoc

Single agent owns the full cycle — planning, implementation, review, merge, and notification.

explore

Open-ended investigation; no repo required, no delivery code — crystallises tickets that hand off to delivery.

audit

Quality auditor for the repo; files structured triage tickets about merged work, never writes delivery code.

caucus

Two peer agents deliberate — a proposer opens a position, a challenger stress-tests it — converging on tickets.

live

Bare-bones single agent in the current directory with the native REPL — no relay, issue queue, or PR workflow.

Why teammates, not tools

Custom protocols, per repo

Layer repo-specific rules on top of the standard agent constitutions. Each project teaches the team its own conventions, verification steps, and boundaries.

standard constitution+ CLAUDE.md+ agents/*.md= this repo’s rules

Fresh context per ticket

Context is cleared between tickets. A reviewer re-reads the next diff cold, with none of the implementer’s heavy state carried over — so review stays independent.

ticket #1 → done── context cleared ──ticket #2 → fresh start

Autonomous conflict resolution

When agents disagree on design or direction, caucus convenes two peers to deliberate to a concrete conclusion — resolving locally instead of escalating to you.

proposer ⇄ challengerdeliberateconclusion → ticket

Auto-pickup of the next ticket

After a merge the system re-arms itself: it resolves the next ready ticket and starts again — finishing one thing and picking up the next without being re-invoked.

merge #142→ next-work→ implement #143

See it run

$ cd ~/projects/acme-api
$ adhoc                       # one agent: claim → implement → PR → notify

[mux] session acme-api_adhoc_claude ready
[mux] next-work → implement #142
      … plans, edits, runs the tests …
[mux] opened PR #143 · notified you

Ready to hand off the busywork?

My AI Team ships as part of the bundle — $5/mo or $49.99/yr (USD).

See pricing & get the bundle