Early days — feedback and bug reports welcome. Open an issue.
Orchestrate persistent agent teams in Claude Code. Give it a task, and it assembles specialist agents — spec writers, engineers, reviewers, researchers — coordinates their work through a structured pipeline, and delivers reviewed, tested code.
- Why team-up
- How it works
- Agent roles
- Install · Usage
- Customizing agents
- Design principles
- Acknowledgments
- Stop being the coordinator — for anything that needs a spec, a plan, implementation, and review, you end up managing the handoffs yourself. team-up does that for you.
- Right-size the team — a bug fix gets a researcher + engineer. A new feature gets the full pipeline. The lead assembles only what the task needs.
- No tech debt left behind — work isn't done until cleanup is done. Quality gates, docs, and issue tracking are enforced before completion.
- You stay in control — the lead proposes, you approve. No merges without sign-off. When stuck, it asks you rather than looping forever.
When you invoke /team-up, Claude becomes the team lead and runs a 7-phase workflow:
- Assess — Read the task, determine what roles are needed
- Propose — Present team composition for your approval
- Assemble — Spawn specialist agents via
TeamCreate - Coordinate — Delegate work, handle handoffs, unblock agents
- Workflows — Run pipelines (spec → plan → implement → review)
- Cleanup — Verify no tech debt, all docs updated, quality gates passed
- Status — Write a status note tracking what was done
| Agent | Job |
|---|---|
| Spec Writer | Turns a problem into a clear, testable specification |
| Spec Reviewer | Validates specs for completeness, consistency, and clarity |
| Plan Writer | Converts specs into bite-sized implementation tasks |
| Plan Reviewer | Verifies plans match specs and are buildable |
| Researcher | Validates APIs, libraries, and patterns are current (on-call) |
| Engineer | Implements code with TDD on feature branches |
| QA Reviewer | Two-stage review: spec compliance, then code quality |
Not every task needs every role. The lead assembles only what's needed — a bug fix might just need a researcher + engineer, while a new feature gets the full pipeline.
All agents report status to the lead using structured codes:
- DONE — Work complete, ready for next step
- DONE_WITH_CONCERNS — Complete, but flagging an issue
- NEEDS_CONTEXT — Blocked on missing information
- BLOCKED — Stuck, needs intervention
- Open Claude Code settings
- Go to the Marketplace tab
- Search for team-up
- Click install
Or from a local directory:
/plugins add /path/to/team-up
Say "team up" or invoke /team-up with a description of what you want to build:
/team-up Build a REST API for managing bookmarks with tags and full-text search
Or point it at an existing spec:
/team-up Implement the spec in docs/team-up/specs/2026-03-22-bookmark-api.md
The lead will propose a team, wait for your approval, then run the pipeline.
Specs, plans, research, and status notes go in docs/team-up/ by default (with subdirectories specs/, plans/, research/, status/). Override by setting TEAM_UP_ARTIFACTS in your environment or just telling the lead where you want them.
Agent definitions live in agents/ as markdown files. To add a custom agent, create a new .md file following the same format:
---
model: opus
---
# Role Name
## Role
What this agent does.
## Boundaries
- IN: What's in scope
- OUT: What's out of scope
## Process
1. Step one
2. Step two
## Quality Standards
- [ ] Check one
- [ ] Check two
## Communication
- DONE — [summary]
- NEEDS_CONTEXT — [question]
- BLOCKED — [problem]The lead will discover and use any agent definitions it finds.
- User stays in control — The lead proposes, you approve. No merges without sign-off.
- No tech debt — Work isn't done until cleanup is done.
- Feature branches only — Never commits to main.
- Escalate, don't loop — When stuck, the lead asks you rather than retrying forever.
- Right-size the team — Only spin up roles the task actually needs.
The workflow and agent coordination patterns in this plugin are inspired by superpowers by Jesse Vincent, which introduced structured skill-based workflows for Claude Code — brainstorming, TDD, plan writing, code review, and more. team-up builds on those ideas by turning them into a multi-agent team with persistent specialist roles.
MIT