A tool is a named function the agent can invoke at runtime: search, calculator, code-runner, database query, API call. Each tool has a schema (name, description, parameters) the LLM sees in its prompt, so it can decide when to call it and with what arguments. Tools are what let agents act on the world beyond text generation: read fresh data, change state, and execute computation.
**A tool** is a function that an LLM agent can call to do something the language model itself cannot do. Search the web, run a Python script, query a database, send an email, click a button on a screen. Each tool has a name, a short description of what it does, and a list of parameters it accepts. Together those three pieces are called the tool's schema.
The schema is what makes tools usable. When the agent runtime sends a prompt to the model, it includes the schemas for every available tool. The model reads those descriptions and decides which tool fits the current step. If it picks one, it emits a structured message that names the tool and fills in the arguments. The runtime sees that message, actually runs the function, and feeds the result back to the model on the next turn.
Tools are why agents matter. A plain LLM call can only produce text. With tools, the same model can read fresh data that did not exist at training time, change real state, and chain actions together. Search lets the model see the current web. A calculator lets it do exact arithmetic. A code runner lets it test ideas. Each tool adds a new thing the model can ask the world to do on its behalf.
**A tool** is a named function the agent can invoke at runtime. Each tool has a schema (name, description, parameters), and the LLM sees that schema in its prompt, so it can decide when to call the tool and with what arguments. Tools are what let agents act on the world beyond text generation.
The shape is consistent across providers. Anthropic, OpenAI, Google, and the broader Model Context Protocol (MCP) standard all describe a tool as a JSON-schema-shaped object: a unique name, a natural-language description explaining when to use it, and a parameter spec listing required and optional arguments with types. The model reads these as part of the system prompt and learns the available actions purely from text.
At call time, the model does not execute anything. It emits a structured tool-use block (JSON containing the tool name and arguments) instead of a final answer. The runtime parses that block, validates the arguments against the schema, runs the matching function in trusted code, captures the return value, and feeds it back as the next observation. The model then decides what to do with that observation: call another tool, refine its plan, or produce a final answer.
Typical tool categories include data access (search, RAG retrieval, database queries), computation (Python execution in a sandbox like e2b or Modal, calculators, symbolic math), state-changing actions (send email, write file, post to Slack), and meta-tools (delegate to another agent, hand off to a human). The choice of tool set is what determines what an agent can actually do.
Quick reference
TL;DR
A tool is a named function with a schema the agent can call at runtime; tools are what let the agent act on the world beyond producing text.
Picture someone solving a puzzle. They are sharp, but if all they can do is talk, they can only ever describe a solution. Now hand them a calculator, a phone, and a search bar. Suddenly they can compute, look things up, and call other people. They still do the thinking, but now the thinking turns into actions. A tool is one of those handheld helpers for an AI agent. Each tool has a label and instructions stuck on the front (the schema), so the agent knows what the tool is for and how to use it. When the agent decides it needs a particular tool, it asks for it by name, and the runtime actually picks it up and uses it. Tools are how an LLM stops being a clever talker and starts being an agent that does things.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
The task is pure language transformation like summarizing or rewriting text the user already supplied. No fresh data or external action is needed; adding tools just increases latency, cost, and failure surface.
The agent only needs read access but you give it write tools 'in case it needs them later'. Over-privileged tool registries amplify prompt-injection blast radius; expose only what the current task actually requires.
You need exact, audited determinism with no model judgment in the loop. A direct API call or hard-coded function is more predictable than letting the model decide whether and when to invoke it.
Quick scan · 2–4 min
Everything important, quickly.
5 min: define a tool as a named function with a schema, walk through how the schema reaches the model via the prompt, explain that the model emits a request and the runtime executes the call, give two or three concrete tool categories, and mention scope as a safety control.
Real-world examples
Real products, models, and research that use this idea.
1OpenAI function calling and Anthropic tool use both accept a JSON schema per tool and return structured tool_use blocks that your runtime executes.
2Anthropic's Model Context Protocol (MCP) exposes tools as discoverable server endpoints so Claude clients can plug into local file systems, databases, and APIs.
3Cursor and Cline expose tools like read_file, edit_file, run_shell_command, and grep to coding agents; the editor runtime executes them after the model emits the request.
4LangGraph and the OpenAI Agents SDK both wrap function-calling APIs with a registry plus loop that drives the call execute observe cycle in production agents.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow does the model actually pick which tool to call from a registry of twenty?
Sign in or go Pro to see the approach for this follow-up.
QWhat happens when a tool's parameter shape changes between releases?
Sign in or go Pro to see the approach for this follow-up.
QWhy are state-changing tools more dangerous than read-only ones, and how do teams mitigate that?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Thinking the LLM runs the tool itself. The model emits a structured request naming the tool and arguments; the runtime is what actually executes the function and feeds the result back.