Catalog
affaan-m/team-agent-orchestration

affaan-m

team-agent-orchestration

Run team-based orchestration for agent squads using work items, ownership, agent Kanban, merge gates, and control pane handoffs.

global
New~1.2k
v1.0Saved Jun 4, 2026

Team Agent Orchestration

Use this skill when agents are being managed like a team rather than a single assistant. The purpose is to make team-based orchestration reliable: clear work items, explicit ownership, agent Kanban state, branch isolation, control pane visibility, and merge gates.

When To Activate

  • The task spans multiple agents, tools, harnesses, branches, or worktrees.
  • The user mentions team orchestration, agent Kanban, squad, conductor, control pane, manager, desktop app, Zellij, tmux, Hermes, Devin, Codex, Claude Code, or multi-agent work.
  • A project needs shared workflow state across people and agents.
  • Existing agent fan-out is producing output but not mergeable product.

Operating Model

Treat every agent as a teammate with a narrow contract:

  • Owner: the person or agent accountable for the work item.
  • Scope: files, branch, tool surface, and forbidden areas.
  • State: backlog, ready, running, review, blocked, merged, or archived.
  • Evidence: tests, screenshots, logs, review notes, or eval reports.
  • Merge gate: the exact condition that allows integration.

Agent Kanban

Use agent Kanban when work must be visible across sessions.

Column Meaning Exit Criteria
Backlog Candidate work item, not yet shaped Acceptance criteria written
Ready Shaped and assignable Owner and branch/worktree assigned
Running Agent is actively working Handoff artifact and changed files exist
Review Work is complete but not merged Tests, diff review, and risk check pass
Blocked Needs external input or failed gate Blocker has owner and next action
Merged Integrated into mainline PR merged or local main updated
Archived No longer relevant Reason recorded

Each card should fit this schema:

{
  "id": "agent-card-001",
  "title": "Build dynamic workflow skill",
  "owner": "codex",
  "state": "running",
  "branch": "product/dynamic-workflow-team-orchestration",
  "worktree": ".",
  "acceptance": [
    "Skill exists",
    "Tests cover required concepts",
    "Content artifact contains video and article angles"
  ],
  "merge_gate": "lint, focused tests, and catalog check pass",
  "handoff": "path/to/handoff.md"
}

Team-Based Orchestration Flow

  1. Shape the board: convert fuzzy ambition into work items with owners and merge gates.
  2. Pick execution mode: single-agent, dynamic workflow mode, dmux/tmux, worktree fan-out, or external desktop orchestrator.
  3. Assign boundaries: one owner per card, clear file scope, and no overlapping writes without an integrator.
  4. Run agents: each agent writes evidence and handoff notes, not just code.
  5. Review in sequence: tests first, then diff review, then security/risk checks, then content/product polish.
  6. Merge deliberately: one integrator resolves conflicts and updates the control pane or status artifact.
  7. Extract reusable skill: if the card pattern repeats, promote it into skills/.

Control Pane Requirements

A useful control pane for team orchestration should show:

  • Active work items and their agent Kanban state.
  • Owner, harness, branch, worktree, and last heartbeat.
  • Links to handoff artifacts, tests, screenshots, and PRs.
  • Blockers grouped by owner and unblock action.
  • Merge readiness by gate, not vibes.
  • Reusable workflow candidates that should become shared skills.

Do not add more automation until the operator can answer: who owns this, what changed, what gate failed, and what can safely merge?

Dynamic Workflow Compatibility

When a card needs dynamic workflow mode:

  • Put the task-local harness under the card owner.
  • Store inputs and outputs on the card.
  • Require an eval before moving from Running to Review.
  • Promote the harness to a shared skill only after repeat use.

Failure Modes To Watch

  • Agent soup: many agents running, no owner or merge gate.
  • Invisible work: useful output exists only in a chat transcript.
  • Board theater: a Kanban board exists but cards have no acceptance criteria.
  • Overlapping writes: parallel agents edit the same files without worktrees.
  • No product artifact: the process produces docs but no runnable or publishable surface.

Output Standard

Finish each orchestration pass with:

  • Board/card changes.
  • Merged or pending branches.
  • Tests and eval evidence.
  • Blockers with owner and next action.
  • New shared skill candidates.
Files1
1 files · 1.0 KB

Select a file to preview

Overall Score

87/100

Grade

A

Excellent

Safety

95

Quality

85

Clarity

85

Completeness

78

Summary

A team-based agent orchestration skill that provides a structured framework for managing multi-agent projects using work items, ownership, agent Kanban boards, merge gates, and control pane visibility. It teaches agents to treat themselves as teammates with clear contracts (owner, scope, state, evidence, merge gates) and provides a repeatable orchestration workflow that ensures visibility, integration safety, and reusable skill extraction.

Detected Capabilities

multi-agent coordinationkanban state managementbranch isolation and worktree assignmentownership tracking and assignmentwork item documentationmerge gate definition and enforcementcontrol pane/dashboard guidanceartifact and evidence collectionorchestration workflow planning

Trigger Keywords

Phrases that MCP clients use to match this skill to user intent.

multi-agent coordinationagent kanbanmerge gateteam orchestrationagent squadwork item ownershipbranch isolationcontrol pane visibility

Use Cases

  • Coordinate multiple agents working on different features or branches without creating merge conflicts or invisible work
  • Manage agent squads using a Kanban-style board to track work state (backlog, ready, running, review, blocked, merged)
  • Establish clear ownership and responsibility boundaries so each agent knows what it can and cannot modify
  • Enforce quality gates before merging agent work, including tests, diffs, security checks, and product polish
  • Extract repeatable patterns from multi-agent projects into shared reusable skills for future orchestration
  • Monitor and debug multi-agent workflows by maintaining a control pane showing heartbeats, blockers, and merge readiness

Quality Notes

  • Skill provides a comprehensive, well-structured mental model for team-based agent coordination — clear ownership and state visibility prevent common failure modes
  • Operating Model section establishes concrete contracts for each agent (owner, scope, state, evidence, merge gate) that enable reliable hand-offs
  • Agent Kanban table with exit criteria is actionable and gives agents clear state progression rules
  • Schema example (agent-card-001) is concrete and immediately usable — agents can implement this exact structure
  • Failure Modes To Watch section (agent soup, invisible work, board theater, overlapping writes, no product artifact) teaches pattern recognition that prevents coordination breakdowns
  • Dynamic Workflow Compatibility section connects this skill to harness/workflow execution, making it compatible with broader orchestration tooling
  • Control Pane Requirements enumerate essential visibility metrics without prescribing specific UI — allows flexibility in tooling (CLI, desktop, web)
  • Output Standard at the end provides a checklist artifact that agents can follow to conclude orchestration passes
  • Skill does not require file writes, shell execution, or external service calls — it is purely instructional and governance-focused
Model: claude-haiku-4-5-20251001Analyzed: Jun 4, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Add affaan-m/team-agent-orchestration to your library

Command Palette

Search for a command to run...