Note
Access to this page requires authorization. You can try signing in or changing directories.
Access to this page requires authorization. You can try changing directories.
A task agent is a helper that your agent uses to complete a focused assignment. The agent that delegates the assignment is called the parent agent. It uses the returned findings to continue its work or prepare a response. Agents powered by the Microsoft Copilot harness can use task agents for tasks such as independent research, focused analysis, or a separate review of a result.
Note
The harness used to build this agent uses usage-based billing. Using, building, testing, and evaluating agents might consume Copilot Credits. Learn more in Overview of usage-based billing.
You guide task agents through your agent's instructions or through instructions in a skill. You don't need to create and publish a separate connected agent for each assignment.
Important
Task agents are available only in early release cycle environments.
Prerequisites
- An agent powered by the Microsoft Copilot harness. Learn more in Build an agent.
- Any alternative model for a task agent must meet your organization's availability and access requirements.
Instructions don't override model availability or access requirements.
Decide when to use task agents
Use task agents when you can give each assignment a clear scope, enough context to complete it, and an expected result.
| Scenario | When a task agent can help | When to handle the work directly |
|---|---|---|
| Independent research | Investigate separate questions or sources, then combine the findings. | Answer a single question with a short lookup. |
| Focused analysis | Examine one document or a defined subset of information without adding every intermediate detail to the parent's working context. | Perform a short calculation or transformation. |
| Separate review | Check a substantial draft for unsupported claims, omissions, or counterarguments. | Make a small wording change or check a simple fact. |
| Parallel work | Work on independent parts of a request at the same time. | Complete steps that depend on the result of the preceding step. |
Delegation adds coordination work. The parent agent must describe the assignment, provide relevant context, assess the result, and combine it with other work. For a small task, doing the work directly can be more effective.
Note
Task agents can increase total token and Copilot Credit consumption, although separate working contexts can sometimes reduce repeated processing. Weigh the quality and completeness of the final response against the total cost of the request. Faster parallel execution doesn't necessarily mean lower cost.
Distinguish task agents from other components
Choose the component that matches how you want to organize the work:
| Component | Use it to |
|---|---|
| Task agent | Delegate a bounded assignment as part of the parent agent's work. |
| Skill | Package reusable task instructions and supporting resources. A skill can guide when and how to delegate to task agents. |
| Connected agent | Invoke a separately configured agent that can have its own ownership, model, and publishing lifecycle. |
Understand how delegated work runs
The parent agent assigns a task to a task agent and uses the result when the assignment finishes. Each task agent has its own context window, separate from the parent agent's context window. This separation keeps detailed intermediate analysis out of the parent's context. Provide the task agent with the relevant background, constraints, and expected output rather than assuming it knows every detail of the conversation.
Independent assignments can run in parallel within the request. The parent waits for delegated work to return; task agents don't run as background jobs that continue after the parent finishes the turn.
Task agents have access to the parent agent's tools and shared workspace, subject to the same permissions. Workspace files are shared, not copied into a separate workspace for each task agent. Changes a task agent makes to a shared file are visible to the parent and other task agents. Coordinate file changes to avoid conflicting edits, especially when assignments run in parallel.
Guide task agents through instructions
In the Build tab, edit your agent's Instructions to describe when delegation is useful and when the agent should work directly. Learn more in Configure agent details and instructions.
For each delegated assignment, specify:
- Scope: The question or part of the request to handle, and what to leave out.
- Context: The relevant information, sources, and constraints.
- Result: The format and level of detail to return.
- Boundaries: Actions to avoid, such as changing shared files or performing work already assigned elsewhere.
In your agent's Instructions, you can require delegation for a defined type of task or set a general rule that lets the parent decide when to delegate. Choose and adapt the following examples to match your agent's intended behavior.
Delegate a specific task
Add instructions that identify the type of task the agent should delegate and the result you expect:
When a user asks you to review an expense policy, use a task agent to
check the provided policy for ambiguous requirements and missing
exceptions. Ask it to return a table with the relevant section, the issue,
and a suggested clarification. Do not edit the document. Assess the
findings yourself and summarize the issues that need attention.
These instructions direct the agent to delegate whenever it handles that type of task. The next example instead gives the agent a general rule for deciding whether delegation is appropriate.
Delegate selectively
Give the agent guidance on when it can choose to use a task agent and when it should handle the work directly:
Handle simple requests directly. Use task agents when a request contains
independent research or analysis assignments that benefit from separate
working contexts. Give each task a clear scope and expected output.
Avoid duplicate work, and combine and assess the returned findings yourself.
Guide parallel work
Explain which parts of the work are independent and what the parent should do with the results:
When comparing several policy documents, you may delegate the analysis of
each document to a separate task agent. Ask each task agent to return the
requirements, exceptions, and supporting references in the same format.
Do not have multiple task agents edit the final comparison. Combine their
findings yourself and resolve differences before responding.
Prefer direct execution and avoid using task agents
If delegation isn't appropriate for your agent's purpose, state that preference explicitly:
Complete requests yourself without delegating to task agents.
Instructions guide model behavior; they aren't an enforced availability or access control. Test whether the agent follows the intended delegation policy.
Try task agents and review the trace
Use the expense policy example to try delegation in Preview. When your agent uses a task agent, the activity trace shows a Task node for the delegated assignment. As with tool calls, you can expand the node to review its input parameters and output results.
- In the Build tab, add the Delegate a specific task example to your agent's Instructions and select Save.
- In the Preview tab, attach a sample expense policy document.
- Ask your agent to review the policy for ambiguous requirements and missing exceptions.
- Find the Task node in the activity trace.
- Select the node to expand its details and review the assignment sent to the task agent and the result it returned.
- Verify that the assignment matches your intended scope and that the returned result meets your requirements.
The task entry shows the delegated assignment and its result, not every internal or nested step. Learn more in Use the activity trace to debug your agent.
Request a different model for a task
By default, a task agent inherits the parent agent's model. You can instruct the parent to request an alternative model for delegated work. This choice doesn't change the parent agent's model.
Note
A task agent can use only models available for delegated work in your environment. The available models depend on model support, your organization's controls, and applicable access and consent requirements. Naming a model in your instructions doesn't make it available or override these requirements. A model listed elsewhere in Copilot Studio might not be available for task agents. Learn more in Model availability in Copilot Studio.
For example, add the following to your agent's Instructions to request a review by a model from a different family:
For substantial recommendations, use a task agent to review the draft with
an available model from a different model family than your own.
Ask the reviewer to identify unsupported claims, missing evidence, and
counterarguments. Assess the findings before revising your response.
A different model family can provide another perspective, but it doesn't guarantee a correct or independent assessment. Continue to verify claims against supporting evidence.
Evaluate quality, response time, and consumption
Test representative requests with and without delegation before making task agents part of your agent's general instructions. Include simple requests as well as requests that could benefit from parallel work.
Compare:
- Quality: Did delegation improve the completeness, accuracy, or usefulness of the final response?
- Response time: Did independent work finish sooner, or did coordination add delay?
- Total consumption: Did the complete request consume more or fewer Copilot Credits?
- Duplication: Did task agents repeat each other's work, or did the parent repeat work it had delegated?
- Instruction adherence: Did the agent delegate only when appropriate and respect any model requirements?
Token volume, model choice, tool use, and coordination all affect consumption. For credit measurement and monitoring, see Overview of usage-based billing. Use agent evaluations to compare response quality across a representative set of requests.