Loading...
👥
Role-Based Teamwork
Structured agent teams with defined roles and responsibilities
Complexity: mediumPattern
Core Mechanism
Structured multi-agent collaboration where each agent is assigned a clear role (e.g., supervisor, planner, researcher, implementer, reviewer, verifier/judge, tool specialist) with defined responsibilities, capabilities, and permissions. Roles coordinate via typed messages and artifact handoffs, enabling division of labor, accountability, and repeatable workflows. Common implementations use supervisor–worker or scheduler patterns with least‑privilege credentials and auditable handoffs.
Workflow / Steps
- Define role catalog: supervisor, planner, researcher, implementer, reviewer, verifier/judge, tool ops.
- Instantiate team: bind prompts, tools, credentials, SLAs, and budgets to each role.
- Intake and triage: normalize goal, constraints, risk, and evaluation rubric.
- Plan and assign: planner decomposes tasks; supervisor assigns to roles with acceptance criteria.
- Execute loops: roles act with tools/retrieval; produce structured artifacts and traces.
- Handoffs: reviewer/verifier validate outputs; resolve conflicts or request revisions.
- Escalation: supervisor routes exceptions; optional human‑in‑the‑loop for high‑risk steps.
- Synthesize and deliver: compile final output with provenance and metrics.
- Learn and update: refine role prompts, policies, and routing from outcomes.
Best Practices
Create explicit role cards (purpose, inputs/outputs, tools, guardrails, success criteria).
Use capability/permission scopes and short‑lived credentials per role (least privilege).
Standardize handoff schemas (task, artifact refs, confidence, costs, next actions).
Bound loops and depth; cap per‑role tokens, time, and retries to avoid ping‑pong.
Summarize across handoffs; store large artifacts externally and pass references.
Prefer small models for routing/checks; reserve larger models for hard reasoning roles.
Instrument per‑role metrics: utilization, handoff acceptance, rework, cost, and latency.
Add human review gates for safety‑critical or high‑impact decisions.
When NOT to Use
- Simple, single‑step tasks where a single agent meets quality and SLOs.
- Strict real‑time paths where additional handoffs break latency budgets.
- Poorly specified goals where role boundaries and acceptance criteria cannot be defined.
- Highly coupled tasks requiring continuous shared context best handled by one agent.
Common Pitfalls
- Unbounded role ping‑pong and re‑review cycles causing token/cost blowups.
- Ambiguous ownership; unclear acceptance criteria for role outputs.
- Permission sprawl or long‑lived tokens beyond role scope.
- Context drift and stale memory across roles without summarization.
Key Features
Explicit role definitions with scopes and policies
Supervisor/scheduler for assignment and escalation
Typed messages and artifact‑centric handoffs
Per‑role budgets, SLAs, and utilization tracking
Guardrails and approvals on sensitive actions
Observability: traces, costs, provenance, and audits
KPIs / Success Metrics
- End‑to‑end task success; per‑role handoff acceptance and first‑pass yield.
- Rework rate; escalation rate; MTTR with/without human assist.
- Tokens/time/cost per successful task and per role; utilization by role.
- Verifier/judge agreement and policy compliance rates.
Token / Resource Usage
- Set per‑role token/time budgets and stop criteria; summarize on each handoff.
- Use small models for routing/checks; cache retrievals and artifacts for reuse.
- Cap concurrency and retries per role; stream partials and early‑exit on confidence.
- Store large artifacts externally; pass compact references and provenance.
Best Use Cases
- Software development lifecycle: planner → coder → reviewer → tester → deploy.
- Research and content production: researcher → writer → editor → fact‑checker.
- Customer support and triage: classifier → specialist → quality verifier.
- Due diligence and audits: evidence gathering → analysis → verification → report.
References & Further Reading
Academic Papers
Implementation Guides
Tools & Libraries
👥
Role-Based Teamwork
Structured agent teams with defined roles and responsibilities
Complexity: mediumPattern
Core Mechanism
Structured multi-agent collaboration where each agent is assigned a clear role (e.g., supervisor, planner, researcher, implementer, reviewer, verifier/judge, tool specialist) with defined responsibilities, capabilities, and permissions. Roles coordinate via typed messages and artifact handoffs, enabling division of labor, accountability, and repeatable workflows. Common implementations use supervisor–worker or scheduler patterns with least‑privilege credentials and auditable handoffs.
Workflow / Steps
- Define role catalog: supervisor, planner, researcher, implementer, reviewer, verifier/judge, tool ops.
- Instantiate team: bind prompts, tools, credentials, SLAs, and budgets to each role.
- Intake and triage: normalize goal, constraints, risk, and evaluation rubric.
- Plan and assign: planner decomposes tasks; supervisor assigns to roles with acceptance criteria.
- Execute loops: roles act with tools/retrieval; produce structured artifacts and traces.
- Handoffs: reviewer/verifier validate outputs; resolve conflicts or request revisions.
- Escalation: supervisor routes exceptions; optional human‑in‑the‑loop for high‑risk steps.
- Synthesize and deliver: compile final output with provenance and metrics.
- Learn and update: refine role prompts, policies, and routing from outcomes.
Best Practices
Create explicit role cards (purpose, inputs/outputs, tools, guardrails, success criteria).
Use capability/permission scopes and short‑lived credentials per role (least privilege).
Standardize handoff schemas (task, artifact refs, confidence, costs, next actions).
Bound loops and depth; cap per‑role tokens, time, and retries to avoid ping‑pong.
Summarize across handoffs; store large artifacts externally and pass references.
Prefer small models for routing/checks; reserve larger models for hard reasoning roles.
Instrument per‑role metrics: utilization, handoff acceptance, rework, cost, and latency.
Add human review gates for safety‑critical or high‑impact decisions.
When NOT to Use
- Simple, single‑step tasks where a single agent meets quality and SLOs.
- Strict real‑time paths where additional handoffs break latency budgets.
- Poorly specified goals where role boundaries and acceptance criteria cannot be defined.
- Highly coupled tasks requiring continuous shared context best handled by one agent.
Common Pitfalls
- Unbounded role ping‑pong and re‑review cycles causing token/cost blowups.
- Ambiguous ownership; unclear acceptance criteria for role outputs.
- Permission sprawl or long‑lived tokens beyond role scope.
- Context drift and stale memory across roles without summarization.
Key Features
Explicit role definitions with scopes and policies
Supervisor/scheduler for assignment and escalation
Typed messages and artifact‑centric handoffs
Per‑role budgets, SLAs, and utilization tracking
Guardrails and approvals on sensitive actions
Observability: traces, costs, provenance, and audits
KPIs / Success Metrics
- End‑to‑end task success; per‑role handoff acceptance and first‑pass yield.
- Rework rate; escalation rate; MTTR with/without human assist.
- Tokens/time/cost per successful task and per role; utilization by role.
- Verifier/judge agreement and policy compliance rates.
Token / Resource Usage
- Set per‑role token/time budgets and stop criteria; summarize on each handoff.
- Use small models for routing/checks; cache retrievals and artifacts for reuse.
- Cap concurrency and retries per role; stream partials and early‑exit on confidence.
- Store large artifacts externally; pass compact references and provenance.
Best Use Cases
- Software development lifecycle: planner → coder → reviewer → tester → deploy.
- Research and content production: researcher → writer → editor → fact‑checker.
- Customer support and triage: classifier → specialist → quality verifier.
- Due diligence and audits: evidence gathering → analysis → verification → report.