What You’ll Learn

By the end of this article, you will clearly understand:

What the Microsoft 365 Agents SDK is and why Microsoft built it
How it fundamentally differs from the Skills-based approach
The core concepts and terminology you must know
The real benefits of using Agent SDK in production
When Agent SDK is the right choice (and when it isn’t)
What kinds of solutions you can realistically build with it

This article is designed for beginners, especially those coming from Copilot Studio Skills or Power Virtual Agents.

Introduction

In Part 1, we learned that Copilot Studio Skills were created to extend bots beyond simple conversations. They solved important problems—but they required manual orchestration, rigid triggers, and complex configuration.

Now imagine a different world.

Instead of your main bot explicitly calling tools and managing every step, imagine having a team of intelligent agents:

Each agent understands its responsibility
Each agent understands context
Agents collaborate automatically
You don’t micromanage message routing

This is exactly the shift introduced by the Microsoft 365 Agents SDK.

The Agent SDK represents Microsoft’s move from tool-based extensibility to agent-based collaboration.

What Is the Microsoft 365 Agents SDK?

The Simple Explanation

The Microsoft 365 Agents SDK (commonly called Agent SDK) is a framework that allows you to build intelligent, autonomous agents that:

Understand natural language conversations
Maintain context across interactions
Decide what actions to take
Collaborate with other agents
Integrate deeply with Microsoft 365

Instead of building something that waits for instructions, you build something that thinks, decides, and acts.

A Simple Analogy

Skills (Old Model)

Skills behave like tools.

You must:

Decide when to use them
Call them explicitly
Handle every response manually

You → Call tool → Get result → Decide next step → Call another tool

Agent SDK (New Model)

Agent SDK lets you build team members.

You → Explain the problem
Agent → Understands context → Takes action → Collaborates → Resolves

This is a fundamental architectural shift, not just a technical upgrade.

Supported Languages

According to Microsoft documentation, the Agents SDK officially supports:

Python
JavaScript / TypeScript
C# (.NET)

These languages are first-class supported for building, running, and integrating agents.

Why Microsoft Built the Agent SDK

The Bigger Vision: Multi-Agent Systems

Microsoft recognized a hard truth:

The future of AI is not one super-bot doing everything.

Instead, the future looks like:

One orchestrator (parent) agent
Multiple specialist (child) agents
Context-aware collaboration
AI-driven routing decisions

The Skills model could not support this vision cleanly or sustainably.

Problems with the Skills Model

Problem 1: Manual Orchestration

With Skills, developers had to explicitly manage:

When to call a Skill
What activity to send
How to handle responses
When to end conversations

This approach was fragile and error-prone.

Problem 2: No Intelligence in Routing

Skills depended on:

Exact trigger phrases
Predefined topics

This broke natural language conversations.

Problem 3: High Maintenance Cost

Even small changes required:

Updating the Skill
Updating the manifest
Updating Copilot topics
Republishing agents

At enterprise scale, this became painful.

What Agent SDK Fixes

Agent SDK introduces AI-driven orchestration.

Instead of writing rules like:

“If the user says X, call Skill Y”

You describe intent, and the platform decides when and how to route the conversation to the appropriate agent.

Key Concepts You Must Understand

1. Agent

An agent is an intelligent conversational entity that can:

Interpret user intent
Maintain conversation context
Decide what actions to take
Communicate naturally
Collaborate with other agents

Agents can be implemented using:

.NET (primary)
Python (Bot Framework)
TypeScript (Bot Framework)

2. Parent Agent and Child Agents

Parent Agent

Typically your Copilot Studio agent
Acts as the orchestrator
Decides which agent should handle a request

Child Agent

Built using Agent SDK (.NET) or Bot Framework (Python/TS)
Specializes in a specific responsibility
Can temporarily take over a conversation

Copilot Studio Agent
 ├── Live Agent Handoff Agent
 ├── Billing Agent
 └── Order Status Agent

This is true multi-agent architecture.

3. Activities

Activities represent events in a conversation:

Message
Event
ConversationUpdate
EndOfConversation

Agent SDK abstracts most of this complexity.

4. Turn Context

The turn context contains:

User information
Channel (Teams, Web, etc.)
Message content
Conversation history

It is the agent’s situational awareness.

5. Proactive Messaging

Proactive messaging allows agents to message users without waiting for user input.

This is critical for:

Live agent replies
Status updates
Long-running workflows

Agent SDK supports this natively; Bot Framework supports it across languages.

6. Agent Orchestration

Agent orchestration means:

Copilot Studio understands when another agent is required
Routing happens automatically
Control flows naturally between agents

No explicit “call skill” actions are required.

Architecture Overview (Conceptual)

At a high level:

Users interact via Teams, Web Chat, or other channels
Messages flow through Bot Framework
Copilot Studio acts as the parent agent
Child agents are invoked automatically
External systems are handled by specialized agents

This architecture is:

Cleaner
More scalable
Easier to reason about

Benefits Over Skills

1. Massive Reduction in Configuration

No manifests
No manual activity wiring
No rigid topic logic

2. Natural Conversations

Users speak naturally.
AI decides routing.

3. Developer-Friendly (Multi-Language)

.NET → Primary, most feature-complete
Python → Bot Framework–based agents
TypeScript → Bot Framework–based agents

All use standard frameworks, not Copilot-specific DSLs.

4. Easier Maintenance

Update code → Redeploy agent

No topic rewiring.

5. Microsoft’s Forward Investment

Skills are deprecated
Agent SDK is actively developed
This is Microsoft’s long-term strategy

What You Can Build with Agent SDK

Live agent handoff systems
Secure payment flows
IT helpdesk automation
HR onboarding assistants
CRM-integrated sales agents
Multi-language support agents

With:

Context awareness
Proactive messaging
Multi-agent collaboration

When You Should Use Agent SDK

Use Agent SDK When:

Building new Copilot Studio solutions
You need intelligent routing
You expect future growth

Consider Alternatives When:

Only simple automation is needed
No conversational context is required
Maintaining existing Skills temporarily

Key Takeaways

Agent SDK replaces Skills conceptually and architecturally
It introduces true multi-agent systems
Orchestration becomes intelligent
Development is simpler and more maintainable
This is Microsoft’s long-term direction

What’s Next

In Part 3, we move from theory to practice.

You will:

Set up your development environment
Create your first Agent SDK project
Run and test your agent locally

Final Thought

You’ve now crossed the most important shift in Copilot Studio development:

From calling tools → to collaborating agents.

Let’s build. 🚀

Introduction to Microsoft 365 Agents SDK