Explore agent development approaches and tools
Every agent depends on the same set of functional layers, regardless of platform. Understanding those layers first makes development approach decisions easier to reason through — because the difference between approaches is how much of each layer is handled for you versus how much you configure or code yourself.
The layers of agent development
Building an agent involves five core functional areas:
| Layer | What it does |
|---|---|
| Agent development platform or service | How you build, configure, host, and publish the agent |
| Model | The AI model that powers the agent's reasoning and responses |
| Orchestration | The logic that controls how the agent reasons, calls tools, and coordinates with other agents |
| Channel / UX | How the agent reaches users, integrates with surfaces, and presents its experience through user interfaces |
| AI-assisted development | Coding tools that accelerate software development |
How much control you have over each of these layers depends on your development approach.
Choose a development approach
Microsoft's platform supports three primary development approaches, each suited to a different team profile and level of customization:
| Approach | Best fit | How the layers are handled |
|---|---|---|
| No-code (Agent Builder in Microsoft 365 Copilot) | Individuals, small teams | All layers handled by the platform. You configure instructions, knowledge sources, and capabilities; everything else is generally managed for you. |
| Low-code (Microsoft Copilot Studio) | Makers, business users, developers | Copilot Studio serves as agent platform, model host, orchestration engine, and channel delivery layer in one. You configure each area through a visual canvas, with code extensions and customization available for certain areas. |
| Pro-code (Microsoft Foundry + SDK ecosystem) | Developers, engineering teams | Each layer is a separate, explicit choice. You select your agent platform, model, orchestration framework, and channel delivery independently—with full control over each. |
The key difference: In the no-code and low-code paths, one platform covers multiple layers at once. In the pro-code path, each layer is a distinct set of tools you choose and connect yourself.
No-code: Agent Builder in Microsoft 365 Copilot
Microsoft 365 Copilot includes Agent Builder, a no-code experience for creating lightweight agents directly within Microsoft 365. You configure instructions and connect knowledge sources; the platform handles everything else. This path fits individual productivity scenarios and small-team use cases where speed matters more than customization.
Low-code: Microsoft Copilot Studio
Copilot Studio provides a visual canvas where makers and developers work together. You configure instructions, connect knowledge sources, and define actions without writing application code. Copilot Studio supports both conversational agents (real-time, user-initiated) and autonomous agents (trigger- and schedule-driven). For scenarios that need more than the visual canvas, Copilot Studio supports customization through code, custom prompts using models from the Foundry model catalog, and direct API and connector integrations, making it viable for mixed teams.
Note
Copilot Studio and Foundry are more closely connected than they might appear. Generative AI features in Copilot Studio run on Microsoft Foundry infrastructure. Copilot Studio agents can also call Foundry-built agents as sub-agents, making it possible to combine low-code orchestration in Copilot Studio with custom AI logic built in Foundry.
Choose pro-code development tools and services
In the pro-code path, you make explicit choices at each layer. Microsoft Foundry is Microsoft's platform for building, deploying, and operating production-grade agents and AI applications—it's the anchor for the pro-code stack. The layers around it (models, orchestration, channel delivery) are generally modular and independently configurable.
| Layer | Pro-code options |
|---|---|
| Agent platform | Foundry Agent Service—prompt agents (configuration-based, fully managed) or hosted agents (containerized custom code); Foundry manages runtime, scaling, and identity |
| Model | Foundry model catalog—browse and deploy models from Microsoft and a wide range of other model providers |
| Orchestration | Microsoft Agent Framework (recommended), Semantic Kernel, other orchestration frameworks, or custom code |
| Channel / UX | Microsoft 365 Agents SDK (multichannel support), Teams SDK (Teams-specific UX customization), or direct API via the Agent Application endpoint |
| IDE and tooling | Visual Studio/Visual Studio Code (IDE), Microsoft 365 Agent Toolkit (for development targeting the Microsoft 365 ecosystem), GitHub Copilot (AI-assisted coding) |
Orchestration frameworks
For pro-code agents, the orchestration framework is the code layer that defines how the agent reasons: receiving input, calling the model, dispatching tools, managing state, and coordinating with other agents.
Microsoft Agent Framework is Microsoft's recommended open-source SDK for this layer. It unifies AutoGen's multiagent abstractions with Semantic Kernel's enterprise features into a single stable framework, automatically handling tool dispatch, conversation history, state management, and multiagent coordination.
Foundry is framework-agnostic. Teams can also use Semantic Kernel or other frameworks depending on existing skills and requirements.
Targeting the Microsoft 365 ecosystem
For agents targeting Microsoft Teams, Microsoft 365 Copilot, or other Microsoft 365 surfaces, the channel delivery layer has two pro-code options: the Microsoft 365 Agents SDK and the Teams SDK. Despite its name, the Microsoft 365 Agents SDK is a multi-channel SDK — it delivers agents across Teams, Microsoft 365 Copilot, Outlook, and external channels including web, email, and SMS. The Teams SDK is Teams-specific, focused on rich Teams experiences like adaptive cards and meeting context. Both are AI-agnostic — you choose your model and orchestration framework independently.
The Microsoft 365 Agent Toolkit is the VS Code and Visual Studio extension for scaffolding, testing, and deploying these agents. It supports declarative agents, custom engine agents, Teams apps, and Copilot extensions.
You'll explore publishing paths in more detail in the next unit.
Integrating with the Microsoft 365 Copilot ecosystem
The platform also provides APIs and SDKs for embedding Microsoft 365 Copilot capabilities in custom applications — and for bringing custom agents into Microsoft 365 Copilot.
The Microsoft 365 Copilot APIs give custom agents and applications secure, compliant access to the capabilities that power Microsoft 365 Copilot. The APIs include the Copilot Retrieval API (semantic and lexical retrieval from Microsoft 365's knowledge index), the Copilot Chat API (for embedding Copilot-powered conversation in custom apps), and the Copilot Search API (for hybrid search over enterprise content). All requests respect existing Microsoft 365 permissions and compliance controls — you don't rebuild security infrastructure.
The Work IQ API provides programmatic access to Work IQ — the intelligence layer that combines Microsoft 365 work data with contextual understanding so agents and applications can reason over emails, meetings, files, Teams messages, and people context without building custom indexing or compliance pipelines. It supports A2A, MCP, and REST protocols. (Work IQ also serves as a managed grounding service within Microsoft's IQ platform — that use case is covered in the next unit.)
When you've built an agent on Foundry or another platform, the Microsoft 365 Agents SDK also serves as an integration path for surfacing it in Microsoft 365 Copilot and the Agent Store. You wrap the existing agent with the SDK and package it with the Microsoft 365 Agent Toolkit to make it available in Microsoft 365 Copilot Chat.
Choose the right approach
Three signals point you toward the right development approach:
- Team profile: If your team includes makers or business users who need to build quickly without writing code, start with Copilot Studio. If you have a developer team building a production service, the pro-code path gives you the control you need. If your scenario is lightweight and individual-productivity-focused, Agent Builder in Microsoft 365 Copilot may be all you need.
- Customization requirements: Low-code tools cover most agent scenarios. Move to the pro-code path when you need fine-grained control over model selection, custom orchestration logic, advanced deployment configurations, network isolation, or CI/CD practices — or when agents need to be embedded as durable microservices in an existing application platform.
- Deployment target: Teams-native experiences with collaborative features (channels, meetings, adaptive cards) point toward the Teams SDK. Delivery to Microsoft 365 Copilot, Teams-plus-other-channels, or external channels such as web, email, and SMS points toward the Microsoft 365 Agents SDK.
These paths aren't mutually exclusive. An organization might use Foundry for a customer-facing service agent, Copilot Studio for an internal process automation agent, and Agent Builder for individual productivity — with each platform serving the team and scenario it fits best.
Guiding question: Which development approach fits your team profile and scenario? If you're on the pro-code path, which options at each layer fit your team's existing skills and your agent's requirements?