| name | delegation-strategy |
| description | Decision framework for when and how to delegate work to Retainer's specialist agents. Covers the two specialists in this reference cut (observer, scheduler) plus the cog's direct tools. |
| agents | cognitive |
Agent Delegation Strategy
When to Delegate
Delegate when the task matches a specialist's scope. Retainer ships two specialists in this reference cut:
| Task Type | Agent | When NOT to delegate |
|---|
| Any memory-shaped question — recent OR deep. Cycle inspection, recall, fact lookup, CBR retrieval/curation, deep-archive search, cross-store connections, pattern mining | observer | Quick status check the user asked about explicitly — answer directly. Memory tools you can call yourself (memory_read / memory_query_facts) for fact-key-shaped lookups |
| Autonomous-cycle scheduling — cron-recurring or one-shot prompts the cog runs on its own | scheduler | A one-off thing the operator wants run NOW — that's a regular cycle, not a scheduled one |
The observer routes recent vs deep internally based on the question — you don't need to pre-classify.
Web search and URL fetch live on the cog directly via web_search and fetch_url — no separate researcher specialist. Just call them.
Do NOT delegate for:
- Short conversational replies (answer directly)
- Tasks you can complete with a single tool call (memory_*, web_search, fetch_url are on you, not specialists)
- Follow-up questions about something already in your context window
- Anything you can verify from current narrative without dispatching a sub-cycle
Tools you have directly (no delegation needed)
- Memory:
memory_write, memory_read, memory_clear_key, memory_query_facts
- Specialists:
agent_observer, agent_scheduler
- Web:
web_search, fetch_url (on the cog directly — no separate researcher specialist in this cut)
- Skills:
read_skill (consult any skill listed in <available_skills>)
- Self-management:
request_more_turns (extend the cog's tool-turn budget mid-cycle when a deep delegation chain warrants)
The memory tools are synchronous and cheap. Use them directly when the answer is "what value did I store under this key?" — not via the observer's get_fact.
Specialist scopes — one-line summary, then drill in
Observer (agent_observer) — knowledge gateway. Recent activity (cycle inspection, recall, facts) AND deep archive (full JSONL search, cross-store connections, pattern mining). Also handles CBR retrieval + curation. Never acts on the world. Read agents-using-observer before dispatching.
Scheduler (agent_scheduler) — autonomous-cycle scheduling. Recurring (cron) and one-shot (RFC3339) prompts the cog will run with SourceAutonomous when their time arrives. Read agents-using-scheduler before dispatching.
The per-agent agents-using-* skills cover briefing, expected reply shape, verification, and cost. This skill is the master TOC; the details live there so they can evolve per-agent without rewriting the routing decision tree.
Verifying delegation results
When a specialist returns a summary:
- Read it before forwarding to the user. The agent's reply text is its claim, not its work — verify the substance is what was asked for.
- If a delegate fails, that's information. Report what happened to the user; don't paper over it with a plausible-sounding response.
- The DAG records the delegation as a child cycle of the current cog cycle. A future inspect tool will let you walk that tree to verify what happened.
Single agent only — no teams
Retainer dispatches to one specialist at a time. If a task genuinely needs multiple perspectives, do them sequentially yourself, or escalate to the operator.
Cost awareness
Every delegation is its own cycle of LLM calls (the specialist's react loop runs up to its max_turns). The observer is max_turns=8; the scheduler is max_turns=6. A simple question that costs you one LLM call costs the observer up to 8 if you delegate. Don't delegate "what's 2+2."
Plan before delegating
If the work has more than 2-3 logical steps, write down what you're going to ask the specialist to do before dispatching. The instruction you pass via agent_<name> is the brief — vague briefs produce vague summaries.
