Connected Agents: The Delegation Pattern for Declarative Agents

When your declarative agent’s instructions hit 8,000 characters and the model reaches for the wrong tool every other turn, you’ve hit agent scope creep. The answer is to connect the Zava Insurance HR Onboarding Buddy to an ecosystem of specialist connected agents.

What Are Connected Agents?

Connected agents let your declarative agent delegate tasks to other specialist agents in your organization. Your agent stays the front door. The user talks to the HR Buddy, always, but behind the scenes, Copilot routes specific questions to worker agents purpose-built for deep expertise.

It’s a microservices architecture for AI assistants. One conversation, multiple expert agents working behind the scenes.

For Zava Insurance, the setup looks like this:

• HR Onboarding Buddy: The agent we’ve been building. General onboarding questions, policies, task tracking, the day-to-day stuff new hires need.
• IT Support Agent: A separate agent owned by the IT team. Deep troubleshooting, device management, known issues databases, software requests.
• Benefits Advisor Agent: A dedicated agent built by the Total Rewards team. Full health plan documents, cost comparison calculators, enrollment workflows, 401(k) modeling.

Each agent is maintained by the team that owns the expertise. The HR Buddy delegates to them when needed. The user stays in one seamless conversation.

Configuring Worker Agents

In the declarative agent manifest (schema v1.6), connected agents are configured through the worker_agents property: a top-level array that references other deployed agents by their title ID.

{
  "$schema": "https://developer.microsoft.com/json-schemas/copilot/declarative-agent/v1.6/schema.json",
  "version": "v1.6",
  "name": "HR Onboarding Buddy",
  "description": "A friendly assistant to help new employees at Zava Insurance.",
  "instructions": "$[file('instructions.txt')]",
  "worker_agents": [
    {
      "id": "T_a1b2c3d4-e5f6-7890-abcd-ef1234567890"
    },
    {
      "id": "T_f9e8d7c6-b5a4-3210-fedc-ba9876543210"
    }
  ]
}

Each id is the title ID of the target agent’s application, available when you publish through the Agents Toolkit or in the agent metadata section of developer mode.

How Delegation Works

Delegation is completely invisible to the user. They see a single conversation with the HR Onboarding Buddy. When Copilot determines that a question falls within a worker agent’s expertise, it routes the query, gets the response, and presents it as part of the same conversation. No switching. No “let me transfer you.” No friction.

From the user’s perspective, the HR Buddy is just really good at everything. Behind the scenes, specialists are doing the heavy lifting.

The Rules of Delegation

There are a few critical things to understand about how this works:

Same tenant requirement. Both agents must be deployed in the same Microsoft 365 tenant. The connected agent needs to be installed and available before your agent can delegate to it. No cross-tenant connections.

Independent configuration. Each connected agent maintains its own complete setup: its own instructions, knowledge sources, API plugins, MCP servers, and guardrails. The IT Support Agent has its own SharePoint sources and tool integrations. You don’t duplicate any of that in the HR Buddy’s manifest.

Permissions are respected. If the connected agent has access to data the user doesn’t have permission to see, that data won’t surface. Each agent operates within the user’s permission context. Security boundaries are maintained across every delegation.

Helping the Model Delegate

Copilot is surprisingly good at figuring out delegation on its own. The worker agents’ names and descriptions give it enough context to route most queries correctly. But there are a few levers you can pull to improve routing reliability.

Worker agent description. The description field of each connected agent acts as its routing signal. A tightly scoped description (like “Deep IT troubleshooting, device management, and software requests for Zava Insurance employees”) gives Copilot a precise match surface. Vague descriptions lead to missed delegations.

Conversation starters. The connected agent’s conversation starters also help Copilot understand what it handles. Starters like “Troubleshoot my laptop”, “Request software access”, or “Compare health plan options” give concrete examples of the queries that agent should own. Copilot uses these as additional routing signals when deciding whether to delegate.

Explicit instructions in the orchestrator. Beyond the worker agents’ own metadata, explicit instructions in the HR Buddy’s instructions.txt improve reliability:

“When a user asks a deep IT troubleshooting question that goes beyond basic setup instructions, or asks for detailed benefits comparisons and enrollment advice, delegate to the appropriate specialist agent. You don’t need to tell the user you’re delegating: just provide the best possible answer.”

The Zava Insurance Scenario

Imagine you’re a new Zava Insurance employee on your second day.

IT Delegation

You didn’t need to know the IT Support Agent exists.

Benefits Delegation

Deep domain expertise, not a generic answer from a one-page summary.

Seamless Context

You’re still in the same conversation:

The user never thinks about which agent to talk to.

The Value: Compose Specialists, Maintain Independently

Connected agents aren’t about making one agent smarter. They’re about building an agent ecosystem.

Compose, don’t duplicate. The IT team builds and maintains the IT Support Agent. The Total Rewards team owns the Benefits Advisor. The HR team manages the Onboarding Buddy. Each team iterates independently on their domain, updating knowledge, refining instructions, and adding new tools, without coordinating with every other team.

Build horizontal workers. Think about agents that multiple teams can connect to: a Helpdesk Agent that any department’s agent can delegate to, a Compliance Agent that surfaces regulatory info across the organization, a Benefits Agent that HR, Finance, and manager agents all leverage. You’re not building one massive agent: you’re building a network of reusable specialists.

Scale without degradation. Instead of one agent with 15 knowledge sources and 8,000 characters of instructions getting confused, you have three focused agents that each excel in their lane. Quality stays high as organizational scope grows.

Resources

• Connected Agents Overview: Microsoft Learn
• Declarative Agent Schema v1.6 Reference
• Build a Declarative Agent: Microsoft Learn
• Microsoft 365 Agents Toolkit: VS Code Marketplace