Copilot Studio: Inline Agents for Models

Key insights

• Inline agents (aka child agents) are small sub-agents built inside a workflow to handle one focused task, like extracting data or translating text.
  They let a larger workflow delegate narrow work without leaving the orchestration context.
• The new Agent node in the workflow designer lets you create an inline agent directly, or call a published agent, pass dynamic data, and use connectors or tools to ground responses in knowledge sources.
  This keeps the agent’s instructions, tools, and outputs tied to the workflow for easier orchestration.
• How to add and use an inline agent: open Build, add the Agent node, pick an existing agent or choose New agent for this workflow, then set instructions, tools, and grounding options.
  Use the agent’s output in downstream steps or branches to continue the workflow.
• When to use inline agents: pick them for tasks specific to one workflow that don’t need reuse.
  If you reuse the same inline agent often, promote to a published agent so multiple workflows can call it.
• Best practices: keep each inline agent to a single responsibility, test prompts per run, and treat agents like subroutines you can reason about and debug.
  Limit inputs, monitor results, and balance cost and quality through configuration.
• The multi-model update (including Anthropic) lets makers choose the best model per step using the prompt builder and orchestration controls.
  Use model selection to match tasks to models for better accuracy, cost, and performance.

Introduction

Daniel Christian [MVP] published a detailed YouTube walkthrough that explains how to build inline agents inside a Copilot Studio workflow and use them for multi-model scenarios. The video breaks the process into clear stages and demonstrates a practical example that includes form triggers, classification, inline agent actions, human review, cleanup, and email delivery. As a result, viewers can see how small, focused agents operate inside a larger orchestration and how makers can mix models for different steps. Consequently, the presentation aims to make the new capabilities in Copilot Studio accessible to makers and developers.

The video also highlights a recent expansion in model choices, noting support beyond Microsoft models to include providers such as Anthropic. This change enables makers to pick the model that fits each subtask rather than relying on one model family across the whole workflow. The author frames this as an important evolution for real-world automations where quality, cost, and latency differ by task. Therefore, the guidance explores both design patterns and the practical tradeoffs of adopting multi-model flows.

What the Video Demonstrates

The demonstration begins with a Microsoft Forms trigger that feeds user input into a workflow, then uses a classifier to route content. After classification, Daniel shows how to add an Agent node and either create a new inline agent or call an existing published agent from the same designer. Next, the workflow either sends the agent output to a human review step or directly to a cleanup action performed by a Copilot node before sending an email. Throughout, the presenter emphasizes how each node passes dynamic data forward and how inline agents simplify localized logic.

Daniel pauses frequently to inspect configuration fields and to show what to put in the agent’s instructions, tools, and grounding knowledge. He demonstrates grounding responses with internal sources and shows how to include connectors when needed. Viewers watch the workflow run and see how outputs change when different model or instruction choices are applied. This live testing underscores how tuning at the node level affects downstream behavior.

In addition, the video compares creating a reusable, published agent with keeping an agent inline to the workflow. The presenter explains when promoting an inline agent to a published agent makes sense, especially if the same logic appears across multiple workflows. This distinction helps teams decide whether to optimize for reuse or for simplicity in a single workflow. Thus, the piece gives practical rules of thumb for maintainability and governance.

How Inline Agents Work in Practice

Inline agents, sometimes called child agents, act as small subroutines inside a parent workflow and focus on a single responsibility. They carry their instructions, tools, and output schema inside the agent node, so the configuration moves with the workflow and avoids separate publishing steps. Makers can configure a node to call an existing agent or to create a new one directly inside the designer, which speeds iteration and testing. As a result, teams can prototype quickly without managing separate agent lifecycles.

Typical steps to create an inline agent are straightforward and align with what Daniel demonstrates in the studio. First, open a workflow and add an Agent node; then choose to create a new agent for that workflow or select a published agent. After that, define instructions, tools, grounding, and outputs, and then route the response to downstream actions such as human review or formatting. These steps make inline agents useful for narrowly scoped tasks like extraction, translation, or targeted formatting.

• Add a workflow trigger and classifier.
• Insert an Agent node and create or select an agent.
• Configure instructions, tools, and grounding sources.
• Route output to human review, cleanup, and delivery steps.

Tradeoffs and Challenges

Using inline agents brings clear benefits, but it also involves tradeoffs that teams should weigh. On one hand, inline agents simplify orchestration by keeping logic next to the workflow, which reduces context switching and speeds iteration. On the other hand, repeated inline agents across many workflows can increase duplication, which points to the need to promote common logic into published agents to improve maintainability and governance.

Multi-model support adds flexibility but also introduces complexity around cost, latency, and quality tuning. Makers can assign a high-capability model to a reasoning step and a cheaper model to formatting, which helps balance budget and performance. However, coordinating prompts, handling differing output shapes, and testing interactions across models requires disciplined versioning and thorough test coverage. Moreover, debugging distributed behavior inside a multi-model orchestration can be harder than debugging a single-agent setup.

Operational concerns also arise when inline agents use connectors or external tools such as MCP servers and knowledge sources. Teams must manage access, security, and data grounding while ensuring responses remain accurate and auditable. Human review nodes help mitigate risk, but they add latency and require workflow designers to decide when manual checks are necessary. Consequently, builders must design with both automation and oversight in mind.

Conclusion

Daniel Christian’s video delivers a clear, practical guide to using inline agents in Copilot Studio, and it shows how multi-model options broaden what makers can do inside workflows. The tutorial balances step-by-step configuration with real-world considerations, helping viewers understand when to choose inline versus published agents and how to mix models for task fit. As a result, the material serves both as an instructional walkthrough and as a prompt to plan governance and testing strategies for production scenarios.

Ultimately, the approach invites teams to trade simplicity for reusability or vice versa, and to balance cost against quality when selecting models. With careful testing, grounding, and review policies, inline agents can speed development while supporting robust automations in diverse, multi-model environments. The video therefore offers actionable guidance for teams looking to adopt these patterns in their own Copilot Studio projects.

Keywords

Inline agents Copilot Studio, Multi-model Copilot Studio, Copilot Studio inline agent tutorial, Copilot Studio agent orchestration, Use inline agents multiple models, Microsoft Copilot multi-model guide, LLM orchestration Copilot Studio, Build multi-model workflows Copilot Studio