You describe the task. The AI planner reads your codebase, assesses feasibility, designs a custom team, and launches agents that build it — in parallel, with tests. What used to take hours of prompt engineering happens in one command.

Requires: Bun · GitHub Copilot CLI · Windows Terminal or tmux

$ crews plan "Build a search ranking classifier"

  ╔══════════════════════════════════════════════╗
  ║  PLANNING                                    ║
  ╚══════════════════════════════════════════════╝

  ⚠️  RISKY (60%) — 4 roles, 4 tasks

  Concerns:
    • Position bias in training data may skew rankings
    • No existing evaluation harness — need to build from scratch

  ROLES
    data-engineer:    Feature pipeline + data profiling
    ranking-modeler:  ONNX model + hyperparameter search
    api-integrator:   Serving endpoint + integration
    evaluator:        NDCG/MRR metrics + A/B test plan

  TASKS
    ⏳ profile-data     → data-engineer   [pending]
    ⏳ train-model      → ranking-modeler  [pending]  (← profile-data)
    ⏳ build-endpoint   → api-integrator   [pending]  (← train-model)
    ⏳ evaluate          → evaluator        [pending]  (← build-endpoint)

  ✅ Plan written. Run `crews apply` to create the team.

That's not a template. The AI planner read the codebase, understood it's an ML problem, invented four domain-specific roles, and flagged position bias as a real risk. No other tool does this.

The difference: You describe the task. a2a-crews spawns an AI planner (via Copilot CLI) that explores your repo, understands the domain, and designs a team with feasibility checks — before spending tokens on execution.

# Install (one command)
bun install -g a2a-crews

crews plan "Build a REST API with auth and tests"
crews apply
crews launch

# Or target a different project directory
crews -d /path/to/project plan "Build a dashboard"

Agents spawn in parallel terminal tabs, coordinate via A2A protocol, and deliver working code. Watch with crews watch. Stop with crews stop. Agents can message each other, report errors, and request human input — all through the bridge.

The same tool. Different intelligence for each problem.

Simple task → preset template:

$ crews plan "Build a calculator"

  ✅ GO (85%) — feature template
  🏗️ Architect → 💻 Coder → 🔍 Reviewer
  Waves: design → implement → review

Complex task → AI-generated team:

$ crews plan "Build a fullstack dashboard with real-time updates"

  ✅ GO (85%) — fullstack template
  🏗️ Architect → ⚙️ Backend ║ 🎨 Frontend → 🔍 Reviewer
  Waves: design → backend + frontend (parallel!) → review

Ambiguous task → AI planner invents roles + flags risks:

$ crews plan "Build a classifier for search ranking"

  ⚠️ RISKY (60%) — AI-generated, 4 custom roles
  🔧 Data Engineer → 📊 Ranking Modeler → 🔌 API Integrator → 📈 Evaluator
  Concerns: position bias, no eval harness, needs domain expertise

This is what makes a2a-crews different. When no template fits, the AI planner takes over.

1. Explores your codebase — reads file tree, package.json, source files, README
2. Understands the domain — ML vs API vs frontend vs infrastructure
3. Creates custom roles — not "architect/coder/reviewer" but "data-engineer/ranking-modeler/evaluator"
4. Assesses feasibility — flags real concerns with confidence scores

Every plan gets a three-factor gate before a single token is spent:

Verdicts: GO (>80%) · RISKY (50-80%) · NO-GO (<50%, won't proceed)

Preset team compositions. Or let the AI planner create a custom team.

graph LR
    A["📝 Describe task"] --> B["🔍 AI plans team"]
    B --> C["🌉 A2A Bridge"]
    C --> D["⚙️ Agent 1"]
    C --> E["⚙️ Agent 2"]
    C --> F["⚙️ Agent 3"]
    D --> G["📦 Working Code"]
    E --> G
    F --> G

1. crews plan — Describe what you want. AI assesses feasibility and composes a team.
2. crews apply — Review the plan. Approve or tweak.
3. crews launch — Agents spawn in terminal tabs, register with the A2A bridge, execute in waves.
4. crews watch — Stream status via SSE. crews stop to cancel.

Example scenarios the planner handles — from simple presets to AI-generated custom teams:

The framework handles planning, spawning, coordination, and retry. Your agents do the coding.

GET /.well-known/agent-card.json
→ AgentCard { protocolVersion: "0.3.0", skills, capabilities, ... }

git clone https://github.com/aviraldua93/a2a-crews.git
cd a2a-crews && bun install

# Global install
bun install -g a2a-crews

# Compiled binary
bun run build && ./crews plan "Build a calculator"

• v0.1 — CLI, A2A bridge, 13 templates, wave orchestration, evidence recovery
• v0.2 — AI planner, feasibility assessment, @a2a-js/sdk integration
• v0.3 — Agent messaging, cost tracking, error reporting, input-required, exponential backoff retry, bridge registry, 149 tests
• v0.4 — Review feedback loops, harness iteration
• v1.0 — Web dashboard, push notifications, external agent federation

See ROADMAP.md for details.

Built on A2A Protocol · @a2a-js/sdk · Bun · CrewAI patterns

MIT © 2026 Aviral Dua