Microsoft has quietly added a new item to the Microsoft 365 Roadmap that signals a major leap in enterprise AI automation. Roadmap item 566998, published on July 1, 2026, reveals that Copilot Studio will soon let makers invoke published agents as discrete workflow steps through a dedicated \"agent node.\" The feature is already available in preview, having launched in April 2026, and marks the first time that autonomous agents built in Copilot Studio can be chained together in a governed, reusable fashion.
The addition addresses a long-standing demand from enterprise developers and citizen makers who have been building custom AI copilots and autonomous agents within Microsoft's low-code platform. Until now, while Copilot Studio allowed the creation of sophisticated agents that could call APIs, query data sources, and execute logic, there was no native way to orchestrate multiple agents as part of a single end-to-end workflow. The new agent node changes that, enabling a new class of multi-agent automation that promises to streamline business processes across the Microsoft 365 ecosystem.
What's New: Agent Node in Copilot Studio (Preview)
At the heart of this update is the agent node—a dedicated workflow action that allows a Copilot Studio maker to call any previously published agent from within the canvas of a new or existing workflow. Think of it as calling a function in code, but at the level of an AI agent: the node passes a request to the published agent, which then executes its configured logic and returns a response that can be used by subsequent steps.
According to the roadmap description, the feature is intended for agents that have been published to a catalog accessible by the workflow. This implies a degree of governance: only agents that have been approved and shared through the organization's catalog can be invoked, reducing the risk of shadow AI and ensuring that each agent complies with enterprise security and data handling policies.
The preview, which began in April 2026, gives early-adopter organizations a chance to test the agent node in non-production environments. Microsoft has not yet announced a general availability date, but the roadmap entry confirms that development is well underway and that the feature is expected to roll out to all Copilot Studio users in the coming months.
Why Agent Chaining Matters for Enterprise Automation
For large organizations, business processes rarely consist of a single task. An employee onboarding workflow, for example, might require creating a user account in Entra ID, assigning licenses, sending a welcome email, provisioning access to SharePoint sites, and creating a ticket in the IT helpdesk system. Each of those steps could be handled by a specialized AI agent—but orchestrating them manually or through brittle Power Automate flows is cumbersome.
The agent node brings true modularity to AI-driven automation. By allowing makers to compose workflows from reusable, published agents, Copilot Studio enables a \"building block\" approach where domain experts can build and maintain individual agents (e.g., an HR policy agent, a legal compliance checker, an IT provisioning bot), while process designers can stitch them together into complex, adaptive workflows.
This not only reduces duplication—the same HR policy agent can be invoked from dozens of onboarding, offboarding, and transfer workflows—but also dramatically simplifies maintenance. When a policy changes, only the agent needs updating; every workflow that calls it automatically benefits. This separation of concerns is a hallmark of modern software engineering, and its arrival in Copilot Studio signals Microsoft's commitment to bringing enterprise-grade software practices to low-code AI development.
Moreover, because the agents are published through a governed catalog, IT administrators retain visibility and control. They can audit which agents are being called by which workflows, enforce data loss prevention (DLP) policies, and ensure that only approved AI models and connectors are used. For industries with strict compliance requirements, this governance layer is not just nice to have—it's essential.
How the Agent Node Works: Integrating Published Agents into Workflows
While Microsoft has not yet released detailed technical documentation, the roadmap description and the preview availability give us a clear picture of the intended functionality. Here's how it likely works based on current Copilot Studio capabilities:
First, a maker builds an autonomous agent using the Copilot Studio design canvas. This agent might use large language models to interpret user intents, call Microsoft Graph APIs, execute Power Automate flows, or interact with custom connectors. Once the agent is tested and ready, the maker publishes it to the organization's agent catalog—a centralized repository that has been part of Copilot Studio since its early releases.
Next, when creating a new workflow (which could itself be a \"master agent\" or a traditional Power Automate cloud flow augmented with AI), the maker drags the new agent node onto the canvas. The node prompts the maker to select a published agent from the catalog. The maker can then configure the input payload—likely a JSON object containing parameters such as user ID, request type, or conversation context—and map dynamic data from previous steps.
At runtime, when the workflow reaches the agent node, Copilot Studio sends the configured request to the chosen published agent. That agent processes the request, using its own AI logic, and returns a structured response. The workflow can then branch based on the response, passing data to subsequent steps or even calling additional agents in sequence or in parallel.
Crucially, because the agent node calls a published agent, the interaction benefits from all the existing governance controls: authentication via Microsoft Entra ID, DLP policies, and usage analytics. The calling workflow does not need to know the internal workings of the called agent—only its interface (the input and output schema). This loose coupling is exactly what enterprise architects have been asking for.
Governance and Control: Publishing Agents for Reuse
The emphasis on \"published agents\" in the roadmap item is deliberate. For years, organizations have struggled with \"shadow IT\" and, more recently, \"shadow AI\"—employees creating powerful automations with little oversight. By requiring agents to be published to a managed catalog before they can be invoked as workflow steps, Microsoft is baking governance into the fabric of agent chaining.
Publishing in Copilot Studio typically involves an approval process. A maker submits an agent for review; an administrator or designated approver checks that the agent uses only approved connectors, respects data sensitivity labels, and does not violate company policies. Once approved, the agent becomes available in the catalog, complete with versioning and lifecycle management.
The agent node only surfaces published agents, so makers cannot accidentally or maliciously call an untested, unauthorized agent. This is particularly important for workflows that handle sensitive data, such as those in finance, healthcare, or human resources. It also means that a single agent can be shared across departments without each team needing to build their own version—a significant efficiency gain.
Furthermore, because published agents carry metadata about their capabilities, usage, and owner, the agent node can provide a transparent audit trail. Every time an agent is called as part of a workflow, the event is logged. This supports not only compliance but also cost management: many Copilot Studio agents consume AI credits or API calls, and knowing exactly which workflows invoke which agents helps IT forecast and optimize spending.
The Road Ahead: From Preview to General Availability
The addition of roadmap item 566998 on July 1, 2026, three months after the preview began, suggests that Microsoft is now ready to signal the feature's upcoming general release. Typically, preview periods for Copilot Studio features last between three and six months, though some have stretched longer depending on feedback and stability.
While the preview is open to any organization with a Copilot Studio license, Microsoft is likely using telemetry and direct customer input to refine the agent node's performance and user experience. Key areas to watch include:
- Performance: How much latency does the agent node introduce when calling another agent? For real-time workflows, even a few seconds of extra delay can be unacceptable.
- Error handling: What happens when a published agent returns an error or times out? Will the workflow be able to gracefully retry or route to a fallback agent?
- Complex parallel execution: Can multiple agent nodes be configured to run in parallel and then join their results? Many business processes could benefit from calling legal, HR, and IT agents simultaneously.
- Cross-environment compatibility: Will agents built in one environment (say, Development) be callable from a workflow in another (Production) once both are published to the same catalog?
Microsoft has a track record of actively seeking feedback during previews and iterating quickly. Users who want to influence the final feature set should join the official Copilot Studio community or their respective Microsoft 365 Insider program and provide candid feedback about their experiences.
Practical Implications for Makers and Developers
For the growing community of Copilot Studio makers—a mix of pro developers, IT pros, and citizen developers—the agent node is a game changer. It elevates Copilot Studio from a tool for building single-purpose chatbots and enterprise search assistants to a platform for orchestrating intelligent process automation at scale.
Consider a common enterprise scenario: an employee submits an expense report. A well-designed workflow could involve:
- A document-processing agent that extracts line items from a PDF receipt.
- A policy-checking agent that validates whether each line item complies with the company travel policy.
- A manager-approval agent that routes high-value items to the employee's manager with contextual justification.
- An ERP agent that creates journal entries in the finance system upon approval.
Each of these agents can be built by subject-matter experts—the finance team builds the policy checker, the IT team builds the ERP connector—and published to the catalog. The workflow designer simply chains them together with the new agent node, focusing on the logic and sequencing rather than reinventing the wheel each time.
Moreover, because the agent node is a first-class citizen in the Copilot Studio workflow canvas, it can be combined with other control structures such as conditions, loops, and parallel branches. This means makers can build workflows that adapt dynamically based on agent responses. For instance, if the policy checker returns a red flag, the workflow could automatically invoke a compliance officer agent for review before proceeding.
The low-code nature of Copilot Studio means that line-of-business experts who are not professional developers can still participate in building these automations. By encapsulating complex AI logic in reusable agents, the platform reduces the technical barrier for creating sophisticated, multi-step AI processes.
A Step Toward Autonomous AI Workflows
The agent node is more than just a new feature; it represents a shift in Microsoft's vision for enterprise AI. Satya Nadella and other executives have repeatedly spoken about a future where autonomous agents handle routine business tasks, collaborating with humans and with each other. The agent node is a concrete piece of infrastructure that makes that vision practical.
By enabling published agents to be composed into workflows, Microsoft is implicitly encouraging organizations to build libraries of single-purpose, well-tested agents that can be combined in countless ways. This aligns with the broader industry trend toward agentic architectures, where complex problems are solved by teams of specialized AI agents rather than a single monolithic model.
However, with great power comes great responsibility. The ease of chaining agents could lead to overly complex workflows that are difficult to debug. It could also exacerbate cost concerns if each agent call consumes significant AI resources. Microsoft will need to provide robust tooling for monitoring, debugging, and optimizing these multi-agent workflows, as well as transparent cost breakdowns.
For now, the preview of the agent node is a clear signal that Copilot Studio is maturing into a serious enterprise platform. Makers who have been waiting for the ability to compose agents into larger solutions should start experimenting today. Those responsible for governance should begin planning how to structure their agent catalogs and approval processes to support this new capability.
As the feature moves toward general availability, it will be fascinating to see what innovative automations the Copilot Studio community creates. One thing is certain: the way organizations build and scale AI-powered processes is about to change fundamentally.