| name | delegation-strategy |
| description | Decision framework for when and how to delegate work to specialist agents and agent teams. Covers agent selection, team strategies, cost awareness, and result verification. |
| agents | cognitive |
Agent Delegation Strategy
When to Delegate
Delegate when the task matches an agent's specialisation:
| Task Type | Agent | When NOT to delegate |
|---|
| Web research, data gathering | researcher | Simple factual questions you already know |
| Code writing, execution, debugging | coder | Trivial calculations (use calculator) |
| Text drafting, editing, reports | writer | Short conversational replies |
| Task decomposition, plan structure, risk analysis | planner | Simple single-step tasks |
| Endeavour lifecycle, phases, sessions, blockers, forecaster config | project_manager | Quick task step completion (use cognitive loop tools) |
| Cycle inspection, pattern detection, CBR curation, fact tracing | observer | Quick status checks (use reflect directly) |
| Email communication | comms | Nothing — always delegate email |
| Deep memory search (months/years), consolidation reports, pattern mining over CBR, dormant-thread resurrection, fact-confidence restoration | remembrancer | Recent-window memory (use recall_* or observer) |
Do NOT delegate for:
- Short conversational replies (answer directly)
- Tasks you can complete with a single tool call
- Follow-up questions about something already in context
What's on the Cognitive Loop vs Agents
You have 16 tools directly available. Everything else requires delegation:
Your tools (fast, synchronous):
- Memory:
recall_recent, recall_search, recall_threads, recall_cases
- Facts:
memory_write, memory_read, memory_clear_key, memory_query_facts
- Status:
reflect, introspect
- Tasks:
complete_task_step, activate_task, get_active_work, get_task_detail
- Utility:
how_to, cancel_agent
Delegate to Observer for:
- Cycle forensics:
inspect_cycle, list_recent_cycles, query_tool_activity
- Pattern analysis:
review_recent, detect_patterns
- CBR curation:
correct_case, annotate_case, suppress_case, unsuppress_case, boost_case
- Fact tracing:
memory_trace_fact
- Safety feedback:
report_false_positive
Delegate to Planner for:
- Pure reasoning: plan decomposition, steps, dependencies, risk identification
- Returns structured XML output (no tools of its own)
Delegate to Project Manager for:
create_endeavour, add_task_to_endeavour, get_endeavour_detailflag_risk, abandon_task, request_forecast_review- Phase management:
add_phase, advance_phase
- Session management:
schedule_work_session, cancel_work_session, list_work_sessions
- Blockers:
report_blocker, resolve_blocker
- Forecaster:
get_forecaster_config, update_forecaster_config, get_forecast_breakdown
- Delete:
delete_task, delete_endeavour
- Task editing:
update_task, add_task_step, remove_task_step, update_endeavour
Single Agent vs Team
Default: use a single agent. Most tasks are best handled by one specialist.
Use a team only when:
- The task genuinely benefits from multiple perspectives (e.g. research that
needs both academic and industry sources)
- Accuracy matters enough to justify the cost of debate (e.g. factual claims
that will be sent externally)
- The task has distinct sequential phases that different agents handle best
(e.g. research → analysis → writing)
- A lead needs to coordinate specialist outputs into a coherent whole
Do NOT use a team for:
- Simple single-perspective tasks (one researcher is enough)
- Tasks where speed matters more than thoroughness
- Follow-up or clarification work
- Anything a single agent can handle adequately
Team Strategies
| Strategy | When to use | Cost |
|---|
ParallelMerge | Breadth — same question, multiple angles | 2-5 agent runs + 1 synthesis |
Pipeline | Depth — sequential phases building on each other | N agent runs + 1 synthesis |
DebateAndConsensus | Accuracy — experts may disagree, need convergence | 2-5× agent runs + 1 synthesis |
LeadWithSpecialists | Orchestration — one agent coordinates the rest | N+1 agent runs, no extra synthesis |
Cost awareness: Teams cost 3-5× a single agent dispatch. A ParallelMerge
with 2 members uses ~2 agent react loops + 1 synthesis LLM call. A 3-member
DebateAndConsensus with 2 rounds uses ~9 agent runs + 1 synthesis. Check the
sensorium's tokens_remaining before dispatching a team — if budget is tight,
use a single agent instead.
Config guards enforce limits:
team_max_members (default 5) — prevents runaway fan-outteam_token_budget (default 200,000) — total token cap across all membersteam_max_debate_rounds (default 3) — caps debate iterations
Instruction Quality
Bad: "Research Dublin rental market"
Good: "Search for Dublin residential rental prices Q1 2026. Use web_search
for Daft.ie and CSO data. Report average rent, year-on-year change, and
supply levels. If sources conflict, note the discrepancy."
Always specify:
- What to find (specific data points, not vague topics)
- Where to look (specific sources if known)
- How to handle problems (what to do if data is unavailable)
- What format to return (structured findings, not narrative)
For teams, the instruction goes to ALL members. Each member also receives their
<team_role> and <perspective> overlays, so the instruction should describe
the overall objective, not per-member tasks.
Result Verification
After an agent or team returns:
- Check the outcome status — "success" doesn't mean the content is correct
- Look for
[WARNING: agent X had tool failures] — the agent continued
despite errors, treat results with suspicion
- Verify key claims against the delegation instructions — did it answer
what you asked?
- Check the sensorium
<delegations> for tool call count and tokens used —
an agent that used 0 tools probably just generated text without doing work
Parallel Dispatch
When you call multiple agents in one response (e.g. agent_researcher and
agent_coder), they run simultaneously. Results come back in whatever order
they finish, then you synthesise. Use this when the tasks are independent.
If tasks are dependent (writer needs researcher's output), call them in
separate turns — call researcher first, get the result, then call writer
with that context.
Delegation Depth
The system caps delegation at 3 levels deep. Sub-agents cannot delegate
further. Teams count as one delegation level from the cognitive loop's
perspective, even though they internally dispatch multiple agents.
Cancel Misbehaving Agents
If the sensorium shows an agent stuck (high turn count, high tokens, no
progress), use cancel_agent(agent_name) to stop it. Then retry with
clearer instructions or a different approach.
