Sub-agents overview
Sub-agents are Optimizely-managed helper agents that Mark (Optimizely Agent Platform) uses to split large requests into smaller, focused tasks. Sub-agents let Mark answer complex, multi-part requests faster and at a lower credit cost. When Mark chat meets a self-contained sub-task, it hands that task to a sub-agent. The sub-agent works in its own separate context, runs any tool calls it needs, and returns only its final result. In this article, context means the conversation history that the model re-reads on every turn. The intermediate steps never enter your conversation, which keeps your chat clean and focused.
Sub-agents require no configuration. Mark installs them on every instance and manages them, so you cannot edit or delete them. The Agent Directory does not list them.
Mark chat and specialized agents both delegate to sub-agents, and both follow the same rules. This article uses Mark chat as the example throughout.
Why Mark uses sub-agents
Mark conversations often involve several parts: research across multiple sources, analysis of large documents, or a set of independent tasks. Without sub-agents, Mark 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 – Mark 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, and its tool calls and reasoning stay there.
How sub-agents work
Delegation happens in the following stages:
- Mark chat identifies a sub-task that a brief instruction fully describes.
- Mark chat selects a sub-agent tier that matches the complexity of the sub-task.
- Mark 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 Mark chat.
- Mark chat folds that result into its response to you.
You interact only with Mark chat. The conversation remains one continuous exchange, even when several sub-agents run behind it.
Sub-agent tiers
Mark provides three sub-agent tiers, each backed by a different inference level. Mark 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.
Simple tier
- Agent name – Simple Sub-Agent
- Handle – mini-sub-agent
- 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 Simple Sub-Agent is the tier for straightforward, routine work. Examples include pulling structured fields out of a document, sorting an item into a category, and reformatting data.
Standard tier
- Agent name – Standard Sub-Agent
- Handle – fast-sub-agent
- 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 Standard Sub-Agent is the default delegation target. When Mark chat delegates without naming a tier, it uses the Standard tier. It handles work that requires judgment but not deep multi-step analysis.
Advanced tier
- Agent name – Advanced Sub-Agent
- Handle – deep-sub-agent
- 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.
The Advanced Sub-Agent is the tier for complex analysis that takes several steps. Examples include combining findings from multiple sources, weighing trade-offs, and working through hard strategy questions. Mark uses it only when a task needs that level of depth.
Parallel fan-out
When a request contains several independent sub-tasks, Mark 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 Mark to research three unrelated topics, Mark chat fans out three sub-agents. Each one works on its own topic, and Mark chat combines the three results when they return.
Fan-out applies only to independent sub-tasks. When one sub-task depends on the output of another, Mark chat runs them in sequence.
Multi-turn continuation
A sub-agent supports more than one turn. When Mark 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 Simple tier instead of the full Mark chat model, at a lower cost.
- Parallel execution reduces overhead – Fan-out completes independent sub-tasks concurrently. Concurrent execution cuts the number of sequential model invocations and the total tokens processed.
The savings grow as a conversation gets longer, because every later turn skips the intermediate content.
See Mark credits for how credits work, how to track your usage, and examples of credits per task.
Limits and guardrails
Mark constrains sub-agent usage so delegation stays deliberate and predictable.
Conservative delegation
Mark 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 Mark to use a sub-agent or to fan out.
Mark 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
Mark 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, Mark chat receives an error and retries in a later turn.
No recursion
A sub-agent cannot create another sub-agent. Mark 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 sub-agent tier is the Standard tier, not the Advanced tier.
- Sub-agents run on the instance's default model provider.
- The Simple tier handles routine tasks at the lowest cost.
Sub-agent entries in Agent Activity Logs
Sub-agents explain why one chat message often produces several rows in your logs, 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 indicate 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 agent name, such as Advanced Sub-Agent, paired with its handle, such as deep-sub-agent.
- Trigger – Message, because a chat message started the request that led to the delegation.
- Triggered By – Your name, not Mark chat. Mark 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.
These rows represent work that Mark chat would have performed inline without sub-agents. Sub-agents route that work through isolated contexts and tier-appropriate models. The log contains more entries, not more work. See Agent activity logs for details.
Sub-agent executions are private
Sub-agent execution logs are private. Sub-agents sometimes start from a private conversation in Mark chat, and a private log protects that conversation. Every sub-agent row displays in the table with a lock icon. The person who started the conversation opens the row normally. Other users see the row grayed out and cannot open it. See Private executions.
Open one of your own sub-agent executions to read the work it performed. The Execution tab displays the duration, the credit total, and the result that the sub-agent returned to Mark chat.