Sage Feature Team
merrickcr/sage-feature-team
Workflow multi-agent coordenado para desenvolvimento de features com verificação em 3 gates
Ver no GitHubAgent multi-papel coordenado para desenvolvimento de features em Claude Code. Orquestra ProductOwner, TestCreator, Developer, Tester e EpicVerifier em um fluxo de trabalho estruturado, com conhecimento específico do projeto armazenado em YAML e gates de verificação em três níveis.
Instalação
npx convez-ai merrickcr/sage-feature-team1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Desenvolvimento de features complexas com múltiplos stakeholders
- Automatização de testes e verificação de aceitação em paralelo
- Orquestração de equipes de desenvolvimento sem coordenação manual
- Geração estruturada de specs, epics e stories a partir de requisitos
Veredito

Padrão bem arquitetado específico para Claude Code que demonstra orquestração de múltiplos agentes em fluxo real de desenvolvimento. Referência sólida, mas baixa portabilidade para outros ambientes agentic; ideal para equipes já inseridas no ecossistema Claude.
README
A tradução para o português deste README ainda está na fila.
Sage Feature Team
A multi-agent feature-development workflow for Claude Code. Generic agents
(ProductOwner, TestCreator, Developer, Tester, EpicVerifier) coordinated by a
skill acting as Team Lead. Project-specific knowledge lives in each project's
.sage/ directory.
What this is, and what it isn't. This is a pattern built against Claude Code's primitives --
Agent,Task,SendMessage,TeamCreate,shutdown_request,Monitor. The ideas port well to other agentic environments: ephemeral per-story workers, YAML as the event log instead of the message body, three verification gates instead of one, mechanical scheduling instead of LLM-judged routing. The code does not. If you're not using Claude Code, treat this repo as a reference design, not a drop-in framework.
Quickstart (5 minutes)
From a fresh clone to a feature spec drafted by your first sage agent.
1. Install (one-time per machine):
pip install -r requirements.txt
python _tools/install_skill.py
2. Invoke the ProductOwner inline. This repo ships with a bundled example
project (examples/static-site-generator/ -- a small Markdown-to-HTML site
builder) that the demo config points at. From the repo root, in Claude Code:
/sage-po "Add an RSS feed at /feed.xml listing the 20 most recent posts sorted by date"
/sage-po runs the ProductOwner agent inline in the main conversation -- no
team panel, no async coordination. After a few minutes you'll see new files
under _output/:
_output/add_rss_feed/
+-- spec.md
+-- epics/EPIC-1.yaml
+-- stories/STORY-1.yaml, STORY-2.yaml, ...
The spec, one epic, and one YAML per story. Open spec.md for the
human-readable version and the STORY-N.yaml files for the per-story
acceptance criteria that downstream agents work against. That's the
on-ramp -- the rest of sage is what happens when you hand these stories
off to the team.
Want to see what a finished run looks like instead of running one? The bundled example already has a complete run committed: browse
examples/static-site-generator/_output/static_site_generator/for the spec, all 8 story YAMLs + theirSTORY-N.implementation.mdsidecars (Developer's AC map), the threeverification/EPIC-N.mdreports (EpicVerifier output), andtokens.md(per-worker token telemetry). No install required.
Going further
Once you've seen the PO output, three natural next steps:
- Continue with inline single-agent skills. Pick up the work yourself
one role at a time:
/sage-test-creatorwrites tests for the next ready story,/sage-developerimplements code for the nextIN_DEVstory,/sage-testerverifies the nextTESTINGstory (story-scoped tests, plus the AC implementation map gate). The reference table below lists each one with its picks-up rule. - Run the full team.
/sage-feature-team "<feature description | file-name>"spawns ProductOwner + TestCreator + Developer + Tester + EpicVerifier and routes work through a parallel scheduler until every epic verifies. You'll see a team panel populate with one worker per story. Heavier than the inline path; see How it flows below for the full pipeline. - Use sage with your own project. From your project's repo root, run
/sage-install. The installer scaffolds.sage/and.claude/skills/into your project, with paths rewritten so the skills point at your project's bundled copies. Then edit each.sage/sage-<role>-config.yamlwith your project's testing conventions, file layout, and code-style docs. Full walkthrough: docs/INSTALL.md.
How it flows
flowchart TD
A[User: feature request] --> B(ProductOwner)
B --> C[spec.md<br/>epics/EPIC-N.yaml<br/>stories/STORY-N.yaml]
C --> D{User: APPROVED?}
D -->|yes| E[Parallel scheduler<br/>max_parallel_workers]
E --> F[Story 1 worker]
E --> G[Story 2 worker]
E --> H[Story N worker]
F -.->|"TestCreator -> Developer <-> Tester"| F1[Story 1 DONE]
G -.-> G1[Story 2 DONE]
H -.-> H1[Story N DONE]
F1 --> I(EpicVerifier)
G1 --> I
H1 --> I
I --> J{Gate A: tests pass?<br/>Gate B: AC map verifies?<br/>Gate C: cross-story regression OK?}
J -->|yes| K[Epic VERIFIED]
J -->|no| L[Reopen failing stories]
L --> E
K --> M{More epics?}
M -->|yes| E
M -->|no| N[Feature complete]
Three verification gates run before a feature is complete:
- Gate A -- per-story tests pass (run by Tester after each Developer cycle).
- Gate B -- the AC implementation map (
verify_ac_map.py) confirms every acceptance criterion is wired to real code, not just to a passing test. - Gate C -- the EpicVerifier runs cross-story regression once every story
in an epic is
DONE, then flips the epic toVERIFIED. Downstream epics withdepends_on:only unblock atVERIFIED, notDONE.
If GitHub didn't render the Mermaid above (older clients sometimes don't), here's the same diagram as a static image: docs/img/architecture.svg (or the high-res PNG for sharing).
Inline single-agent skills
Reference for the inline skills mentioned in Going further. Each runs the agent directly in the main conversation -- no team panel, no orchestrator overhead.
| Skill | Picks up | Override |
|---|---|---|
/sage-po "<feature description>" | n/a -- creates a new spec + stories file | --feature <name> to set feature_name explicitly |
/sage-test-creator [STORY-N] | Next story at TODO whose dependencies are all DONE | Pass STORY-N to target a specific story |
/sage-developer [STORY-N] | Next story at IN_DEV | Pass STORY-N to target a specific story |
/sage-tester [STORY-N] [--full] | Next story at TESTING (story-scoped tests) | STORY-N to target a specific story; --full for regression |
All four also accept --feature <feature_name> if multiple feature folders
exist under _output/. Otherwise the feature is auto-detected (single
match) or the skill asks the user (multiple matches).
Where to go from here
- docs/INSTALL.md -- install sage into your own
project (the bundled example is covered by the Quickstart above).
Prerequisites, the
/sage-installflow, the manual install path, the dependency story, and what to do when something doesn't preflight. - docs/ARCHITECTURE.md -- the design rationale: the generic-WHAT / project-specific-HOW split, the state machine, the three-gate model, the scheduler model, the file reference, and how to add a new agent.
- HANDBOOK.md -- the agent protocol in full: completion reporting, escalation, Monitor usage, timeouts, SendMessage discipline.
- examples/static-site-generator/ --
a real end-to-end run: the implementation sage produced plus all run
artifacts under
_output/(spec, epics, stories, verification reports, token telemetry).