support@Free-Braindumps.com
Register Login
Cisco
CompTIA
ISC
EC-Council
EXIN
Fortinet
ITIL
Juniper
Microsoft
VMware
Avaya
SAP
Google
NVIDIA
Salesforce
Amazon
Palo Alto Networks
ISC2
CrowdStrike
Anthropic
All Vendors
  1. Home
  2. Exams
  3. Microsoft
  4. AI-500

Free AI-500 Exam Braindumps
Designing and Implementing Multi-Agent AI Solutions Questions 41–45 (page: 10)

Updated On: 2-Oct-2026
Page 10 of 23
PDF with 107 Questions
View Related Case Study

You have a Microsoft Agent Framework workflow. The workflow includes three specialized agents that wrap custom Hugging Face Transformers pipelines for Personally Identifiable Information (PII) detection, sentiment classification, and summarization.
Each ticket must be processed by the PII detection agent first. The sentiment classification agent must receive the redacted ticket text. The summarization agent must receive both the redacted text and the sentiment result.
You need to coordinate the agents to meet the dependencies.
Which orchestration pattern should you use?

  1. group chat
  2. sequential
  3. handoff
  4. concurrent

Answer(s): B

Explanation:

The best orchestration pattern for this workflow is the Sequential (or Chain-of-Agents) pattern, typically implemented in the Microsoft AutoGen / Agent Framework using a Linear Graph or Sequential Chat.
The use case has strict, multi-step data and control dependencies:
PII Agent must run first to redact the text.
Sentiment Agent depends directly on the output of the PII Agent (the redacted text).Summarization Agent depends on the outputs of both previous agents (redacted text + sentiment result).
A sequential pipeline ensures that the output context of each agent is passed down the chain in the exact order required, preventing data leaks (by ensuring PII is stripped before any other agent sees the text) and satisfying the data prerequisites for the summarization step.


Reference:

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



View Related Case Study

You need to implement a monitoring solution to help identify the reasons for the silent failures.
What should you do?

  1. Implement a red team evaluation that uses the Code Vulnerability risk category.
  2. Aggregate all raw text outputs into a single Azure Storage account blob.
  3. Implement tracing in Foundry by passing unique thread IDs across all agent executions.
  4. Implement continuous evaluation by using the Code-Vulnerability-Evaluator for the Lead Orchestrator agent.

Answer(s): C

Explanation:

Scenario: Patients report that during the intake process, the session frequently times out silently without indicating why. The issue occurs during workflow execution.
The most helpful action is to implement tracing in Foundry by passing unique thread IDs across all agent executions.
A silent timeout during a multi-agent workflow means the process is getting stuck or dropping a request somewhere along the chain. By passing a unique thread ID (also known as a correlation ID or trace ID) across all agents, you can stitch together the exact path a patient's session took.
When a timeout occurs, you can search for that specific thread ID in your logs to see exactly which agent received the request last, where it stalled, or which dependency failed to respond.
Incorrect:
[Not D]
The Code-Vulnerability-Evaluator is a security and compliance tool used to scan code for security flaws, bugs,
or vulnerabilities. It does not monitor active runtime environments, track live session states, or provide visibility into asynchronous workflow bottlenecks.


Reference:

https://medium.com/@eginamalaj/orchestrating-healthcare-agents-with-the-microsoft-agent-framework-25b354
8a9c40



View Related Case Study

You need to resolve the high latency issue for the Patient Intake agent. The solution must preserve a compacted version of critical triage details.

  1. Store each conversation turn as a separate document in an Azure Cosmos DB database. Configure the database's full-text search index to automatically summarize the context before model inference.
  2. Use standard HTTP requests. Configure a manual sliding window that truncates the oldest 50 percent of the text after every 10 conversation turns.
  3. Set store=false on the Responses API. Configure the Lead Orchestrator agent to inject a full summary at the start of every turn.
  4. Implement the Responses API in WebSocket mode to send incremental inputs by using previous_response_id. Periodically call the standalone /responses/compact endpoint.

Answer(s): B

Explanation:

Scenario: When the Patient Intake agent engages in long, multi-turn conversations with patients, the accumulating conversation history causes high latency due to massive prompt sizes and risks that exceed the model's context window.
To address the high latency and context window overflow while preserving critical medical triage details, you should implement a Conversation Summary Buffer Memory pattern (or Message Summarization/Compaction strategy).
In an Azure AI / Microsoft Agent Framework ecosystem, the best approach is to decouple the full, raw conversation history from the active context window. This can be executed through the following architectural action:
Implement a Context Summarization / Compaction Node
Instead of continuously appending raw text to the agent’s active message array, apply a sliding window truncation strategy combined with structured summarization:
Keep the most recent N turns of the conversation entirely raw to preserve immediate context, tone, and the flow of the active conversation.
For older turns, route the messages through a secondary, lightweight summarization mechanism (such as a background worker or a specialized summarization utility). This process compresses the past conversation into a dense, structured, and clinically grounded summary (e.g., in JSON or Markdown format).


Reference:

https://developers.openai.com/cookbook/examples/agents_sdk/session_memory



View Related Case Study

You need to tag logged operations. The solution must meet the telemetry requirements.
What should you use?

  1. attributes
  2. traces
  3. semantic conventions
  4. spans

Answer(s): A

Explanation:

Scenario: Litware support engineers want each operation to use two tags named Claim ID and Refund Amount,
so they can easily filter the telemetry by using the tags.
To tag logged operations with specific key-value pairs like Claim ID and Refund Amount, you should use attributes.
In OpenTelemetry and Azure Monitor, attributes are the standard key-value pairs applied directly to spans or logs to provide extra context. Adding custom attributes allows you to filter, group, and analyze your multi-agent telemetry based on those specific business metrics.


Reference:

https://learn.microsoft.com/en-us/azure/azure-resource-manager/management/tag-resources



View Related Case Study

DRAG DROP (Drag and Drop is not supported)
You need to implement a logging solution for Claim Approval.
What should you use for each process? To answer, drag the appropriate resources to the correct processes.
Each resource 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: Agent run middleware
To log the start and completion of each specialist agent's run and inspect its final output within your refactored workflow, you should use Agent Middleware, specifically configured at the agent layer, in combination with the
AgentContext.
The Interceptor Pattern: Agent middleware acts as an execution pipeline interceptor.
When a sequential workflow invokes a specialist agent, the agent-level middleware captures the context before the agent processes the input, executes the agent via a delegate callback, and then captures the context immediately after completion.
Capturing Execution Lifecycle (AgentContext / AgentRunContext):Start Event: Read the agent's identifier metadata using context.agent.name before invoking the next execution layer.
The Execution Pass-through: Await the framework's next delegate function (e.g., await call_next() or await next(context)) to allow the specialist agent to run.
Completion & Final Output Inspection: Once the execution delegate returns, the final output and tool generation states are populated inside context.result. You can log or audit this property directly from the middleware layer before the sequential pipeline transitions to the next specialist agent.
Box 2: Function calling middleware
You should use the function calling middleware.
In the Microsoft Agent Framework, function calling middleware is specifically designed to intercept tool and function executions.
While Agent Run middleware intercepts the top-level execution of the agent itself, Function calling middleware operates at a narrower, more granular scope—making it the ideal choice for cross-cutting tool concerns like audit logging and argument validation.
Access to Metadata: It passes a FunctionInvocationContext to your middleware code. This context explicitly contains the function name (context.Function.Name) and the arguments being passed by the LLM
(context.Arguments).
Centralization: Instead of writing logging code inside the customer-refund-tool or within every individual specialist agent, you register this middleware once at the framework or builder level. It automatically wraps the target tool executions.
Non-Invasive Execution: Using the pipeline's delegation pattern (await next(context)), you can record the exact incoming intent seamlessly before allowing the actual refund tool logic to run.
Scenario:
There is a multi-agent workflow named Claim Approval that runs specialist agents sequentially and uses the model-deployment model.
Planned changes: The company plans to refactor Claim Approval so that shared capabilities of audit logging and exception handling are implemented once as reusable middleware in Microsoft Agent Framework, instead of being coded into each specialist agent and tool.


Reference:

https://learn.microsoft.com/en-us/agent-framework/concepts/agents/middleware



  PDF
Viewing page 10 of 23
Viewing questions 46 - 50 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!