Crews

Crews

A Crew is a team of agents that work together to accomplish tasks that are too complex or varied for a single agent. Crews use intelligent routing, task delegation, and a Kanban-style board to coordinate work.

How Crews Work

The Routing Model

When a message or task arrives at a crew:

1. A Router classifies the task (using an LLM)
2. The router identifies which agent in the crew is best suited
3. The task is delegated to that agent
4. The agent works on the task, using its own tools and knowledge
5. If the agent needs help with a subtask outside its expertise, it can hand off to another agent
6. The final result is returned to the user

User Request
    │
    ▼
┌─────────┐
│  Router  │  ← Classifies and delegates
└────┬────┘
     │
     ├──► Agent A (Billing)
     │
     ├──► Agent B (Technical)
     │
     └──► Agent C (General)

Task Board

Crews use a Kanban-style task board with three columns:

Column	Description
To Do	Tasks waiting to be picked up
In Progress	Tasks currently being worked on by an agent
Done	Completed tasks

Each task card shows:

• Task description
• Assigned agent
• Priority level
• Status and progress
• Creation timestamp

Creating a Crew

Step 1: Plan Your Crew

Before building, decide:

1. What types of tasks will this crew handle?
2. What specialized roles are needed?
3. What tools does each role require?
4. What knowledge does each role need?

Step 2: Create the Agents

Create individual agents for each role in your crew. Each agent should be specialized:

Example: Customer Support Crew

Agent	Role	Tools	Knowledge Base
Billing Agent	Handle billing inquiries	Stripe, invoice flows	Pricing docs, billing FAQs
Technical Agent	Resolve technical issues	Jira, GitHub, monitoring	Product docs, troubleshooting guides
Onboarding Agent	Help new customers	CRM, email, tutorial flows	Getting started guides
Escalation Agent	Handle VIP and complex cases	All tools + Slack (to humans)	All knowledge bases

Step 3: Configure the Crew

1. Navigate to Agents > Crews
2. Click New Crew
3. Name your crew (e.g., "Customer Support Crew")
4. Add agents to the crew:
   • Select existing agents
   • Define each agent's role description (used by the router)
5. Configure routing rules

Step 4: Define Routing

The router uses LLM-based classification to match incoming tasks to agents. You can influence routing with:

Role Descriptions

Describe what each agent handles. These descriptions are provided to the routing LLM:

Billing Agent: Handles questions about invoices, payments, subscriptions,
  pricing, refunds, and billing errors.

Technical Agent: Handles questions about product features, bugs, API
  integrations, error messages, and performance issues.

Onboarding Agent: Handles questions from new customers about getting
  started, account setup, first-time configuration, and tutorials.

Routing Rules (Optional)

Add explicit rules that override LLM-based routing:

Rules:
  - If message contains "invoice" or "payment" → Billing Agent
  - If message contains "error" or "bug" → Technical Agent
  - If user.accountAge < 7 days → Onboarding Agent

Rules are checked first. If no rule matches, the LLM router is used.

Task Delegation

Agent-to-Agent Handoffs

Agents within a crew can delegate subtasks to other agents. This happens when:

• The current agent recognizes a subtask outside its expertise
• The system prompt instructs the agent to delegate specific types of work
• The agent explicitly uses the delegate_task tool

Example Handoff Flow

User: "I'm getting an error when I try to pay my invoice"

1. Router → Technical Agent (because "error" keyword)
2. Technical Agent investigates, finds no technical issue
3. Technical Agent delegates to Billing Agent:
   "User reports error paying invoice #5678. No technical bug found.
    Likely a payment processing issue."
4. Billing Agent resolves the payment issue
5. Response returned to user

Handoff Context

When an agent delegates a task, it passes:

• The original user message
• A summary of work done so far
• Relevant data collected during investigation
• The reason for delegation

This ensures the receiving agent has full context without re-asking the user.

Crew Configuration

Priority Levels

Tasks can be assigned priority levels:

Priority	Description	SLA
Critical	System down, data loss	Immediate
High	Major functionality impacted	1 hour
Normal	Standard requests	4 hours
Low	Nice-to-have, non-urgent	24 hours

Concurrency

Configure how many tasks each agent can handle simultaneously:

Billing Agent:
  maxConcurrentTasks: 5
Technical Agent:
  maxConcurrentTasks: 3
Escalation Agent:
  maxConcurrentTasks: 2

Fallback Agent

Designate a fallback agent that handles tasks when:

• No other agent matches the task
• The assigned agent is at capacity
• The routing classification confidence is low

Monitoring Crews

Crew Dashboard

The crew dashboard shows:

• Active tasks — Currently in progress across all agents
• Queue depth — Tasks waiting to be picked up
• Agent utilization — How busy each agent is
• Resolution time — Average time from task creation to completion
• Handoff rate — How often tasks get delegated between agents

Task History

View completed tasks with:

• Which agent handled them
• Whether handoffs occurred
• Total resolution time
• User satisfaction (if feedback is collected)

Crew Patterns

Tiered Support

Tier 1: General Agent (handles common questions)
    │
    └── Escalates complex issues to:
        Tier 2: Specialist Agents (billing, technical, etc.)
            │
            └── Escalates critical issues to:
                Tier 3: Human handoff via Slack/email

Parallel Processing

For tasks that require multiple types of work:

User: "Set up my new team member"

Router creates subtasks:
  → HR Agent: Create employee record, benefits enrollment
  → IT Agent: Provision accounts, assign licenses
  → Facilities Agent: Assign desk, order equipment

All run in parallel, results combined.

Review Chain

For tasks that require quality checks:

Author Agent: Drafts content
    │
    ▼
Reviewer Agent: Reviews for accuracy and tone
    │
    ▼
Publisher Agent: Formats and publishes

Best Practices

1. Keep agents focused — Each agent should have a clear, narrow specialty
2. Write detailed role descriptions — The router relies on these to make good decisions
3. Test routing with diverse inputs — Ensure edge cases route correctly
4. Monitor handoff rates — High handoff rates suggest agents need broader capabilities or routing needs adjustment
5. Set realistic concurrency limits — Don't overload agents with too many parallel tasks
6. Include a fallback agent — Always have a safety net for unclassified tasks

Next Steps

• Set up a knowledge base for your agents
• Configure agent tools
• Learn about agent memory