Google

One specific application of tool use for Large Language Models involves enabling them to solve tasks by calling external APIs. This approach allows an LLM to address particular sub-problems, thereby facilitating the completion of more complex objectives.

LLM Tool Use with External APIs

A primary distinction between tool use and Retrieval-Augmented Generation (RAG) lies in when external information is accessed. With tool use, external functions are invoked dynamically *during* the inference process as needed. In contrast, RAG systems retrieve relevant texts and provide them as context *before* the prediction or generation phase begins.

Comparison of Execution Timing in Tool Use and RAG

A significant challenge in implementing tool use is that standard Large Language Models are not inherently trained to generate the specific commands or markers needed to invoke external functions. This limitation necessitates further adaptation to enable them to interact with tools effectively.

Limitation of Pre-trained LLMs in Tool Use

A specific application of LLM tool use involves granting the model access to a web search tool. This capability enables the LLM to retrieve external information to answer questions that require up-to-date or specialized knowledge, such as identifying the location of the 2028 Olympics.

Using Web Search as an External Tool for LLMs

Beyond information retrieval tasks that use tools like web search, Large Language Models can also be prompted to address and solve mathematical problems, showcasing a different domain of their application.

Application of LLMs to Mathematical Problems

A development team is building a chatbot for an airline. The chatbot must be able to answer user questions like, 'What is the status of flight UA456?' and 'Are there any business class seats available on the 10 AM flight to London tomorrow?'. The airline's flight data is stored in a private, real-time database. Which of the following represents the most effective and reliable approach for the team to implement these features?

Based on the principles of how these models function, analyze the most probable reason for the assistant's inaccuracy with stock numbers and describe the specific technical approach that would resolve this issue.

Troubleshooting an LLM-Powered Sales Assistant

You are designing an internal LLM assistant for a finance operations team. A user asks: “Can I approve this vendor payment today? If not, what exactly is blocking it and what should I do next?” The correct answer depends on real-time data from two internal systems exposed via APIs: (1) an invoice/PO matching service and (2) a sanctions/AML screening service. The business requires (a) high accuracy, (b) an auditable rationale, and (c) minimal latency/cost.

Write an essay proposing a single end-to-end inference workflow that combines: (i) tool use with external APIs, (ii) a deliberate-then-generate step that surfaces likely error modes before drafting the final response, (iii) a predict-then-verify strategy that generates multiple candidate decisions/explanations, (iv) a verifier that selects or rejects candidates, and (v) a self-reflection step that decides whether to call additional tools or revise the answer.

In your proposal, be explicit about: what the model generates at each stage, when API calls happen, what the verifier checks (and what it cannot guarantee), how self-reflection changes control flow, and the key tradeoffs you are making among accuracy, auditability, and latency/cost. Assume the APIs can occasionally return incomplete data or transient errors.

Designing a Reliable LLM Workflow for Real-Time Decisions

You are reviewing a proposed architecture for an internal LLM assistant used by Finance Operations to (1) draft a vendor-payment approval note and (2) optionally trigger an external API call `create_payment(vendor_id, amount, invoice_id)` that will schedule a real payment. The team has observed two failure modes: (a) the model sometimes hallucinates invoice details when the user’s message is incomplete, and (b) when the model does call the API, it occasionally chooses the wrong invoice_id among several similar open invoices.

Write a design critique and improvement plan that integrates: (i) deliberate-then-generate prompting (the model must first surface likely error types/uncertainties before drafting the approval note), (ii) a predict-then-verify strategy that generates multiple candidate action plans (including whether to call the API at all) and selects among them, (iii) an explicit verifier component (describe what it checks and whether it is outcome-based, process-based, or both), and (iv) safe tool-use with the external API (describe gating, required arguments, and what happens when required data is missing).

In your answer, explain the tradeoffs you are making (latency, cost, and risk), and give at least two concrete examples of verifier checks that would specifically reduce the two observed failure modes without relying on the model’s pre-trained knowledge alone.

Design Review: Combining Tool Use, DTG, and Predict-then-Verify for a High-Stakes API Workflow

You lead an LLM platform team. A customer-facing assistant can call two internal APIs: (1) `get_account_balance(account_id)` and (2) `get_recent_transactions(account_id, days)`. Last week, the assistant told a customer they had “$0 available” and recommended a payment plan. An audit later showed the model (a) called the correct APIs but (b) misread a negative pending authorization as the final balance and (c) produced a confident explanation that sounded plausible. You are asked to propose a revised inference-time workflow that reduces the chance of this kind of error without adding more than ~1 second median latency.

Write an essay that (i) designs a concrete end-to-end flow combining deliberate-then-generate, self-reflection, and a predict-then-verify stage; (ii) specifies what the verifier checks and whether it should be outcome-based, process-based, or a hybrid; and (iii) explains how and when the model should use the external APIs (including what to do when API outputs are ambiguous or inconsistent). Your answer must explicitly discuss the tradeoffs among accuracy, latency, and failure modes (e.g., false rejects vs false accepts), and justify why your design would have prevented the incident described.

Post-Incident Analysis: Preventing Confidently Wrong API-Backed Answers

You are reviewing an internal pilot of an LLM-powered customer support assistant for a subscription product. The assistant can call two external APIs:

- `get_invoice(customer_id, invoice_id)` → returns line items, taxes, discounts, currency, and current payment status.
- `create_refund(invoice_id, amount, currency, reason)` → executes a refund immediately and returns a refund confirmation ID.

Incident: A customer asked, “I was double-charged on invoice INV-8841—refund the extra charge.” The assistant responded confidently: “You were charged twice; I’ve refunded $49.99,” and then called `create_refund(INV-8841, 49.99, "USD", "duplicate charge")`. Later, finance found the invoice was in EUR, the ‘double charge’ was actually an authorization + capture, and the correct action was to provide an explanation (no refund). The team wants a redesign that (1) minimizes extra model calls/latency, (2) reduces the chance of executing an incorrect refund, and (3) still uses the LLM to handle ambiguous customer language.

As the reviewer, propose a single end-to-end workflow (not a list of unrelated tips) that integrates: (a) a deliberate-then-generate step, (b) a predict-then-verify mechanism with an explicit verifier, (c) self-reflection to catch overconfident claims, and (d) safe external API tool use. Your answer must specify where in the flow the model generates candidates, what the verifier checks (outcome vs. step-level), what evidence must be pulled from `get_invoice`, and the exact gating rule that prevents `create_refund` from being called when uncertainty or mismatches (e.g., currency/status) are detected.

Case Review: Preventing Incorrect Refund Commitments in an LLM + Payments API Assistant

You are the product owner for an internal LLM assistant used by Customer Operations to answer: (1) “Where is order #12345 right now?” and (2) “Can I promise delivery by Friday?” The assistant can call two external APIs: `get_tracking(order_id)` (returns latest scan location + timestamp) and `get_inventory(sku, warehouse)` (returns available-to-promise quantity). A recent incident occurred: the assistant confidently promised Friday delivery based on a stale tracking scan and an incorrect assumption about inventory allocation rules. Leadership now requires: (a) fewer than 2 API calls per user request on average, (b) a measurable reduction in incorrect commitments, and (c) an auditable record of why the assistant made a commitment.

As the designer, propose a single end-to-end inference workflow that integrates: deliberate analysis before answering, self-reflection, predict-then-verify with a verifier, and tool use with the APIs above. Your answer must specify (i) when and why the model calls each API (or chooses not to), (ii) what the model generates as multiple “candidates” (what varies across candidates), (iii) what the verifier checks and what evidence it uses (including how it handles stale timestamps), and (iv) what the final user-facing response should contain to be auditable while minimizing overconfident promises.

Case Study: Shipping a Tool-Using LLM Assistant with Built-In Verification Under Latency Constraints

You are designing an internal LLM assistant used by procurement and security teams to draft vendor risk review summaries. The assistant can call two internal APIs during inference: (1) `get_vendor_certifications(vendor_id)` which returns a list of current certifications with expiry dates, and (2) `get_latest_security_incidents(vendor_id)` which returns incident summaries from the last 12 months. A recent near-miss occurred: the assistant confidently wrote, “Vendor X is SOC 2 Type II certified through next year and has had no security incidents,” but the certification had expired two months earlier and there was a medium-severity incident last quarter. Leadership requires a redesign that (a) reduces the chance of false claims, (b) keeps median response time under 8 seconds, and (c) produces an auditable trail showing why the final statements were made.

Propose a single end-to-end inference workflow (not training) that integrates: deliberate-then-generate self-reflection, predict-then-verify with a verifier, and tool use with the APIs above. Your answer must specify (i) when and how many candidate drafts are generated, (ii) what the verifier checks (and whether it is outcome-based, process-based, or both), (iii) how API results are used to ground or block claims, and (iv) how the workflow meets the 8-second latency constraint while still improving reliability. Be concrete about the sequence of steps and the key tradeoffs you are making.

Case Study: Preventing Hallucinated Compliance Claims in an API-Enabled LLM for Vendor Risk Reviews

You are reviewing a proposed architecture for an i...

In an LLM-based customer support assistant, the mo...

You’re designing an internal LLM assistant for a f...

You’re leading an internal rollout of an LLM assis...

A user asks a Large Language Model, 'What is the capital of Brazil and what is the current time there?'. The model has access to an external tool `get_current_time(city)`. Arrange the following steps in the logical order the model would follow to answer the user's request.

Learn Before

Related