Implement generative AI and agentic solutions

You are building a semiautonomous customer-support agent in Azure AI Foundry. The agent can call a custom function that issues refunds directly to customer payment methods. Business rules require that any refund over $500 be reviewed and explicitly approved by a human support supervisor before execution, while smaller refunds may proceed automatically. You need to implement this with the least custom orchestration code while keeping an auditable record of decisions. What should you do?

You are building a customer-support agent in Azure AI Foundry Agent Service. The agent answers product questions from an internal knowledge base, but users also ask about breaking news that affects your products (e.g., recent regulatory changes and current market prices) that changes daily and is not present in your indexed documents. You must add a capability so the agent can retrieve up-to-date public web information at query time while keeping your existing knowledge-base retrieval for internal content. Which tool should you add to the agent?

You are building an Azure AI Foundry agent for a finance team. Users upload CSV files containing quarterly sales data and ask the agent to compute custom aggregations, generate correlation statistics, and produce chart images on demand. The requested calculations vary unpredictably per user and cannot be pre-defined as fixed functions. Which built-in agent tool should you enable to satisfy these requirements?

Your team is building a generative application in Azure AI Foundry that summarizes long legal contracts. Business stakeholders require the highest possible summarization quality and are willing to accept higher per-token cost and slower response times, since summaries run as scheduled overnight batch jobs rather than interactively. You must choose a deployment approach in Foundry that best fits this workload. Which approach should you select?

You are building an Azure AI Foundry agent for a customer support scenario where conversations can span dozens of turns. Users complain that after long sessions the agent begins to lose track of earlier details, and you also notice per-request token costs climbing steeply as the thread grows. You want the agent to retain the essential context of the entire conversation while keeping the prompt token count bounded. What is the most appropriate approach?

You are building a customer support agent with the Azure AI Foundry Agent Service. Each customer has an ongoing support case that may span several separate sign-in sessions over multiple days. Within a single session, the agent must remember earlier turns, and when a customer returns days later you must resume the exact same case context without re-uploading history. You also need to inspect the individual tool calls and model steps that occurred during one specific request for debugging. Which combination of Agent Service constructs should you use to model this?

You operate a production Foundry agent that calls several external APIs through registered tools. Support reports intermittent failures where the agent returns incomplete answers. You need to diagnose which tool invocations are failing and correlate them with the specific user turns and model reasoning steps, without adding custom logging code to each tool. What should you do first?

You build a customer-support agent in Azure AI Foundry that uses the File Search tool grounded on a vector store of product manuals. Compliance requires that every answer the agent returns must display which source document and passage supported each claim, so auditors can verify the response was grounded and not fabricated. What is the most appropriate way to satisfy this requirement?

You are building an Azure AI Foundry agent that must answer employee questions using a set of 40 internal PDF policy documents that rarely change. You want the agent to retrieve relevant passages from these documents automatically during a conversation, without building and maintaining your own separate Azure AI Search index or writing custom retrieval code. Which approach should you use to give the agent access to these documents?

You are building a semiautonomous Azure AI Foundry agent for an e-commerce operations team. The agent uses a custom function tool named submit_refund that calls an internal payments API to issue customer refunds. During load testing you notice that transient network timeouts occasionally cause the agent's runtime to retry the tool call, resulting in some customers being refunded twice. You must prevent duplicate refunds without disabling automatic retries. What is the most effective approach?

You build a Foundry agent that calls a custom function tool named getShippingQuote. During a run, the external shipping API the function wraps is temporarily unavailable and the function raises an exception. Your current implementation lets the exception propagate, which terminates the entire run and returns a generic failure to the user. You want the agent to gracefully recover — informing the user and, when possible, continuing the conversation with an alternative — without crashing the run. What is the recommended way to handle this in your tool implementation?

You are building a customer-support agent in Azure AI Foundry Agent Service for an insurance company. The agent must handle policy questions but must never provide legal advice, must always escalate coverage disputes to a human, and must respond only in the customer's language. During testing, the agent occasionally offers interpretations of legal liability and answers in English regardless of the customer's language. You need to correct this behavior with the least engineering effort while keeping the guidance consistent across all conversations. What should you do?

You build a Foundry agent that generates detailed compliance summaries. Users report that longer summaries are being cut off mid-sentence, and the response metadata shows a finish_reason of 'length'. The prompt and system instructions are well within the model's context window. Which change most directly resolves the truncated output?

You are building an Azure AI Foundry agent for a call-center analytics team. Agents must accept uploaded recorded customer support calls (audio files), produce accurate transcripts, then reason over the transcript to summarize the customer's issue and detect sentiment. The team wants the least custom orchestration code and prefers using a Foundry-managed capability to handle the speech-to-text step before passing text to the LLM. Which approach should you implement?

Your team is building a customer-support agent in Azure AI Foundry that must accept photos of damaged products uploaded by customers and generate a written triage summary describing the visible defects. You need to deploy a model into your Foundry project and expose it to the agent so it can process both the image and an accompanying text description in a single request. Which approach correctly enables this capability?

You are building an Azure AI Foundry agent that must call your company's internal Orders REST API, which is protected by OAuth 2.0 client-credentials flow against Microsoft Entra ID. You register the API as an OpenAPI-specified tool for the agent. When configuring the tool, you must ensure the agent can authenticate to the API without embedding long-lived secrets in the tool definition and while respecting the API's token audience requirements. Which authentication configuration should you use for the OpenAPI tool?

You are building an Azure AI Foundry agent for a travel-booking assistant. The agent has three registered tools: get_user_preferences (reads a profile store), search_flights (queries an airline API using the retrieved preferences), and check_weather (queries a public weather API for the destination). During a single turn the agent must produce a recommendation that uses flight results filtered by user preferences, while weather information is independent. You want to minimize end-to-end latency without producing incorrect results. How should you design the tool-calling behavior for this turn?

You are building a generative application in Azure AI Foundry that must answer employee HR questions using an existing Azure AI Search index that already contains vectorized and semantically enriched HR policy documents. You want to consume the index from your Foundry-based application through a supported, managed integration rather than writing custom HTTP calls to the search service, and you want the connection to be reusable across projects in the hub. What should you do?

You are building a customer support agent in Azure AI Foundry that uses a large reasoning model. Users complain that responses feel slow because the full answer only appears after the model finishes generating, which can take several seconds for long replies. The backend already uses the Foundry Agent Service SDK. Business requirements state that perceived responsiveness must improve without changing the model or reducing answer quality. What is the most appropriate change to the way the agent consumes model output?

You are building an agent with the Azure AI Foundry Agent Service SDK. Your code creates a thread, adds a user message to it, and then wants the agent to process the conversation and produce a response. After creating the run, you notice your code immediately reads the thread messages but finds no assistant reply. What is the correct approach to reliably retrieve the agent's response?