Practice Exams:

Microsoft AI-103: Designing Useful Multi-Agent Workflows

AI & Machine Learning

Splitting an application into several AI agents can make a diagram look sophisticated without improving the result. Every handoff adds latency, cost, state management, and another opportunity for tools to act under the wrong authority. Multi-agent design makes sense when distinct responsibilities genuinely need different tools, knowledge, review rules, or execution schedules. Microsoft Foundry supports several ways to build agents and orchestrate tool use, but the engineering decision begins with the workflow itself. A reliable system should be able to explain why one agent was insufficient, what each specialist owns, and how every handoff is validated before another component takes action.

On this page
  1. Prove that one agent is not enough
  2. Use workflows when execution order matters
  3. Define handoffs as contracts, not chats
  4. Give each agent narrowly useful tools
  5. Keep shared memory deliberately limited
  6. Control fan-out, loops, and completion conditions
  7. Trace decisions across the whole workflow
  8. Choose orchestration according to the workload
  9. Evaluate whether the extra agents earned their place

Prove that one agent is not enough

Begin with the simplest working design. A single agent may retrieve documents, draft a response, and call a narrow tool through well-defined application logic. Add another agent only when a separate responsibility has measurable value: independent fact review, restricted tool authority, long-running execution, or a different knowledge base. If the new agent merely rewrites the first agent’s text, it may add cost while hiding responsibility for mistakes. Define the problem the separation solves and compare it against a simpler workflow using the same task-level evaluation set. A multi-agent Microsoft AI-103 workflow needs explicit task boundaries and a trace that shows which agent supplied each decision or tool action.

A customer onboarding process offers a reasonable example. One component verifies submitted documents, another checks account eligibility, and a final component prepares a customer-facing summary. These tasks have different evidence requirements and permissions, so boundaries can be valuable. But deterministic validation and API calls may still be better performed by ordinary application code rather than another model. Model-driven agents should handle uncertainty where their judgment is genuinely needed, while hard rules and authoritative system writes remain under explicit service control.

Use workflows when execution order matters

Many business processes have dependencies that conversation alone should not manage. A compliance review must finish before an account can be activated; a failed identity check must block downstream provisioning. Represent those dependencies as a workflow with states and allowed transitions. An agent may recommend a transition, but the agent orchestration layer should decide whether prerequisites are satisfied. This makes the process repeatable and easier to recover after a timeout or service restart. It also prevents one persuasive agent message from skipping a required verification stage.

Separate the workflow’s durable state from the model’s conversational memory. Record current step, inputs, outputs, approvals, retry count, and error status in a system designed for reliable recovery. A long-running workflow should resume from a confirmed checkpoint rather than ask the model to reconstruct all steps from prose. Include cancellation and expiration rules. If the customer withdraws a request, dependent agents should not continue performing stale actions simply because their queued instructions remain in a conversation transcript.

Define handoffs as contracts, not chats

A handoff should specify the task, permitted input, expected output schema, source references, and error modes. For a research specialist, the contract might require a list of evidence passages with document IDs and dates. For a validation specialist, it may require pass/fail decisions tied to specific rules and uncertainty flags. Avoid passing loosely structured prose that leaves the receiving agent to guess which facts were verified or which actions are authorized. Typed contracts are especially important when agents developed by different teams are combined into one system.

Include provenance and authority in each handoff. A statement like “the payment was approved” should carry a verifiable approval record, not merely an assertion generated by another model. Distinguish proposed actions from completed side effects, and preserve the original user intent where that distinction matters. Version handoff schemas, because one team’s seemingly harmless new field can change another agent’s behavior. Test backwards compatibility before deploying updated specialists independently.

Give each agent narrowly useful tools

Tool catalogs are permission surfaces, not just ways to increase capability. A document-analysis agent may need read access to one storage container, while an operations agent may need to open a ticket. Neither should inherit a broad administrative connection simply because both participate in the same workflow. Use separate identities or connection scopes where appropriate, and validate tool arguments outside the model. A request from another agent is not proof of user authorization. Apply the same access and approval checks you would require from a human-facing application.

Consider a billing workflow where one agent identifies a disputed charge and another proposes a refund. The first agent’s evidence is useful, but it should not be able to authorize a transfer through a message. The refund tool should verify amount limits, account ownership, and the authenticated approver. Log which agent proposed the action and which principal executed it. Multi-agent cooperation must not become a way to launder permissions through a specialist with greater access than the original requester.

Keep shared memory deliberately limited

Agents often need some shared context, but copying an entire conversation and every intermediate document to all participants is wasteful and can breach data boundaries. Share the minimum task state, validated facts, and source references each specialist needs. Retain long-term user preferences only with a clear purpose and retention policy. Technical traces should record where a fact came from and whether it was verified, because an unverified statement can otherwise be repeated through several agents until it appears authoritative merely from repetition.

Define memory freshness and invalidation rules. A pricing specialist’s cached quote may be acceptable for minutes, while a customer consent decision may need a short-lived transaction-bound reference. If one agent corrects a fact, other agents should not keep using an older copy without warning. Separate immutable evidence from mutable task notes and model summaries. This reduces contradictory responses and makes it possible to replay a workflow using the same trusted inputs after a failure.

Control fan-out, loops, and completion conditions

Multi-agent systems can accumulate cost through circular delegation: one specialist asks another to confirm something, which asks the first for more explanation. Put explicit limits on depth, retries, model calls, token budgets, and elapsed time. Define what constitutes completed work, a legitimate clarification request, and a terminal failure. A coordinator should not report success just because every sub-agent returned some text. It should confirm that required outputs exist and the authoritative system state reflects any requested action.

Where tasks can run in parallel, ensure they are independent. Two agents writing to the same record can create races or conflicting updates. Use concurrency control, idempotency identifiers, and deterministic merge logic for shared outputs. If human approval is required before a side effect, no amount of parallelism should bypass that gate. Test partial failure: one research agent succeeds while another times out. The coordinator must know whether to retry, continue with a qualified result, or stop for review.

Trace decisions across the whole workflow

A single final answer does not reveal which agent supplied a mistaken fact or chose the wrong tool. Use end-to-end correlation identifiers that link user request, coordinator decisions, specialist calls, retrieval results, tool attempts, and completed actions. Record agent and prompt versions at each step. This allows the engineering team to distinguish a bad handoff contract from a model error or a downstream service issue. Protect sensitive payloads in telemetry and preserve access boundaries when traces from several agents are combined.

Evaluate components independently and as a complete system. A retrieval specialist may achieve strong passage recall, but the coordinator could fail to incorporate its evidence. A tool specialist may choose correct parameters in isolation, yet receive a malformed task from upstream. Include tests for handoff fidelity, safety, state recovery, and total cost per task. A multi-agent architecture should show a measured improvement in user outcomes or controllability over the simpler design that it replaced.

Choose orchestration according to the workload

Microsoft Foundry offers managed agent runtimes and tools, while applications can also implement orchestration through their own services or workflow frameworks. Choose based on required control, operational dependencies, deployment boundaries, and supported features. Managed prompt agents can simplify common patterns; hosted or external agents can support more customized logic. But the platform cannot infer a business approval process that was never specified. The workflow still needs explicit contracts, retries, logging, and permission rules.

Avoid overcommitting to rapidly changing framework terminology in long-lived documentation. Record the exact supported APIs and versions used by the deployed implementation, and verify current service limits before adopting preview capabilities. A system that can recover state and explain its decisions is more valuable than one designed around the newest orchestration label. The solution should remain understandable to application engineers and operators who did not write the original prompt instructions.

Evaluate whether the extra agents earned their place

After a pilot, compare one-agent and multi-agent designs on the same representative tasks. Measure completion quality, authorization failures, p95 latency, resource cost, retries, and operational incidents. Look for cases where specialization genuinely improved reasoning or made permissions easier to enforce. Also identify coordination overhead and duplicated retrieval. A team should be willing to remove an agent that contributes little. Architectural simplicity is not a failure of ambition; it is often the strongest reliability and security choice.

Multi-agent systems can be useful when responsibilities are genuinely separate and controlled by explicit workflow contracts. They become fragile when handoffs are informal, shared memory is unlimited, tools are overprivileged, or success is inferred from fluent prose. Start with the business process, constrain each specialist, preserve provenance, and evaluate the whole chain. That approach turns several collaborating models into an accountable application rather than a collection of conversations that occasionally arrive at a good answer.

Continue learning

Related guides

Agent Identity in Azure AI FoundryAssign agent identities and restrict access as workloads are deployed.Managing Agent Memory on AzureSet memory retention, access, and state boundaries for agents.Event-Driven AI Workflows on AzureTrigger AI processing from events while controlling retries and ordering.Durable AI Workflows with QueuesRecover queued AI work through retries, checkpoints, and idempotent actions.

Related Posts

• AI-102 Retired: The Current AI-103 Azure AI Developer Roadmap

• Mastering AI-102: A Complete Preparation Resource

• Understanding the Core of AI-102 and the Azure AI Engineer Role

• Microsoft AI-300: Fine-Tuning Needs Versioned Data and Models

• Microsoft AB-100: AI Across Dynamics 365, Power Platform, and Foundry

• Microsoft AI-103: Evaluating Agents Beyond the Final Answer

• Microsoft AI-103: Scaling AI Apps Without Cost Surprises

• Microsoft AI-900: What Changes With AI-901

• Microsoft AI-103: Operating Azure AI Search for RAG

• Microsoft AI-103: Blue-Green Releases for Azure AI