What is the recommended pattern for integrating Azure AI Agent with Copilot Studio so that the agent’s output can be used as variables inside topics?

The recommended pattern is to treat the Azure AI Agent as an external tool or child agent and integrate it through Copilot Studio’s existing integration patterns, then expose its results as structured outputs that Copilot Studio can bind to variables in topics.

From the available guidance, the relevant patterns are:

1. Use Copilot Studio tools or topics to call external services
   • Copilot Studio supports integration via Power Platform connectors, HTTP requests, and other mechanisms. These can be attached either as:
     • Tools: invoked by generative orchestration when the agent decides they are needed.
     • Topic nodes: invoked deterministically at a specific point in a topic.
   • When using tools or topic nodes, inputs and outputs are defined as parameters that map directly to Copilot Studio variables.
   • For HTTP-based services, use an HTTP node or a connector that wraps the Azure AI Agent endpoint. The node/connector defines:
     • Input parameters (for user query and any additional parameters).
     • Output schema (fields returned from the agent) that Copilot Studio can store in variables.
2. Prefer structured outputs and explicit topic inputs/outputs
   • Topics should define clear input parameters (for example, UserQuery, SearchScope) with human-readable names and descriptions. Generative orchestration uses these to collect missing values automatically.
   • Topics can also define output variables (for example, SearchResults, EvidenceSummary). These outputs are then available to the orchestrator and other topics.
   • The guidance recommends avoiding “double-handling” data in prompts. Instead of feeding raw text back into the LLM, treat the Azure AI Agent’s response as structured data (JSON fields) and expose those as topic outputs. Copilot Studio then uses those outputs in subsequent steps or to compose the final answer.
3. Integration pattern choice for Azure AI Agent
   • For calling APIs or HTTP-based services (which includes an Azure AI Agent exposed over HTTP), the recommended approaches are:
     • Custom connectors / HTTP tools when connecting to APIs or basic HTTP services.
     • These are used as tools or topic actions inside Copilot Studio.
   • Copilot Studio integration patterns are not exclusive and can be combined. For example:
     • A topic calls a Power Automate flow or HTTP node that invokes the Azure AI Agent.
     • The flow returns structured JSON, which the connector or HTTP node maps to output variables.
     • Another topic consumes those variables for routing or post-processing.
4. Multi-agent and workflow-oriented orchestration
   • For more deterministic, multi-step processes (for example, “call Azure AI Agent for retrieval, then call another agent for reasoning, then apply approvals”), use a workflow engine such as Power Automate, Logic Apps, or Copilot Studio topics to orchestrate the sequence.
   • Each step (including the Azure AI Agent call) should have clear preconditions, post-conditions, and structured outputs so that the next step can consume them.
   • This pattern is suitable when strict ordering, auditability, and human-in-the-loop approvals are required.
5. Using the Azure AI Agent output in Copilot Studio
   • The key is to ensure the Azure AI Agent returns structured data (for example, JSON with named fields) that the connector or HTTP node can map to:
     • Topic output variables (for use in generative orchestration and final responses).
     • Intermediate variables for routing (for example, a classification field that determines which topic to call next).
   • Copilot Studio’s generative orchestration then uses these outputs to:
     • Combine them with other topic outputs.
     • Decide which additional tools or topics to invoke.
     • Compose the final answer to the user.
6. Authentication and payload details
   • The provided context does not specify the exact authentication method, request schema, or response format for Azure AI Agent endpoints. The general pattern from the documentation is:
     • Use HTTP requests or custom connectors for services not covered by prebuilt connectors.
     • Define URI, method, headers, and body on each HTTP request node.
     • Design the response schema so that Copilot Studio can bind response fields to variables.
   • Specific token acquisition, headers, and payload structure for Azure AI Agent must follow that service’s own API documentation, which is outside the provided context.
7. Responsible AI and governance
   • When integrating an external agent, apply responsible AI guardrails:
     • Pass only the minimum necessary fields to the Azure AI Agent.
     • Use human-in-the-loop review before any writeback or high-impact action.
     • Clearly label AI-generated insights and track which agent or topic produced them.

In summary, the recommended architecture within Copilot Studio is:

1. Expose the Azure AI Agent as an HTTP-based tool or custom connector.
2. Define topic inputs (user query and parameters) that map to the request payload.
3. Have the Azure AI Agent return structured JSON.
4. Map response fields to topic output variables.
5. Use generative orchestration and/or workflow-oriented patterns to route and post-process those outputs across topics and agents.

References:

• Plan and design integration strategies
• Connect an agent available over the Agent2Agent (A2A) protocol (preview)
• Apply generative orchestration capabilities
• Use Copilot Studio agents in model-driven apps
• Process to build agents across your organization
• Search and tool use architectures
• Workflow-oriented multi-agent patterns
• How can I publish a CoPilot from Studio while having it reference my connector for the agent instead of asking users for their own? - Microsoft Q&A