Sub-agents overview
Sub-agents let Optimizely Opal answer complex, multi-part requests faster and at a lower credit cost. When Opal Chat meets a self-contained sub-task, it hands that task to a sub-agent. The sub-agent works in its own isolated context and returns only the finished result. The intermediate steps never enter your conversation.
Sub-agents require no configuration. Opal installs them on every instance and manages them, so they cannot be edited or deleted. They are also not listed in the Agent Directory.
Opal Chat and specialized agents both delegate to sub-agents, and both follow the same rules. This article uses Opal Chat as the example throughout. Context means the conversation history that the model re-reads on every turn.
Why Opal uses sub-agents
Opal conversations often involve several parts: research across multiple sources, analysis of large documents, or a set of independent tasks. Without sub-agents, Opal Chat handles every part inline. That approach creates two problems:
- Context bloat – Intermediate work such as fetched documents and tool results accumulates in the conversation. The model re-reads that content on every later turn. Each message then costs more, and longer context degrades the quality of the answers.
- Split attention – Opal Chat divides its attention across unrelated objectives when it juggles several sub-tasks inline. Accuracy on each sub-task drops as a result.
Sub-agents isolate the work. Each sub-agent gets a clean context dedicated to one task. Only the final answer returns to your conversation, and the tool calls and reasoning stay in the sub-agent's context.
How sub-agents work
Delegation happens in the following stages:
- Opal Chat identifies a sub-task that a brief instruction fully describes.
- Opal Chat selects an inference tier that matches the complexity of the sub-task.
- Opal creates a sub-agent in its own isolated context with that instruction.
- The sub-agent completes the work, including any tool calls it needs.
- The sub-agent returns its final result to Opal Chat.
- Opal Chat folds that result into its response to you.
You interact only with Opal Chat. The conversation remains one continuous exchange, even when several sub-agents run behind it.
Sub-agent tiers
Opal provides three sub-agent tiers, each backed by a different inference level. Opal Chat selects the tier automatically. Routine work runs on the least expensive model that handles it well. Two of the tiers use extended thinking, where the model reasons through a problem before it answers.
Mini tier
- Task type – Routine data operations, classification, and structured data extraction
- Inference level – Quick, the fastest level
- Reasoning – No extended thinking, optimized for speed and cost
- Relative cost – Lowest of the three tiers
The mini tier suits straightforward work. Examples include pulling structured fields out of a document, sorting an item into a category, and reformatting data.
Fast tier
- Task type – General-purpose delegation with light reasoning
- Inference level – Balanced, the everyday reasoning level
- Reasoning – Extended thinking enabled
- Relative cost – Mid-range of the three tiers
The fast tier is the default delegation target. When Opal Chat delegates without naming a tier, it uses the fast tier. It handles work that requires judgment but not deep multi-step analysis.
Deep tier
- Task type – Complex, multi-step reasoning
- Inference level – Pro, the deepest reasoning level
- Reasoning – Full extended thinking with a higher token budget
- Relative cost – Highest of the three tiers
Opal Chat reserves the deep tier for sub-tasks that require sustained reasoning across several steps.
Parallel fan-out
When a request contains several independent sub-tasks, Opal Chat dispatches them at the same time. This pattern is parallel fan-out, and it shortens the total response time.
For example, when you ask Opal to research three unrelated topics, Opal Chat fans out three sub-agents. Each one works on its own topic, and Opal Chat combines the three results when they return.
Fan-out applies only to genuinely independent sub-tasks. When one sub-task depends on the output of another, Opal Chat runs them in sequence.
Multi-turn continuation
A sub-agent supports more than one turn. When Opal Chat needs a clarifying answer or further analysis, it continues with the same sub-agent. The second turn keeps the context that the sub-agent built in the first turn, which avoids repeated processing.
Credit and cost implications
Sub-agents reduce total credit consumption on complex tasks for three reasons:
- Context isolation reduces token re-processing – Intermediate work stays in the sub-agent's context instead of your conversation. Your conversation stays lean, so every later turn processes fewer tokens.
- Tier-appropriate model selection – A classification task runs on the mini tier instead of the full Opal Chat model, at far lower cost.
- Parallel execution reduces overhead – Fan-out completes independent sub-tasks concurrently. That cuts the number of sequential model invocations and the total tokens processed.
The savings compound over longer conversations. Context isolation delivers more value as the turn count grows. Each turn avoids re-processing intermediate content that would otherwise sit in the conversation.
Limits and guardrails
Opal constrains sub-agent usage so delegation stays deliberate and predictable.
Conservative delegation
Opal Chat delegates only when one of the following is true:
- The sub-task is self-contained, and a brief instruction fully describes it.
- Inline handling would flood your conversation with intermediate detail, such as large documents or long tool-call sequences.
- You explicitly ask Opal to use a sub-agent or to fan out.
Opal Chat does not delegate trivial work that it handles directly. It also does not chain sub-agents to offload its entire task.
Per-turn dispatch budget
Opal caps the number of sub-agent dispatches in a single turn. Individual sub-agent calls and fan-out slots share that one budget. When a turn reaches the cap, Opal Chat receives an error and retries in a later turn.
No recursion
A sub-agent cannot create another sub-agent. Opal filters the delegation tools out of every sub-agent's tool set, which prevents unbounded chains of nested delegation.
Cost-effective defaults
Three defaults keep routine delegation inexpensive:
- The default inference tier is the fast tier, not the deep tier.
- Sub-agents run on the model provider configured as the instance default.
- The mini tier handles routine tasks at the lowest cost.
Sub-agent entries in Agent Activity Logs
Sub-agent executions explain a surprise in your logs. One chat message often produces several rows, each with its own credit total. The Agent Activity Logs tab records every sub-agent execution as a separate entry. Rows that share one execution time show parallel fan-out, where several sub-agents ran concurrently on independent parts of one request.
To find these rows, enter sub in the search field on the Agent Activity Logs tab. A sub-agent row carries the following values:
- Agent – The tier name, such as Deep Sub-Agent, paired with the handle deep-sub-agent.
- Trigger – Message, because a chat message started the request that led to the delegation.
- Triggered By – Your name, not Opal Chat. Opal attributes a sub-agent execution to the person who started the conversation.
- Model Provider – Instance Default, because sub-agents do not override the provider configured for the instance.
- Credits – The credit total for that execution, based on its tier and the amount of work it performs.
Open a sub-agent execution to read the work it performed. The Execution tab shows the duration, the credit total, and the result that the sub-agent returned to Opal Chat.
These rows represent work that Opal Chat would have performed inline without sub-agents. Sub-agents route that work through isolated contexts and tier-appropriate models. The log shows more entries rather than more work. See Agent activity logs for details.