Explainers · updated July 2026
What is tool use in an LLM? How a model stops talking and starts doing.
Tool use (also called function calling) is the mechanism that lets a language model reach outside its own text. You hand the model a short menu of tools it is allowed to use, each described in plain terms. Instead of answering from memory, the model can reply with a structured request to run one. You execute it, hand back the result, and the model keeps going, repeating until the job is done. That loop is the whole idea behind agents like Claude Code and GitHub Copilot.
The loop, drawn
One menu, four moves, and a loop that closes it.
Read it as a cycle, clockwise from the model. Step 0 hands the model its menu of tools. Then it decides, emits a call, the tool runs, the result comes back. And the blue arrow is the part that matters: the model reads the result and goes around again. That single return edge is what separates an agent from a chatbot.
A chatbot would stop after one reply. An agent lives on the blue arrow: it keeps calling tools and reading results until the goal is met, then exits with a plain-text answer. Everything a coding agent does on your machine is some number of trips around this loop.
Schema → call → result
A tool is just a description the model can read.
“Function calling” sounds like the model runs code. It does not. The model never sees your filesystem and never executes anything: it only reads tool descriptions and writes tool calls. Here is the whole exchange for one search, top to bottom. This is exactly how Claude Code exposes its file tools and how GitHub Copilot exposes its own: same three parts.
What the model is handed
No code: just a name, a plain-English description, and the shape of the arguments. That description is the “schema.” It is the entire contract the model works from.
The model's call
Not prose: a structured request the harness can run verbatim. The model chose the tool and filled in the arguments.
The result (a tool_result)
Fed back into the conversation as text the model reads on its next turn, where it decides whether it has enough to answer, or needs to call again.
The tool name here is illustrative. The point is the shape: a schema the model reads, a structured call it writes, a result that returns as text. Where those tools come from (how an agent is handed a menu it did not ship with) is the job of an MCP server.
Why it matters
A chatbot answers once. An agent acts until it's done.
Without tools, a language model is sealed in a box. It predicts text from what it was trained on, and stops. No eyes on your files, no hands on your machine, no way to check anything that happened after its training cutoff. Brilliant, and inert.
The loop gives it senses and hands. Reading a tool_result is perception; emitting a call is action. Claude Code and GitHub Copilot are, mechanically, an LLM wired to a set of tools and spun in this cycle: plan, call, observe, repeat. The model's raw intelligence is only half the story; the other half is which tools it has, and how good each one is.
That second half sets a hard ceiling. And the tool a coding agent reaches for most is the humble one: finding files and searching their contents. In one measured Claude Code session, the agent made 71 tool calls just to locate a single file: seventy-one full trips around the loop before it could even start the real work.
The bottleneck
The loop is only as fast as the tool inside it.
Deciding to call a tool takes the model one turn. Running the tool is where the wait lives. And the tool an agent runs most, file and content search, is the slow one. The tools an agent shells out to were built to walk the disk, not to skip it. On a real 4.47-million-file machine, the same lookup the loop needs over and over becomes the slowest thing in it:
None of this is the tools' fault. ripgrep and grep are excellent at reading the filesystem quickly. They just have to read all of it, on every call, because nothing warmer exists machine-wide. Multiply one slow call by the dozens a task needs, and the loop spends its life waiting on the disk.
Methodology: Ryzen 9 9950X3D · 64 GB DDR5 · NVMe · Windows 11 · 4,470,000 files. Interlinked ran the same tasks: 85 μs to find a file by name (139 μs median of 20 queries), and 16 ms on the content query ripgrep took 93.8 s to answer. Full method in the ripgrep comparison and the 412,000× VS Code write-up.
Make the most-called tool free
One fast tool changes the whole loop.
You cannot make the model call fewer tools, but you can make the tool it calls most answer at memory speed. Interlinked keeps a live, always-warm index of every file on the machine, names and contents. The search tool stops walking the disk and answers from memory. Every trip around the loop gets cheaper in both currencies at once: the wait you feel, and the result the model must re-read on every later turn shrinks to the handful of files that actually matched.
The result can carry more than paths, too. On a fresh machine the index seeded 26,958 relationships from 8,455 git events across all 12 repos in 1.7 seconds, so a single call can come back already knowing which files change together and what a past agent noted about them. That is future trips around the loop the agent never has to make. Content queries land in the 7 to 9 ms range typically; a save is searchable in about a millisecond, so the tool is never stale.
NO MODEL IN THE LOOP: THE ENGINE IS AN INDEX AND A HASHMAP · EVERY ANSWER STAYS ON YOUR MACHINE.
Do this today
Give your agent a faster tool.
Install once. One signed installer auto-configures 19 AI clients: Claude Code, Cursor, Copilot, Codex, Windsurf, Zed, Cline and the rest. No JSON editing, no keys.
Let it index. Filename search works immediately; content search fills in behind it. At rest the whole engine sits around 44 MB, and the index on disk stays under 1% of the drive.
Stay fresh for free. Save a file and it is searchable in about a millisecond (under 30 ms worst case), so the tool the loop calls most is never out of date.
Scope when you can. Whole-machine when you do not know where something lives; scoped to a folder when you do: scoped queries return in the microsecond range.
Everything local is free forever, on all your devices, no card. Hosting starts at $5.99/mo. Download for Windows.