Microsoft’s agent framework is designed to extend your organization’s capacity beyond human-only speed and scale without simply adding more headcount. The best starting point is an existing workflow where people currently:

• Interpret complex or unstructured inputs (emails, documents, chats)
• Apply judgment or policy context to make decisions
• Produce outputs such as summaries, recommendations, or approvals

Typical goals include:

• Reducing cycle time (for example, time-to-submission or time-to-approval)
• Improving consistency of responses against policy or standards
• Lowering cost-to-serve by automating repeatable steps
• Raising quality and satisfaction through faster, more accurate answers

To make this measurable, the guidance is to define up front:

• Goal: What outcome you want to improve (e.g., reduce manual touch rate on a process).
• Scope: Which tasks the agent will handle (e.g., create and manage tickets, draft responses, route work).
• Boundaries: When the agent must hand off to a human and how it is supervised.
• Success metrics: Baselines and targets for accuracy, completion rate, escalation correctness, latency, and user adoption.
• Governance and audit: Who can create or share agents, what data and tools they can access, and how misbehavior is handled (block, escalate, quarantine).
• ROI measurement: Before-and-after metrics such as cycle time, manual touch rate, cost per case, and quality or satisfaction scores.

Example: claims support
In the claims scenario described in the guide, the organization tracks:

• Time-to-submission for employees
• Cycle time from submission to decision
• Manual touch rate and auto-approval rate for low-risk claims
• Cost per claim before vs. after deployment
• Grounded accuracy, completion rate, and correct escalation

By anchoring the project in these metrics, teams can see whether agents are actually reshaping the process and delivering business outcomes, not just adding another tool.

The recommended approach is to start from the workflow, not the technology, and then introduce agents only where they add clear value.

1. Map the end-to-end process

• Identify what triggers the work (user request, event, schedule).
• List major steps from intake to completion.
• Note which systems are read from or written to.
• Capture decision points, approvals, and handoffs.
• Highlight where errors, delays, or inconsistencies occur today.

This becomes your “process spine” that everything else attaches to.

2. Separate agentic vs. deterministic steps

• Use agents where you need to interpret unstructured inputs, apply policy or judgment, or generate content (summaries, recommendations, explanations).
• Use deterministic logic for predictable, rules-based tasks such as routing, approvals with clear thresholds, static knowledge lookups, and error handling.
• Remember that agents introduce non-deterministic behavior and cost, so they should be reserved for steps that truly need reasoning.

3. Prefer modular, multi-agent designs

Instead of one “super-agent,” the guidance is to build modular, specialized agents that each own a clear part of the process. This makes the system:

• Easier to reason about and audit
• Simpler to evolve or replace in parts
• Aligned with how organizations already work (scoped roles and handoffs)

Example: claims support

• Front-door agent: A conversational entry point in Microsoft Teams or an HR portal. It answers questions, collects information, sets expectations, and routes work.
• Claims expert agent: A high-accuracy RAG agent grounded in official policy documents. It provides policy-backed answers to questions like “Is this covered?”
• Claims submission agent: An automation-focused agent that runs the end-to-end submission and decision workflow, including validation, fraud/risk checks, and guardrails. It auto-approves low-risk claims and routes others to human reviewers with structured summaries and recommendations.

Together, these agents deliver a repeatable, auditable workflow with the right mix of automation and human oversight, while keeping each agent’s role narrow and manageable.

The framework is designed so that different roles in your organization can participate in building agents, all on a common architecture and governance model.

1. Choosing the right builder tools

• Information workers
  Use Microsoft 365 Copilot Agent Builder and Workflows (Frontier) for personal productivity and quick wins. These are ideal for individual or small-team automation inside Microsoft 365.
• Power users / business teams
  Use Microsoft Copilot Studio (including agent starters like Employee Self-Service) for departmental or shared processes, especially in HR, IT, and workplace scenarios. This suits teams that are comfortable with a hosted environment and don’t need deep control over networking or custom runtimes.
• Developers
  Use Microsoft Foundry and pro-code SDKs such as the Microsoft Agent Framework and Agents Toolkit (VS Code) when you need:
• Isolated networks and deep API/data integration
• Full DevOps practices and observability
• Fine-grained control over scaling and runtime behavior

Most organizations will combine these: personal agents for bottom-up momentum, Copilot Studio for departmental scale, and Foundry for enterprise-grade services.

2. Data and tool options

The guide emphasizes that data quality directly shapes agent quality. Key options include:

• Copilot connectors & Power Platform connectors: Governed access to Microsoft 365 and hundreds of SaaS/enterprise systems.
• Web data: Internet or scoped website search where appropriate.
• Vector stores (e.g., Azure AI Search): Retrieval indexes for unstructured content (documents, webpages) used for grounding and RAG.
• Model Context Protocol (MCP) servers: Model- and vendor-agnostic access to tools and data across MCP-compatible agents.
• Computer-use agent (CUA): UI-level interaction (clicking, typing, navigating) when systems lack APIs or connectors.
• Specialized intelligence layers:
• Microsoft Work IQ for Microsoft 365 collaboration patterns and org models.
• Microsoft Fabric IQ for a single semantic model across OneLake, Power BI, and operational systems.
• Microsoft Foundry IQ for reusable knowledge bases across internal and public sources via MCP.

In the claims example, policy documents are indexed in a retrieval store, while HR, claims, and fraud systems are accessed via governed APIs—replacing manual “search and copy/paste” with consistent, auditable access.

3. Identity, security, and governance

Every agent gets an Agent ID in a shared directory for registration, discovery, and governance. At runtime, you choose a user identity model:

• On-behalf-of (OBO): The agent inherits the user’s permissions. Use this for personal assistants that read email, access files, or act on a user’s behalf.
• Dedicated agent account: The agent has its own alias, email, files, and permissions. Use this for shared processes or when you need more restricted, stable access than a typical user.

Example: claims support

• The front-door, claims expert, and claims submission agents run OBO the employee to retrieve context and draft claims using the same permissions as the employee.
• The auto-approver uses a dedicated Agent User ID so approvals come from a stable, auditable service identity with tightly scoped permissions.

Across all of this, Microsoft Agent 365 provides central identity and governance, with controls for data protection, auditability, risk governance, and operational resilience. Observability is supported through Microsoft Entra Agent ID, with security and compliance reinforced by Microsoft Defender and Microsoft Purview.