convez.ai
AgenteAutomaçãoAvançado
CaelanDrayer

cAgents – Sistema de Orquestração Multi-Agente para Claude

CaelanDrayer/cAgents

Orquestre 141 agentes especializados em tarefas multi-domínio com roteamento automático

Ver no GitHub
BomPluginScore · de 0 a 100

Plataforma de orquestração de 141 agentes especializados em 9 arquétipos (desenvolvedor, operador, analista, estrategista, etc.) que decompõe automaticamente tarefas complexas, coordena execução paralela com gates de qualidade, e roteia trabalho entre domínios (engenharia, negócios, criação, crescimento). Integra-se nativamente ao Claude Code via hooks Node.js e pipeline inteligente de roteamento, planejamento e revisão.

Instalação

$npx convez-ai CaelanDrayer/cAgents

1 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

Estrelas
6
Forks
1
Acompanhando
0
Saúde
71%
Último commit
há 1 semana
Versão
—
Issues abertas
1
Contribuidores
3

Casos de uso

  • Tarefas multi-etapas que envolvem engenharia + estratégia + criação simultaneamente
  • Coordenação paralela de trabalho com gates de qualidade e loops de revisão automática
  • Decomposição e delegação inteligente de projetos complexos em equipes de agentes especializados
  • Análise estratégica cross-domain (roadmap, planejamento trimestral, auditoria de qualidade)

Veredito

Ferramenta robusta para cenários de alta complexidade que demandam orquestração multi-domínio e paralela. Aviso: consome 10-50x mais tokens que interações diretas; ideal para tarefas estratégicas onde custo de API é secundário ao tempo de resolução. Não recomendado para correções rápidas pontuais.

README

A tradução para o português deste README ainda está na fila.

cAgents

Your AI Workforce for Claude Code

Deploy 141 specialized agents across 9 builder-role archetypes through an intelligent pipeline that routes your request, plans execution, decomposes work, coordinates specialists, reviews outputs, and validates quality — automatically.

StatValue
Agents141 across 9 archetypes (developer/operator/advisor/analyst/creator/writer/strategist/core/leadership)
Skills4 slash commands (v12.2.0: /org folded into /team strategic mode; v12.1.2: /improve folded into /run)
Hooks31 .cjs files = 28 unique registered hooks + hook-utils.cjs + run-hook.cjs launcher + eval-runner.cjs CLI, across 18 event types
ModelsOpus 4.6 (controllers) · Sonnet 4.6 (execution) · Haiku 4.5 (support)

Is cAgents Right for You?

Use cAgents if you need:

  • Multi-step task orchestration with automatic routing, planning, and coordination
  • Cross-domain work (engineering + business + creative + growth in one request)
  • Parallel execution with quality-gated waves (40-60% faster for complex tasks)
  • Consistent delegation patterns across 9 archetypes (141 specialists)
  • Reviewer loops, confidence scoring, and revision routing built into every run

cAgents is NOT for you if:

  • You need a quick single-file fix — use Claude Code directly, it is faster and cheaper
  • You want minimal token usage — cAgents consumes 10-50x more tokens per request for orchestration overhead
  • You only work in a single narrow area — the orchestration overhead may not be worth it for isolated tasks

Usage Warning

cAgents spawns 3-10+ subagents per request. Each consumes API tokens independently. A single /run can use 10-50x more tokens than a direct Claude Code interaction. /team (especially strategic mode) amplifies this further. Monitor usage closely.


Requirements

  • Claude Code 2.1.69+ (required)
  • Node.js (recommended) — powers 28 unique registered hooks (31 .cjs files = hooks + hook-utils.cjs + run-hook.cjs launcher + eval-runner.cjs CLI) for session management, secret detection, team coordination, and completion verification
cAgentsMin Claude CodeHighlights
10.6.0+2.1.69+Confidence tiers, blind review, handoff documents
10.5.0+2.1.69+Clean team lifecycle, hook reliability
10.0–10.42.1.47+Custom model routing in teammates

Installation

# From Claude Code Marketplace
/plugin CaelanDrayer/cAgents

# Manual
git clone https://github.com/CaelanDrayer/cAgents.git
cd cAgents && ./scripts/setup.sh

Quick Start

Four commands. Four different capabilities.

# Route a bug fix to the engineering domain automatically
/run Fix the authentication bug in src/auth.ts

# Coordinate strategy across domains with C-suite analysis (strategic mode auto-enables)
/team Plan our Q3 product roadmap

# Audit or improve code quality (v12.1.2: improve modes folded into /run via keyword router)
/run review src/api/ --auto-fix

# Explore a design problem interactively
/designer Redesign the checkout flow

The pipeline detects the domain, selects the appropriate controller, decomposes the work into items with acceptance criteria, and coordinates specialist agents — without you specifying a single agent name.


Skills Reference

/run — Task Execution Pipeline

Routes any request through the full pipeline: orchestrator enriches context, planner defines objectives + decomposes work into items with acceptance criteria + assembles delegation prompts, a controller coordinates specialists, and a validator confirms quality. (v12.0.0 folded the standalone task-decomposer and prompt-engineer agents into the planner.)

/run Fix the auth bug in src/auth.ts
/run Write a sci-fi short story set on a generation ship
/run Plan Q4 product launch campaign
/run Design onboarding program for new engineers
/run Create knowledge base article on our refund policy
/run Fix auth bug --analytics    # Show execution metrics after run

The domain routes automatically based on request content. Engineering requests go to an tech-lead controller; creative requests go to a narrative-director; business requests go to an operations-manager or strategic-planner.

/team — N-Wave Parallel Execution

Decomposes work into parallel waves. Teammates execute simultaneously within each wave; a quality gate validates before the next wave starts. Tier 3+ defaults to 5-7 waves.

/team Implement OAuth2 authentication
/team Build user dashboard --waves 8   # Force minimum 8 waves
/team Build feature --dry-run          # Preview wave structure before running
/run Build feature --team              # Team mode via flag on /run

Each teammate is a controller that spawns execution agents directly. Wave 0 handles scaffolding and interface contracts; middle waves parallelize implementation; the final wave handles integration and validation.

Cross-Domain Strategic Coordination via /team --strategic (v12.2.0+)

/org was removed in v12.2.0 and absorbed into /team strategic mode. The full executive layer — CEO inline logic, parallel C-suite analysis, cross-domain deliberation, unified strategic brief, dependency-ordered per-domain dispatch — now runs inside /team. Strategic mode auto-enables when router.domain_count >= 2; force-enable with --strategic (single-domain executive framing) or force-disable with --no-strategic (flat multi-wave).

/team Launch new product with campaign          # auto-enables strategic mode (multi-domain)
/team Fix auth bug                              # single-domain routes through flat /team
/team Restructure engineering team --strategic  # force-enable for single-domain executive framing
/team Migrate to microservices --dry-run        # preview routing decision

Single-domain simple requests still favor /run; single-domain complex work runs as flat parallel /team; multi-domain requests trigger Wave 0/1/2 C-suite deliberation plus Wave 3..N per-domain dispatch.

/designer — Interactive Design Exploration

Guides design exploration through structured Q&A before building anything. Research agents pre-build context-rich question lists per phase. Unlike other skills, /designer waits for your responses at each step — it does not auto-proceed.

/designer Redesign the checkout flow
/designer Plan the data model for a multi-tenant SaaS
/designer Define the API contract for the notifications service

A 4-dimension clarity score tracks readiness; implementation does not begin until ambiguity drops below 20%. Phase overlap starts next-phase research during the current phase to reduce wait time.

Improve Modes inside /run — Quality Review and Optimization

Quality review and measurable optimization are available as modes on /run. The standalone /improve skill was folded into /run in v12.1.2 via a first-word keyword router. Mode selection via the keyword or via --mode review|optimize|full.

/run review src/auth/                              # = --mode review (audit only)
/run audit src/auth/                               # = --mode review (alias for review)
/run review src/api/ --auto-fix                    # Auto-patch CRITICAL findings
/run optimize src/db/queries.ts                    # = --mode optimize (measure, change, verify)
/run improve src/                                  # = --mode full (review then optimize)
/run review src/ --baseline                        # Establish quality baseline
/run review src/ --suppress baseline               # Show only regressions

Review mode runs parallel specialist reviewers (security-engineer, code-reviewer, performance-analyzer) and produces severity-tagged findings with file:line evidence. Optimize mode benchmarks before and after, rolls back on regression, and tracks pattern effectiveness across sessions.

V11.0.0 consolidated /review and /optimize into /improve. v12.1.2 folded /improve into /run via the keyword router. See .claude/skills/run/reference/improve-mode.md for the full contract and docs/MIGRATION-V11.md for the V11 migration baseline.

/helper — Command Guidance

Recommends the right skill based on your task description. Use it when you are unsure whether to reach for /run or /team (with or without --strategic).

/helper
/helper I need to refactor the entire auth module
/helper --troubleshoot              # Diagnose why a previous skill run failed

Domain Breakdown

Canonical: 9 Archetypes (V11.1.0+)

Since v11.1.0, the agent catalog (141 agents as of v12.7.0) is organized as a builder-role archetype tree:

ArchetypeAgentsScope
Developer26Backend, frontend, fullstack, infrastructure, quality (5 branches)
Operator36Support, business-ops, people-ops, marketing-sales, content (5 branches)
Advisor12Legal, health, education, personal (4 branches)
Analyst19Data science, BI, research, social science
Writer8Copy, narrative, technical, editorial
Creator5Visual artists, designers, audiovisual creators
Strategist8Product owners, portfolio managers, planners
Core15Pipeline infrastructure (trigger, orchestrator, planner, reviewer, etc.)
Leadership12C-suite executives — used by /team strategic mode (v12.2.0+; pre-v12.2.0 used by /org)
TOTAL141

Legacy: 13-Domain Routing Overlay (2 dirs on disk + 11 consolidated)

The router and planner still consume legacy domain routing config (controller_catalog + router_keywords). On disk only 2 overlay dirs survive — agents/_overlay/people/ and agents/_overlay/shared/ (config-only, no SKILL.md files); the other 11 legacy domains were consolidated into cagents-memory/_system/config/routing.yaml. Either way, domain-keyworded requests still find the right archetype controller. The table below lists the legacy domains and how they map to the canonical archetypes.

Legacy DomainMaps to Archetypes
Engineering (31 routing slots)Most of developer/ + parts of operator/infrastructure
Creative (30 routing slots)creator/ + parts of writer/
Business (28 routing slots)strategist/ + operator/business-ops
Growth (34 routing slots)operator/marketing-sales + parts of writer/
People (17 routing slots)operator/people-ops
Service (28 routing slots)operator/support + advisor/legal
Leadershipleadership/ (used by /team strategic mode in v12.2.0+; pre-v12.2.0 used by /org)
Shared/Science/Health/Education/Personal/Arts/Tradesanalyst/ + advisor/{health,education,personal} + creator/

Engineering (31) handles the full software stack: backend-developer, frontend-developer, devops-engineer, security-engineer, qa-lead, architect, dba, performance-analyzer, and 23 more. Use /run Fix the bug or /team Build the feature and the pipeline routes here automatically for software tasks.

Creative (30) covers long-form and short-form writing: prose-stylist, dialogue-specialist, plot-developer, narrative-director, character-psychologist, worldbuilder, and 24 more. Use /run Write a mystery short story and the narrative-director controller coordinates the right specialists.

Growth (34) is the largest domain: copywriter, marketing-strategist, seo-specialist, demand-generation-manager, sales-strategist, and 29 more. Use /run Plan the Q4 content calendar and the marketing-strategist controller coordinates the campaign team.

Service (28) covers support and legal: customer-success-manager, general-counsel, compliance-officer, technical-writer, legal-analyst, and 23 more. Use /run Draft an EULA for our SaaS product and the general-counsel controller coordinates the legal team.


Architecture

/run — Event-Driven Pipeline

/run is a config-driven state machine. Each stage writes a file that triggers the next stage.

User Request
  |
  +-> /run  (state machine loop, reads pipeline_config.yaml)
        |
        INIT          -> orchestrator  -> enriched_context.yaml
        ORCHESTRATED  -> planner       -> plan.yaml + work_items.yaml
        PLANNED       -> controller    -> coordination_log.yaml
              |
              +-> execution agent  (implements work item)
              |     +-> reviewer   Stage 1: spec compliance
              |                    Stage 2: code quality
              |                    REVISE -> back to execution agent (max 3 rounds)
              |
              +-> (repeat per work item, dependency-ordered)
        COORDINATED   -> validator     -> validation_report.yaml
        VALIDATED     -> complete
              FAIL   -> re-run controller   (max 3 cycles)
              REVISE -> re-run planner      (max 3 cycles)

Controllers never implement. They ask questions of specialist agents, synthesize answers, and coordinate work items in dependency order. A two-stage review runs on every work item: Stage 1 checks spec compliance against acceptance criteria; Stage 2 checks code quality only after Stage 1 passes.

/team — N-Wave Parallel Execution

/team request
  |
  Wave 0   Lead (sequential)
  |         enrichment, scaffolding, interface contracts
  |
  Wave 1..N-1   Teammates (parallel within each wave)
  |   +-> Teammate A (controller) -> execution agent -> reviewer
  |   +-> Teammate B (controller) -> execution agent -> reviewer
  |   +-> Teammate C (controller) -> execution agent -> reviewer
  |
  |         GATE: quality validated before next wave starts
  |
  Wave N   Lead (sequential)
            integration, final validation, report

More waves produce more quality gates. Tier 3+ defaults to 5-7 waves. Use --waves N to set a minimum. Each teammate is a controller that spawns execution agents via the Agent tool — teammates never implement directly.

Complexity Tiers

TierCoordinationWhen It Applies
2 (Moderate)1 controllerBug fix, answer a question, single-file change
3 (Complex)1 primary + 1-2 supportingAdd a feature, create a subsystem
4 (Expert)Executive + primary + supporting + HITLMajor refactor, architecture migration

The pipeline detects tier automatically via 9-signal complexity scoring. Tier 2 uses a fast path that skips 3 enrichment agents to keep simple requests lean.


Key Features

Goal Drift Prevention

After context compaction, the post-compact-restore.cjs hook reads the active plan.yaml and re-injects the mission, domain, phase, and work-item progress into the model's context window. An agent given 30 work items 40 tool calls ago still acts on the original objectives — not on whatever survived the compaction.

This fires automatically — no prompt engineering required. It is a no-op when there is no active session, so it does not affect ordinary Claude Code usage.

Lifecycle Hooks

cAgents ships 31 .cjs files = 28 unique registered hooks + hook-utils.cjs + run-hook.cjs launcher + eval-runner.cjs CLI. The 28 hooks fire across 18 of Claude Code's 24 event types:

EventHookPurpose
SessionStartsession-catchup.cjsDetect incomplete sessions, inject cAgents context
SessionEndteam-stop.cjsFinalize team metrics and update session status
UserPromptSubmitprompt-router.cjsEnforce delegation rules + natural-language routing suggestions
PreToolUse[Bash]bash-validator.cjsBlock dangerous commands and data exfiltration attempts
PreToolUse[Write|Edit]secret-detection.cjsBlock writes containing API keys, tokens, credentials
PreToolUse[Write|Edit]controller-delegation-validator.cjsWarn when controllers write implementation files
PreToolUse[Write|Edit|Bash]approval-gate.cjsEnforce approval gates for sensitive operations
PreToolUse[Agent]model-routing-advisor.cjsSuggest optimal model before agent spawns
PreToolUse[Agent]session-init-gate.cjsEnsure session init complete before agent spawns
PermissionRequestpermission-handler.cjsAuto-approve safe patterns, HITL gates
PostToolUse[Write|Edit]post-write-validator.cjsValidate JSON/YAML syntax after writes
PostToolUseFailuretool-failure-tracker.cjsTrack failures, detect patterns, suggest recovery
Notificationnotification.cjsLog notifications to daily files
SubagentStartsubagent-tracker.cjsLog agent spawns to agent_tree.yaml with audit trail
SubagentStartteam-start.cjsInitialize team monitoring directories
SubagentStopsubagent-stop-tracker.cjsCapture completion summaries and duration metrics
Stopverify-completion.cjsVerify completion criteria before allowing stop
StopFailurestop-failure-handler.cjsSave recovery state on unclean stop
TeammateIdleteammate-idle-handler.cjsFind available work or cleanly stop idle teammates
TaskCompletedteam-task-complete.cjsUpdate task list, unblock dependencies
InstructionsLoadedinstructions-loaded.cjsValidate rules directory, inject session context
PreCompactpre-compact-save.cjsSave workflow state before context compaction
PostCompactpost-compact-restore.cjsRe-inject workflow context after compaction

Confidence Scoring

Every completed work item includes a confidence score (0.0–1.0) and rationale. Items below 0.7 trigger additional scrutiny: the reviewer applies stricter criteria and the controller flags them in the coordination log.

Two-Stage Review Protocol

The reviewer loop runs two distinct stages in strict order:

  1. Stage 1 — Spec Compliance: Does the implementation meet every acceptance criterion? Evidence must cite specific file:line. No quality judgments at this stage.
  2. Stage 2 — Code Quality: Is the implementation well-written and maintainable? Runs only after Stage 1 passes. Findings are severity-tagged (CRITICAL/HIGH/LOW). REVISE triggers only for CRITICAL or two or more HIGH findings.

This prevents marking work complete when it looks clean but misses requirements.

Aggressive Decomposition

The planner breaks even simple requests into 30+ work items with explicit acceptance criteria, dependency graphs, and agent assignments. Work items execute in topological order; independent items execute in parallel.


Domain Routing

cAgents routes your request to the right domain automatically based on keywords. No configuration needed — just describe what you want.

RequestRouted ToController
/run Fix the auth bugEngineeringtech-lead
/run Write a blog post about AICreativenarrative-director
/run Plan Q4 product launchBusinessoperations-manager
/run Build an email campaignGrowthmarketing-strategist
/run Create onboarding programPeoplehr-manager
/run Draft our privacy policyServicegeneral-counsel

For cross-domain work that spans multiple areas (e.g., launching a product requires engineering, marketing, and ops), use /team — strategic mode auto-engages when router detects 2+ domains and coordinates C-suite agents across domains automatically (v12.2.0+; pre-v12.2.0 this was /org).


Performance Benchmarks

FeatureMeasurement
Aggressive Decomposition30+ work items from a simple request
Controller Pattern30-40% simpler planning, 20-30% fewer tokens vs direct delegation
Parallel Execution50x speedup (swarm mode), 80%+ parallelism efficiency
Task Inventory60-80% context savings for workflows with 20+ tasks
Team Mode40-60% execution time reduction for tier 3+

How cAgents Compares

DimensioncAgentsOfficial feature-dev pluginOfficial code-review plugin
Agent count1413–53–5
Business domains9 archetypes (2 routing overlays + 11 consolidated)1 (engineering)1 (engineering)
Pipeline state machineYes — PASS/FAIL/REVISE routing, max 3 cyclesNoNo
Parallel team executionYes — N-wave with per-wave quality gatesNoNo
Revision loopsYes — executor + reviewer, max 3 rounds per work itemNoNo
Two-stage reviewYes — spec compliance then code qualityNoNo
Hook lifecycle28 unique hooks across 18 event types1–4 hooks1–4 hooks
Goal drift preventionYes — attention injection on every Write/Edit/BashNoNo
Confidence scoringYes — 0.0–1.0 per work item, low scores trigger scrutinyNoNo
Cross-domain orchestrationYes — /team strategic mode fires full C-suite hierarchy (auto-enabled when domain_count >= 2)NoNo

Numbers for cAgents reflect the current release. Official plugin figures are approximate based on publicly available descriptions.


Real Workflow Examples

Multi-Domain Strategy: /team Plan Q3 product launch (auto-enables strategic mode)

/team detects two or more domains in the request (engineering + business + growth) and auto-enables strategic mode. The CEO inline logic fires first and determines which C-suite agents are needed: CTO for technical feasibility, CPO for roadmap fit, CMO for go-to-market.

CTO, CPO, and CMO each analyze the request independently in Wave 0/1, writing their analyses to separate YAML files. Each then reads the others' analyses before a Wave 2 deliberation phase where they surface conflicts and cross-domain dependencies. The CMO flags that the marketing timeline assumes a launch date the CTO says is unrealistic. The deliberation resolves this with a phased launch plan.

The result is a unified strategic brief. /team then dispatches Wave 3..N per-domain: the engineering team plans the feature work, the marketing team plans the campaign, each using the strategic brief as shared context. (Pre-v12.2.0 this workflow was /org invoking sequential /team runs per domain; v12.2.0 fused both steps into a single /team session with nested waves.)

Full-Stack Feature: /team Build user dashboard

Wave 0 (lead, sequential): scaffolding, interface contracts between frontend and backend, database schema decisions written to a contracts file that all subsequent waves read.

Wave 1 (parallel, 3 teammates): backend-developer builds the API endpoints against the contract, frontend-developer builds the component tree consuming that API contract, dba validates the schema against query patterns.

Wave 2 (parallel, 2 teammates): qa-lead writes integration tests covering the API and UI, accessibility-checker audits the component tree.

Wave 3 (lead, sequential): integration, final test run, validation report. Each wave is gated — the next wave does not start until the current wave's quality criteria pass. Total execution time: 40-60% less than sequential.

Quality Review: /run review src/auth/ --auto-fix

Three reviewers run in parallel: security-engineer (injection, auth bypass, token handling), code-reviewer (naming, structure, DRY, complexity), performance-analyzer (N+1 queries, unnecessary allocations). Each reports findings with CRITICAL/HIGH/LOW severity, citing specific file:line evidence.

The lead synthesizes findings, deduplicates overlapping concerns, and produces a prioritized list. Because --fix was passed, each CRITICAL finding routes through an execution agent to be patched. The patches re-enter the review pipeline to confirm the finding is resolved before the overall review marks complete.


Documentation

ResourceContent
CLAUDE.mdComplete architecture reference and agent inventory
docs/ARCHITECTURE.mdPipeline design, state machine, and domain structure
docs/SKILLS.mdFull skill reference with all flags and options
docs/TEAM_MODE.mdN-wave execution, wave types, gate sentinels, templates
docs/GETTING_STARTED.mdFirst-run guide and environment setup
docs/RELEASE_NOTES.mdDetailed version history
.claude/rules/29 modular topic-specific rules loaded by agents
docs/SECURITY.mdSecurity policy and vulnerability reporting

External Resources

Key external tools and libraries that cAgents depends on:

  • Claude Code — Anthropic's CLI for Claude, required runtime for cAgents
  • Node.js — JavaScript runtime powering cAgents hooks and scripts
  • Vitest — Test framework used by the cAgents test suite
  • tmux — Terminal multiplexer used for team mode split panes
  • js-yaml — YAML parser used throughout session state management
  • ajv — JSON Schema validator used for configuration validation

Version History

See docs/RELEASE_NOTES.md for the complete history. Recent highlights:

  • V12.17.0 — Current release. Final organization + documentation reconciliation pass (session team_final-org-docs_260528_001): reconciled current-count drift to disk truth (141 agents, 36 rules, 64 docs, 16 version-registry slots), added validate-counts.sh Check 2b (targeted absence guard) so stale README agent-totals can no longer pass the presence-only check, and aligned README + docs/ with the current 4-skill catalog and 5-state pipeline.
  • V12.10.0 — FU-3 bare-prose agent-name sweep: replaced the last bare universal-* agent-name mentions in agent prose (the five pipeline agents — router, planner, validator, executor, self-correct) across 25 agents/** files, completing the v12.5.0 pipeline-agent rename. Added a no-bare-universal-prose-refs regression guard.
  • V12.2.0 — BREAKING: /org skill removed; cross-domain coordination folded into /team with auto-enabled strategic mode (router domain_count >= 2 triggers Wave 0/1/2 C-suite deliberation + Wave 3..N per-domain dispatch). 12 leadership agents preserved at their existing locations. Plugin skill count 5->4. Migration: /org X → /team X.
  • V12.1.2 — Folds /improve into /run via a first-word keyword router and removes the standalone /improve skill (/run review|audit = --mode review, /run optimize = --mode optimize, /run improve = --mode full). Plugin skill count 6->5.
  • V12.0.0 — Consolidation release: pipeline collapse 7->5 states (task-decomposer + prompt-engineer folded into planner), engineering-manager merged into tech-lead, architecture-reviewer collapsed into architect --review mode flag, 13 marketing-sales agents absorbed (38->25), chief-legal-officer renamed to clo, 11 legacy domain dirs deleted, cagents-memory/_communication/ removed, max_revision_cycles 5->3, execution self-validation reduced 15->5 hook-verifiable checks. Total agents 251->240.
  • V11.3.0 — Plugin health sweep: archetype-canonical doc alignment (9 archetypes canonical, 15 domains as routing overlay), 109 stale related_agents cross-references swept, hook-count assertions corrected (26 unique registered, 29 .cjs total), sync-agents.sh --check dry-run flag added, validate-versions.sh pruned to 18 canonical slots, regression tests added.
  • V11.1.3 — Removed statusLine hook and status bar integration.
  • V11.0.0 — Removed deprecated skills /review, /optimize, /context, /debug. /review and /optimize consolidated into /improve (--mode review|optimize|full); /context replaced by /run context … passthrough; /debug replaced by /run --mode debug. See docs/MIGRATION-V11.md for the migration guide.
  • V10.23.0 — 29-check validation framework, regression validation chain, mandatory self-validation protocol for execution agents
  • V10.22.0 — Two-stage review protocol (spec compliance then code quality), 5 pipeline improvements
  • V10.20.0 — 23 agent communication gap fixes, Growth domain expanded from 35 to 39 agents
  • V10.18.0 — Vibe field on all 243 agents, worktree isolation, guard command pattern, skill chaining, commit-before-verify pattern
  • V10.16.0 — Session ID naming overhaul with readable slugs, agent_id linking in coordination_log
  • V10.12.0 — External session-visualizer integration with 15 session-data improvements (contract dropped in v12.6.0)
  • V10.6.0 — Confidence tiers, blind review, dead-letter queue, handoff documents
  • V10.3.0 — Creative domain overhaul (24 to 30 agents, all on Opus 4.6)
  • V10.0.0 — 8 business domains, agent chaining with topological execution

License

MIT License — see LICENSE for details.


Built with Claude Code | 141 agents across 9 archetypes | Opus 4.6 · Sonnet 4.6 · Haiku 4.5

Ver o original no GitHub

Bom para

Relacionados