Improving Summary Completeness With a Reflection Pass
Short answer
A Add a reflection pass in the application code that critiques and expands the draft summary against the retrieved policy documents before returning it.
Question
You need to improve response completeness. The solution must be implemented in the logic of the application code before responses are returned.
What should you do?
Key Takeaways
The question tests choosing an application-logic pattern over model parameters; the trap is assuming a sampling parameter or streaming improves how completely documents are summarized.
To improve summary completeness in a Microsoft Foundry agent within application code, add a reflection pass that drafts, critiques, and expands the summary before returning it. The correct answer is A; streaming, presence_penalty, and max_tokens do not address completeness.
Common mistake: Option C, increasing presence_penalty, is the tempting wrong pick because it sounds like a quality tuning knob, but it is a request parameter that promotes token variety rather than fuller coverage, and it is not application code.
Expert Analysis
The constraint that decides it: "in the logic of the application code." The question asks for improved response completeness — summaries that fully cover the retrieved policy documents rather than being truncated or partial — and it explicitly requires the change to live in application logic, applied before the response is returned to the user. That single qualifier eliminates most candidates.
Why C and D fail on the constraint. presence_penalty and max_tokens are request-time inference parameters sent to the model endpoint; they are not application-logic steps, so both violate the stated implementation location. Beyond that, C works against the goal: presence_penalty pushes the model toward less-repeatable, more varied token choices, which is a diversity knob, not a completeness knob — it can even make a summary wander. D is the direct opposite of the requirement: lowering max_tokens truncates generation earlier, guaranteeing less complete summaries.
Why B fails on the goal. Response streaming only changes how tokens are delivered — incrementally rather than in one payload. It has no effect on how thoroughly the model reasons over the retrieved policy documents, so completeness is unchanged; streaming merely changes the user experience and, if anything, makes partial output visible sooner.
Why A is correct. A reflection pass is a two-stage workflow implemented in your own code: the agent produces a draft summary, then the application sends a follow-up prompt containing the retrieved documents plus the draft and asks the model to critique and expand it, returning the revised, fuller summary. That is exactly an application-logic transformation applied before responses are returned, and it is the standard pattern for improving coverage and completeness in grounded summarization.
Answer: A
Official Reference
https://learn.microsoft.com/en-us/azure/ai-foundry/foundry-agent-sdk/
This link opens the official vendor documentation in a new tab.
Exam Strategy
Read the qualifier first — "in the logic of the application code" — and immediately discard any option that is a request parameter or client behavior, since parameters are not application logic. Then map the stated goal (completeness) to the mechanism: truncation limits hurt it, delivery changes ignore it, and self-critique loops help it. On agent-quality questions, favor two-stage draft-and-revise patterns over single-call sampling tweaks.
Frequently Asked Questions
Why doesn't increasing presence_penalty improve summary completeness?
What does a reflection pass look like in agent application code?
Does response streaming affect answer quality or completeness?
Community Votes
100% of anonymous learners picked answer A. Votes are pick records left by other test-takers — they are not the verified answer.
Discussion 1 contributions
Compiled from public community threads and reader submissions, lightly edited for clarity. Handles and vote tallies are shown as recorded, and comments reflect the views of individual contributors.
From public community threads 1
-
8ac3742 👍 1 Answered AHow Reflection Pass Works in Application Code In application logic, a reflection pass is implemented as a two-stage LLM workflow: Step 1 (Generate Draft): The agent generates a summary based on the retrieved documents. Step 2 (Self-Reflect & Critique): The application sends a second prompt containing both the retrieved documents and the initial draft: "Review the summary above against the provided policy documents. Did it omit any key clauses, edge cases, exceptions, or coverage details? List missing items." Step 3 (Revision): If omissions are identified, the agent integrates them into a completed, final response before returning it.
Reader comments & corrections
No reader corrections yet — spotted an error or have a note? Share it below.
Related Analysis
Practice All AI-103 Questions
Access 88 questions with complete answers and detailed explanations.
View Full AI-103 Practice Test →