convez.ai
MCP ServerAutomaçãoAvançado
Everyone-Needs-A-Copilot

Claude Copilot

Everyone-Needs-A-Copilot/claude-copilot

Time de 16 agentes especializados com memória persistente e orquestração de tarefas

Ver no GitHub
BomPluginScore · de 0 a 100

MCP server que transforma Claude Code em um time de desenvolvimento completo com 16 agentes especializados (Arquiteto, Engenheiro, QA, Segurança, UX, DevOps e mais). Oferece memória persistente entre sessões, orquestração de tarefas paralelas e skill loading sob demanda — pronto para uso imediato por desenvolvedores solo e customizável com padrões da sua equipe.

Instalação

$npx convez-ai Everyone-Needs-A-Copilot/claude-copilot

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
14
Forks
3
Acompanhando
0
Saúde
75%
Último commit
há 1 semana
Versão
v5.36.0
Issues abertas
2
Contribuidores
2

Casos de uso

  • Automação de fluxos de desenvolvimento com múltiplos agentes especializados
  • Manutenção de contexto e decisões entre sessões de trabalho
  • Execução paralela de streams de trabalho com detecção de conflitos
  • Customização de metodologias e padrões proprietários da equipe

Veredito

Solução ambiciosa para orquestração de agents no Claude Code, com arquitetura robusta de persistência e paralelização. Prototipagem confirmada até 5 streams paralelos; escala maior ainda é terreno desconhecido — avaliar em ambiente de produção antes de confiar em workflows críticos.

README

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


What Is Claude Copilot?

Claude Copilot is a set of instructions that sit on top of Claude Code. This is an independent, community-driven framework for Claude Code, unaffiliated with Microsoft Copilot or GitHub Copilot.

It's not separate software—it's markdown files (agents, commands, project instructions) and two CLI tools (cc and tc) that give Claude Code new capabilities:

You GetWhat It Does
Persistent MemoryDecisions, lessons, and progress survive across sessions (FTS5 keyword search)
16 Specialist AgentsLean agents with on-demand skill loading; methodology-embedded from IDEO to Kent Beck
Auto-Firing SkillsSkills surface automatically from trigger-rich descriptions; code-bearing skills run executable scripts
Parallel OrchestrationHeadless workers execute streams concurrently with /orchestrate (works; unproven at large scale — no proven >5-stream run; tests are mock-only)
Pause & ResumeContext switch mid-task with /pause, return with /continue
Task ManagementPRDs, tasks, and work products (WP) via tc CLI with minimal context usage
Stream ManagementParallel work streams with conflict detection and dependencies
Known ReferencesConfigured paths and refs surface into every session via the Known References registry (cc config set refs.*); cc memory search is available manually — agents do not yet auto-search a company knowledge repo (roadmap: agent auto-pull)
Extensions SystemOverride or extend agents with your company methodologies
Code-Execution Pathtc.api / cc.api facades for multi-step ops without CLI round-trip token cost
Live Docscc docs get <pkg> — version-exact package documentation; agents code against the real installed API, not stale training memory; local-first, offline-safe
Context EngineeringAuto-compaction, continuation enforcement, activation modes

When Claude Code reads these instructions, it gains persistent memory, 16 specialist agents, and a structured process — the design goal being more disciplined, resumable work built from the practices that tend to produce better software. We measure process and context efficiency, not output quality; there is no defect/rework data yet.

→ Why we built this


The Problem

Solo developers are expected to be experts in everything. AI assistants help, but they:

  • Forget everything between sessions
  • Give generic advice without context
  • Lack proven processes for complex work

Teams face the same challenges at scale—plus knowledge silos, inconsistent standards, and AI that amplifies inconsistency.

→ Read the full problem statement


April 2026 Restructure

A diagnostic of 15 sessions (Apr 17-22 2026) found a 6% delegation rate — 94% of work stayed in the main session despite a 14-agent roster. A 5-day staging deployment saga (57 manual bash polling calls, 26 loops) exposed missing primitives. The April 2026 restructure introduced mechanical hook enforcement, the tc deploy wait primitive, and model pinning. The roster was consolidated to 8 agents as an interim step to reduce complexity during the hook rollout; it has since been restored and expanded to the current 16-agent roster as the enforcement layer proved stable.

→ Full diagnostic and rationale


How It Works

┌─────────────────────────────────────────────────────────────────────────────┐
│                              YOU                                             │
│                               │                                              │
│                    "Fix the login bug" or "/continue"                        │
└───────────────────────────────┼─────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                         PROTOCOL LAYER                                       │
│                                                                              │
│   /protocol  →  Classifies request, routes to right agent                   │
│   /continue  →  Loads your previous session from memory                     │
└───────────────────────────────┼─────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                          AGENT LAYER                                         │
│                                                                              │
│   ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐  │
│   │   ta    │ │   me    │ │   qa    │ │   doc   │ │   do    │ │   sd    │  │
│   │Architect│ │Engineer │ │   QA    │ │  Docs   │ │ DevOps  │ │ Service │  │
│   │         │ │         │ │         │ │         │ │         │ │Designer │  │
│   └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘  │
│   ┌─────────┐ ┌─────────┐ ┌─────────┐  ┌─────────┐                          │
│   │   uxd   │ │  uids   │ │   uid   │  │   kc    │  Knowledge Copilot       │
│   │UX Design│ │UI Design│ │UI Dev   │  │ (util)  │                          │
│   │         │ │ System  │ │         │  └─────────┘                          │
│   └─────────┘ └─────────┘ └─────────┘                                      │
└───────────────────────────────┼─────────────────────────────────────────────┘
                                │
              ┌─────────────────┼─────────────────┐
              │                 │                 │
              ▼                 ▼                 ▼
┌────────────────────┐ ┌────────────────────┐ ┌────────────────────────────────┐
│   MEMORY COPILOT   │ │   TASK COPILOT     │ │          cc SKILLS             │
│   (cc memory)      │ │   (tc CLI)         │ │                                │
│ • Decisions made   │ │ • PRDs & tasks     │ │ • Auto-fires from description  │
│ • Lessons learned  │ │ • Work products    │ │ • Code-bearing: L1/L2/L3      │
│ • FTS5 keyword     │ │ • ~94% less context│ │ • Known References registry    │
│                    │ │   for externalized │ │   (configured paths/refs only) │
│                    │ │   work products vs │ │ • Agent auto-pull: roadmap     │
│                    │ │   inlining outputs │ │                                │
│ • Enables /continue│ │ • tc.api facade    │ │ • cc.api facade                │
└────────────────────┘ └────────────────────┘ └────────────────────────────────┘

Quick Start

1. Clone

mkdir -p ~/.claude && cd ~/.claude
git clone https://github.com/Everyone-Needs-A-Copilot/claude-copilot.git copilot

2. Machine Setup (once)

cd ~/.claude/copilot && claude

Then say:

Read @SETUP.md and set up Claude Copilot on this machine

3. Project Setup (each project)

cd ~/your-project && claude

Then run:

/setup-project

4. Start Working

/protocol fix the login bug          # Start fresh work
/continue                            # Resume where you left off

→ Complete setup guide


How to Use This Framework

Two patterns cover most development work:

Pattern 1: Fix a Bug

Illustrative (not a captured transcript).

/protocol the checkout form submits twice on Enter key

What happens step-by-step:

  1. Protocol classifies your request:

    [PROTOCOL: DEFECT | Agent: @agent-qa | Action: INVOKING]
    Detected: Bug fix → Routing to QA Engineer...
    
  2. @agent-qa diagnoses:

    Bug reproduced. Root cause: Missing preventDefault() on keyDown handler.
    Routing to @agent-me for fix...
    
  3. @agent-me implements:

    Fix implemented:
    - Added e.preventDefault() to handleKeyDown
    - Added test: "prevents double submission on Enter"
    
    Routing back to @agent-qa for verification...
    
  4. @agent-qa verifies and commits:

    Verification: PASS ✓
    Git commit: fix(TASK-abc): Prevent double submission on Enter key
    

Pattern 2: Build a Feature (with Orchestration)

For substantial features, use parallel work streams:

/protocol ultrawork add OAuth authentication with Google and GitHub

Step 1: Planning

The Tech Architect creates a plan with parallel streams:

✓ PRD Created: PRD-xyz789
✓ 4 streams identified with 18 tasks

Stream Structure:
  Depth 0 (Foundation):
    • Stream-A (Database & Config) - 4 tasks

  Depth 1 (Parallel):
    • Stream-B (Google OAuth) - 5 tasks → depends on: Stream-A
    • Stream-C (GitHub OAuth) - 5 tasks → depends on: Stream-A

  Depth 2 (Integration):
    • Stream-Z (Integration & Docs) - 4 tasks → depends on: Stream-B, Stream-C

Next: Run /orchestrate start to begin parallel execution

Step 2: Set up worktrees and launch agents

/orchestrate start
Scaffolding ready. Each stream has an isolated worktree.

Launching Task agents for each stream...
  Stream-A (Foundation)... ✓ Agent launched
  Stream-B (blocked by Stream-A) - will start when ready
  Stream-C (blocked by Stream-A) - will start when ready
  Stream-Z (blocked by Stream-B, Stream-C) - will start when ready

Step 3: Monitor progress

/orchestrate status
Stream     | Status      | Progress
-----------|-------------|----------
Stream-A   | completed   | 100%
Stream-B   | in_progress | 60%
Stream-C   | in_progress | 40%
Stream-Z   | pending     | 0%

Step 4: Completion

When all streams finish:

🎉 INITIATIVE COMPLETE 🎉

All streams completed. 18 git commits created.

Quick Commands

CommandUse For
/protocol [task]Start any work
/continueResume yesterday's work
/pause [reason]Context switch, save state
/orchestrate startSet up worktrees, launch agents
/orchestrate statusCheck stream progress

Work Intensity Keywords

KeywordUse ForExample
quickTypos, obvious fixes/protocol quick fix the typo
thoroughDeep review, full testing/protocol thorough review auth
ultraworkLarge multi-stream features/protocol ultrawork redesign auth

→ Full usage guide with more scenarios


(Optional) Shared Knowledge

/knowledge-copilot

Creates a Git-managed knowledge repository for company information, shareable via GitHub


Your Team

Core agents (always available):

AgentRoleWhen to Use
taTech ArchitectSystem design, task breakdown, ADRs
meEngineerImplementation, bug fixes, refactoring
qaQA EngineerTesting strategy, edge cases, verification
docDocumentationREADMEs, API docs, technical writing
doDevOpsCI/CD, infrastructure, deploy, containers
sdService DesignerCustomer journeys, experience strategy
kcKnowledge CopilotShared knowledge setup (utility)

Design chain (sd → uxd → uids → uid → ta → me):

AgentRoleWhen to Use
uxdUX DesignerInteraction flows, task design
uidsUI Design SystemVisual tokens, color, typography
uidUI DeveloperComponent implementation specs

Specialist branches:

AgentRoleWhen to Use
secSecurityThreat modeling, STRIDE/DREAD analysis
indIndustrial DesignerObject-level essentialism review (upstream of uxd)
ccoCreative DirectorBrand strategy, creative direction
cwCopywriterCopy execution, messaging, microcopy

Business advisory (optional — outside the software build chain):

cs and cpa are standalone advisory agents for founder/agency business needs. They do not route into the build chain (sd → uxd → uids → uid → ta → me). Invoke them directly.

AgentRoleWhen to Use
csCustomer SuccessSupport patterns, retention strategy
cpaCPA / FinancialTax implications, financial modeling

→ Meet your full team | Agent roster history


All Commands

CommandPurpose
/protocol [task]Start work (auto-routes to right agent)
/continue [stream]Resume from memory or specific stream
/pause [reason]Save checkpoint for context switch
/orchestrate startSet up worktrees, launch stream agents
/orchestrate statusCheck stream progress
/mapGenerate project structure analysis
/setup-projectInitialize a new project
/setup-knowledge-syncEnable auto-updates on releases
/knowledge-copilotBuild shared knowledge repo

→ Orchestration Guide | Knowledge Sync


Works Alone, Grows With Teams

LevelWhat You Get
Solo16 agents, persistent memory, local skills
Team+ shared knowledge repo, Known References registry
Enterprise+ Extensions system, company-specific agent overrides

→ Customization guide | Extension Spec


Requirements

RequirementVersion
Python3.10+
Claude CodeLatest
Disk space~100MB

Build tools (for Python packages):

  • macOS: xcode-select --install
  • Linux: sudo apt-get install build-essential

Documentation

Start here:

GuidePurpose
Usage GuideHow to actually use this - real workflows and scenarios
Decision GuideWhen to use what - quick reference matrices
AgentsAll 16 specialists in detail

Setup & Configuration:

GuidePurpose
User JourneyComplete setup walkthrough
Configuration.mcp.json, environment variables
CustomizationExtensions, knowledge repos, private skills

Advanced:

GuidePurpose
Enhancement FeaturesVerification, auto-commit, preflight, worktrees
Extension SpecCreating extensions
ArchitectureTechnical deep dive
PhilosophyWhy we built it this way

Operations:

DocumentPurpose
Working ProtocolAgent-First Protocol details
Documentation GuideDoc standards, token budgets

Reference:

DocumentPurpose
Quick ReferenceCommand cheatsheet
GlossaryFTS5, BM25, ADR, PRD, WP, L1/L2/L3, all 16 agent codes

Contributing

Contributions welcome! See CONTRIBUTING.md.

When modifying agents:

  • Keep base agents generic (no company-specific content)
  • Use industry-standard methodologies
  • Include routing to other agents

License

MIT License - see LICENSE


Acknowledgements

This project builds on the work of many contributors and open source projects. See ACKNOWLEDGEMENTS.md for credits.


Ver o original no GitHub

Bom para

Relacionados