Free AI-500 Exam Braindumps
Designing and Implementing Multi-Agent AI Solutions Questions 21–25 (page: 6)

Updated On: 2-Oct-2026
View Related Case Study

You are designing a Microsoft Foundry multi-agent solution for claims processing. The design includes multiple specialized agents.
You need to specify the agent personas, scopes, boundaries, and autonomy levels. The solution must meet the following requirements:
● Provide a clear owner for conflicts between specialist agents.
● Validate agent outputs before downstream agents consume the outputs.
● Prevent specialist agents from invoking tools outside the assigned domain.
● Isolate each business domain so that adding a specialist agent affects only that domain.
What should you do?

  1. Define a claims hub that has direct specialist delegation, gate the final settlement output against a checklist,
    and route conflicts through the hub.
  2. Define connected agents grouped by domain under a main agent use natural-language delegation, and accept narrative summaries from the specialist agents.
  3. Define domain-scoped workflows that have local quality gates, publish the accepted results to a shared case state, and let the consuming domains resolve conflicts.
  4. Define domain-scoped sub-orchestrators under a claims supervisor, gate each output against a structured contract, and route conflicts through the supervisor.

Answer(s): D

Explanation:

The "Define domain-scoped sub-orchestrators under a claims orchestrator..." approach fits the solution best.
Here is how a hierarchical architecture using domain-scoped sub-orchestrators perfectly meets all four of the architectural requirements:
Clear Owner for Conflicts
The hierarchical supervisor (the domain sub-orchestrator) acts as the immediate escalation point and referee for its specialized agents.
Validate Agent Outputs
The sub-orchestrator serves as a gatekeeper, validating data and formats before passing them up to the main orchestrator or down to other domains.
Prevent Tool Misuse
Tools are registered and exposed only to the sub-orchestrator's scope, establishing strict security boundaries.
Isolate Business Domains
The architecture is highly modular. Adding, removing, or changing a specialist agent only requires updating its local sub-orchestrator.


Reference:

https://devblogs.microsoft.com/foundry/introducing-multi-agent-workflows-in-foundry-agent-service/



View Related Case Study

HOTSPOT (Drag and Drop is not supported)
You have a Microsoft Foundry multi-agent solution that runs as three stateless worker instances behind a load balancer. Each workflow can span five days and is identified by using two application-defined values named userId and workflowType.
During execution, each workflow has a Foundry Agent Service thread. Regulatory policy requires a seven-year queryable audit record of all agent messages.
You are evaluating the following state design for the solution:
● For the active session container, use a Foundry Agent Service thread. The threadId value will be kept in worker memory during execution.
● For the shared team state, use Azure Managed Red is keyed by workflowId with a two-hour sliding expiration. Missing Redis entries will be rebuilt from Azure Cosmos DB.
● For the durable store, use Azure Cosmos DB for NoSQL A container named SessionMetadata will be partitioned by userId and will store workflowType, status, threadId, and expiresAt. A container named
Messages will be partitioned by threadId, will store serialized messages, and will have TTL disabled.
For each of the following statements, select Yes if the statement is true. Otherwise, select No.
Note: Each correct selection is worth one point.
Hot Area:

  1. See Explanation section for answer.

Answer(s): A

Explanation:



Box 1: No
No, the proposed state design does not fully satisfy both constraints.
While it successfully satisfies the seven-year audit requirement, it fails to guarantee the five-day recovery constraint due to critical architectural flaws in how session state is managed across stateless workers.
Box 2: No
No, the proposed design does not fully support resuming a workflow by userId and workflowType after a worker restart.
While the Azure Cosmos DB schema allows you to look up the metadata, the design fails because it relies on volatile in-memory storage for critical session identifiers and uses an unstable identifier (threadId) for the durable message store.
Box 3: Yes
Yes, the proposed design can successfully hold the active shared team state without serving as the audit record store.By utilizing Azure Managed Redis keyed by workflowId with a two-hour sliding expiration (rebuilt from Azure Cosmos DB if missing), the active shared team state is maintained in a fast, in-memory caching tier dedicated to execution. Meanwhile, the long-term, regulatory seven-year audit trail is completely offloaded to the Azure Cosmos DB Messages container, which is partitioned by threadId and has Time-to-Live (TTL)
disabled to prevent data loss.


Reference:

https://devblogs.microsoft.com/foundry/introducing-multi-agent-workflows-in-foundry-agent-service/



View Related Case Study

DRAG DROP (Drag and Drop is not supported)
You have a code modernization solution that uses Microsoft Agent Framework. The solution uses specialized agents for equivalence validation and migration-note generation. Source and target database metadata are available through separate tools, and neither lookup depends on the other.
You need to define the orchestration pattern for each stage to meet the following requirements:
● Ensure that source and target metadata retrieval finishes as quickly as possible.
● Involve multiple specialized participants only for exceptions the equivalence validation agent cannot resolve automatically.
Which patterns should you use? To answer, drag the appropriate patterns to the correct stages. Each pattern may be used once, more than once, or not at all. You may need to drag the split bar between panes or scroll to view content.
Note: Each correct selection is worth one point.
Select and Place:

  1. See Explanation section for answer.

Answer(s): A

Explanation:





Box 1: Concurrent pattern
To ensure that the source and target metadata retrieval tools execute simultaneously and finish as quickly as possible, you should use the concurrent orchestration pattern.
Parallel Execution: In the Microsoft Agent Framework, the Concurrent pattern functions as a classic "fan-out /
fan-in" model. Since the two metadata lookup tools have no dependencies on each other, this pattern will broadcast and run both independent tasks in parallel.
Minimized Latency: Running them concurrently ensures the total stage duration is limited only by the slowest single lookup, rather than the sum of both lookups (as would happen in a Sequential pattern).
Once both independent agents finish retrieving their respective metadata, the framework will aggregate the outputs so the subsequent specialized agents can proceed with equivalence validation and migration-note generation
Box 2: Group chat pattern
For the unresolved equivalence exception review stage, you should use the Group Chat orchestration pattern.
The Group Chat pattern natively models a collaborative conversation among multiple specialized agents (and optionally a human reviewer).
Selective Escalation: The initial stage can run via a low-overhead pattern like Sequential or Handoff (where the equivalence validation agent operates solo). Only when an exception is triggered does the system hand off the context to a Group Chat Manager.
Multi-Agent Collaboration: Once inside the group chat, multiple specialized participants (such as database specialists, schema experts, or language-specific migration agents) can look at the same synchronized conversation history to debate, refine, and resolve complex boundary cases collectively.


Reference:

https://learn.microsoft.com/en-us/agent-framework/workflows/orchestrations



View Related Case Study

HOTSPOT (Drag and Drop is not supported)
You have a multi-agent customer support workflow in Azure Logic Apps Standard that includes the following loops:
● A customer service agent loop that delegates to specialist agents
● A refund specialist agent loop that processes refunds and resolves billing issues
You need to complete the system prompt examples. The solution must meet the following requirements:
● Route refund, return, exchange, and billing requests to the refund specialist.
● If a specialist agent gets an unrelated request, return control to the customer service agent.
● Ensure that the agents use only their own tools.
How should you complete the prompt examples? To answer, select the appropriate options in the answer area.
Note: Each correct selection is worth one point.
Hot Area:

  1. See Explanation section for answer.

Answer(s): A

Explanation:



Box 1: infer intent, and then hand off to one specialist agent
The "infer intent, and then hand off to one specialist agent" completes the system prompt example for the refund specialist agent and fulfills all three core routing and tool-usage requirements.
Routing Scope: Restricts tasks explicitly to refund, return, exchange, and billing requests.
Control Hand-off: Mandates returning to the customer service agent for unrelated topics.
Tool Isolation: Confines the agent to its own designated tools.
Box 2: Hand back non-refund requests without using tools.
The Refund Specialist is explicitly ordered to hand back non-refund/billing requests instantly without consuming tool tokens.


Reference:

https://github.com/MicrosoftDocs/azure-docs/blob/main/articles/logic-apps/set-up-handoff-agent-workflow.md



View Related Case Study

HOTSPOT (Drag and Drop is not supported)
You have a Microsoft Foundry multi-agent solution that includes a planning agent and an execution agent.
You are designing a fixed order process where executions can run for several hours and can be interrupted by worker restarts.
You need to implement orchestration for the process. The solution must meet the following requirements:
● Pause at predefined points.
● Resume from the last saved state after an interruption.
Which mechanisms should you use? To answer, select the appropriate options in the answer area.
Note: Each correct selection is worth one point.
Hot Area:

  1. See Explanation section for answer.

Answer(s): A

Explanation:



Box 1: A workflow with agent executors
The best choice for this architecture is a workflow with agent executors (such as Azure Data Factory,
Temporal, Durable Functions, or Azure Logic Apps orchestrating your Microsoft Foundry agents).
Here is why a workflow-driven structure is superior to an Agent-as-tools pattern for the specific requirements:
Long-Running Executions
Excellent. Built to handle tasks lasting hours or days without timing out.
Interruption Resilience
Excellent. Naturally checkpoints state to storage to survive worker restarts.
Fixed Order Process
Guaranteed. Deterministic paths are hardcoded or explicitly defined.
Predefined Pauses
Native. Built-in support for hooks, approval gates, or wait states.
Box 2: A human-in-the-loop (HTIL) gate
To set up approval and operator override pauses in this Microsoft Foundry multi-agent system, a human-in-the-loop (HITL) gate is the best choice.
Human-in-the-Loop (HITL) Gate is explicitly designed for process orchestration where an agent must halt execution at a predefined checkpoint and wait for external human intervention (approval, denial, or data override) before moving to the next stage of the fixed order process. Because your execution can run for hours and needs to survive restarts, HITL gates integrate naturally with stateful orchestration frameworks (like
Durable Functions or state stores) to persist the state while waiting.
Box 3: Checkpoints
To set up interruption recovery for this long-running, multi-agent process, you should use Checkpoints.
In the Microsoft Agent Framework (the orchestrating layer integrated within Microsoft Foundry), Checkpoints are a first-class feature designed specifically to manage state persistence for functional and graph-based workflows. They address your exact requirements in the following ways:
Pause at predefined points: The workflow engine automatically saves the process state at deterministic boundaries or explicit gates (such as human-in-the-loop validation steps).
Resume after interruption: If a worker restarts or a crash occurs mid-execution during a multi-hour process, the system can reload the execution graph using a saved checkpoint ID and safely resume from the last saved state rather than starting over from scratch.


Reference:

https://techcommunity.microsoft.com/blog/azure-ai-foundry-blog/building-a-digital-workforce-with-multi-agents-i n-azure-ai-foundry-agent-service/4414671
https://github.com/MicrosoftDocs/semantic-kernel-docs/blob/main/agent-framework/journey/workflows.md



Viewing page 6 of 23
Viewing questions 26 - 30 out of 107 questions


Post your Comments and Discuss Microsoft AI-500 exam prep with other Community members:

AI Tutor AI Tutor 👋 I’m here to help!