Microsoft AB-100: Designing Agentic Business Solutions
Designing an agentic business solution is different from adding chat to an application. The solution must connect a business outcome to users, data, knowledge, tools, workflow, identity, governance, evaluation, deployment, and adoption. The agent is one component in that design, not the architecture by itself.
On this page
The current Microsoft AB-100 role reflects this systems view. Microsoft expects architects to plan AI business solutions, design agentic-first architectures, orchestrate Microsoft services, integrate Copilot Studio and Foundry, secure cross-platform interactions, test behavior, and define ALM. A practical design method therefore starts with the business boundary and progressively turns it into a governed operating model. For Microsoft Business AI solutions, the boundary diagram should trace permissions from the user through the agent and connector to the system that authorizes each transaction. Consider an agent permitted to summarize a customer refund case but not to approve payment. The architecture must express that difference in tool permissions, approval workflow, and test evidence, rather than relying on a prompt alone to enforce it.
Define the business boundary first
Start with the process, user, decision, and outcome the solution owns. Identify where the work begins, where it ends, which systems are authoritative, and which decisions require human accountability. Agentic architecture becomes much clearer once that boundary is written in business language.
If the intended scope is “help with everything,” the design is not ready. A production agent needs a job, not an aspiration.
Begin with a support case in which an agent summarizes evidence, checks entitlement and proposes a remedy. Identify the case record, policy authority, permissions and approval threshold before selecting autonomous steps. The business application must verify entitlement and perform the actual write; the model should not invent an exception. Compare a straightforward deterministic workflow with multi-agent delegation on task completion, cost and rejected actions. An architecture is incomplete if its owner cannot trace or reverse a consequential decision.
Business requirements should be translated into architecture decisions explicitly. For each requirement, record whether it is satisfied by knowledge, a deterministic workflow, an agent tool, a user interface rule, or a governance policy. This prevents the agent prompt from becoming the place where every unresolved requirement is hidden.
Nonfunctional requirements belong in the first design workshop, not the last. Expected user count, response time, availability, data classification, audit needs, recovery, cost, and support hours can change the platform choice just as much as functional capability.
Keep an architecture decision record for major choices: why Copilot Studio was selected, why one tool uses delegated identity, why a workflow is asynchronous, or why an agent is split into specialists. These records make later redesign faster because teams can understand the original constraint instead of guessing from configuration.
Map users and channels
Decide who will use the solution and where they already work. Microsoft 365 Copilot, Teams, Copilot Studio channels, custom applications, or external experiences each imply different authentication, deployment, licensing, and support models. Platform choice should follow the user journey instead of forcing users into a new surface simply because the implementation team prefers it. Audience size and external exposure also affect governance depth and service expectations.
Use a decision table for ambiguous architecture choices. Compare options such as Agent Builder, Copilot Studio, Foundry, Power Automate, or ordinary application code against audience, autonomy, integration, data, compliance, latency, ALM, and support needs. A written comparison prevents architecture from being driven by whichever tool the team used most recently.
Separate knowledge from transactional data
Knowledge sources answer questions about policies, documents, procedures, and reference material. Transactional systems provide current business state such as orders, cases, inventory, or approvals. The design should distinguish what can be grounded through Microsoft 365 or other knowledge sources from what must be retrieved live through a tool.
Identity and data must stay aligned across the entire request. An agent may retrieve permitted records using delegated user access, but a broadly privileged connector must not become a shortcut around that user’s authorization. Make the target service verify the request before returning protected data or committing a write.
Design documents should also identify the authoritative source for every business-critical fact. Customer status belongs in the CRM, access rights in the identity system, policy in the governed repository, and approval state in the workflow. The agent can interpret these facts but should not become a parallel system of record through memory or generated summaries.
Data minimization is another useful design test. Ask whether the agent needs the entire document library, full CRM record, or all user history to complete the task. Smaller context and narrower permissions usually improve privacy, performance, and explainability at the same time.
Decide what the agent may choose
Generative orchestration is useful for interpreting intent and selecting among capabilities. It is weaker as the sole enforcement mechanism for required sequence, financial controls, compliance checks, or irreversible actions. Business workflows should preserve deterministic steps and approvals while the agent handles ambiguity around when the workflow is appropriate. Write down which decisions are generative, which are rules, and which require a person.
Multi-agent patterns should earn their complexity. Separate agents can be valuable when they need different data, identities, models, or responsibilities. If all agents share the same context and tools, a single well-designed agent with deterministic workflows may be easier to operate and evaluate.
Design tools as business capabilities
Expose actions such as “create service request” or “get customer balance” instead of generic database or HTTP access. Copilot actions should have narrow inputs, predictable outputs, authentication that matches the operation, and explicit failure behavior. Shared business capabilities can be reused across agents, reducing duplicated connectors and inconsistent validation.
Use a capability map to identify reusable components. Several business scenarios may need the same customer lookup, approval service, policy search, or document-generation capability. Building those once as governed tools or flows reduces duplicated integrations and makes later agents cheaper to deliver.
Design identity end to end
The user, agent, connector, flow, and downstream service may all use different identities. Map that chain for every sensitive operation. Authentication design should state where the user is delegated, where the agent acts as itself, and where a shared service credential is intentionally used. Authorization belongs in the target service and workflow as well as in the conversational front end.
Plan governance before publishing
Identify the environment, data policy, owner, audience, risk tier, publishing route, support team, and review cycle before the solution is made broadly available. Copilot adoption scales more safely when governance is part of the delivery path rather than added after hundreds of users depend on the experience. The design should also include a containment action such as blocking or disabling the agent if a significant issue appears.
Design for degraded operation. If a knowledge source is unavailable, decide whether the agent can answer from a narrower source, ask the user to wait, or refuse. If a write tool is down, do not let the model invent a successful result. Reliable architecture includes the failure state as a first-class path.
Business-process ownership should remain separate from platform ownership. A platform team can operate Copilot Studio and shared connectors, but the business owner still decides which process is correct and whether the outcome is valuable. This separation keeps technical governance from accidentally becoming process governance.
Build evaluation into the architecture
Define representative scenarios, risky edge cases, tool-use checks, and business outcome measures before final deployment. Testing should cover both conversational behavior and real process effects. An agent can produce a polished answer while calling the wrong action or using the wrong account. Agent instructions and tool definitions should move through the same evaluation cycle as other behavior-changing components.
Prototype architecture should test the riskiest dependency first. If the solution depends on delegated access to a sensitive system, complex multi-agent coordination, an unusual connector, or strict response time, validate that constraint before investing in polish. Early proof should reduce architectural uncertainty, not merely demonstrate that the model can answer a question.
Design the operating lifecycle
The solution needs ALM, monitoring, feedback, ownership, improvement, and retirement after launch. Copilot ALM defines how configuration moves across environments, while agent lifecycle defines how the business governs the deployed product.
Match human oversight to consequences
Human oversight should match business consequence. A draft email may need no approval; changing payment terms, customer status, or access rights may require a named reviewer. Place the gate where it protects the actual risk rather than applying a generic “human in the loop” slogan everywhere.
Architecture review should include the operating team. Support engineers, administrators, security, data owners, and business process owners often see dependencies that the implementation team misses. Their input improves runbooks, ownership, and failure handling before users are affected.
Design for ongoing operational support
Supportability is part of architecture. Decide where logs live, which team owns each dependency, how incidents are escalated, and how the agent can be disabled or degraded safely. A design that works only while the implementation team is watching the pilot is not production architecture.
Finally, review the architecture after real use begins. User behavior can reveal different intents, tool needs, and data gaps from those assumed during workshops. Treat production evidence as input to architecture evolution rather than as a reason to keep extending one increasingly complicated agent indefinitely.
Define an end state for each successful solution. Some agents should remain long-lived conversational products; others may reveal that most of the underlying process can become deterministic automation. Architecture should allow teams to remove unnecessary generative steps when reliable operational evidence supports a simpler design.