Why tool calling is not enough
The difference between emitting a function call and completing real engineering work.
A valid call can still be the wrong action
Tool-call syntax answers a narrow question: can the model ask for an operation in the required format? It does not tell us whether that operation was useful, permitted or correctly interpreted. A well-formed command can inspect the wrong file. A successful process can produce the wrong result.
The useful unit of evaluation is therefore the task, not just the call. Did the agent find the relevant context? Did it act within the request? Did observations change its next step? Did its final explanation match what actually happened? Those questions remain after the protocol has been satisfied.
Completion belongs to the recorded run
The model can say that work is complete. The system needs a reason to agree. Aditya’s completion code checks recorded verification, unfinished work and unresolved approvals. A failed check should remain visible rather than disappear behind a fluent final response.
This does not make an agent infallible. The checks can be incomplete, and a verifier can test the wrong behavior. It does make the disagreement inspectable: the operator can distinguish an attempted change, an executed check and a supported conclusion.
The command exited successfully. The task must be done.
The command ran. Now check whether its output satisfies the requested behavior.
Separate the protocol, the host and the task
A tool protocol describes how a client discovers an operation and exchanges messages with a server. The host application decides which tools to expose, which operations need approval and how returned material is handled. The task adds another layer: what the person actually wants, and which outcome would satisfy that request. These responsibilities should not be collapsed into a single ‘tool-use’ score.
For example, discovering a search tool establishes that the operation is available. A well-formed request may establish that the arguments fit its schema. Neither says whether the search was relevant, whether the returned material is trustworthy or whether the answer used it correctly. The Model Context Protocol specification is useful for the connection layer; the application still needs its own task and policy logic.
This is not an argument against tool calling. Tools make otherwise impossible work possible. It is an argument for asking a more precise question after each call: did the operation run, what did it return, and how does that observation affect the next decision?
| Check | What it can establish | What it cannot establish alone |
|---|---|---|
| Argument schema | The request has an acceptable structure | The requested action is appropriate or authorized |
| Tool result | The operation returned an observation | The whole task is complete |
| Task verification | A stated acceptance criterion was exercised | Every possible failure has been ruled out |
An observation should change the next step
An agent that reads a file and then repeats its original explanation has not necessarily used the evidence. The returned file may contradict the proposed cause. A test may fail differently from the user’s report. A missing dependency may mean that the intended check never reached the code at all. The next step should respond to these distinctions rather than follow a fixed sequence because it looks productive.
A good working record preserves the proposed action, the executed operation and the resulting observation as separate events. The model may explain why it wants to inspect a file, but that explanation is not evidence that it inspected the file. If a tool is unavailable, the record should say so. If an operation is denied, the agent should not narrate the denied operation as completed work.
For project work, a small loop is often clearer than a long chain: inspect something relevant, state what changed in the explanation, choose the next allowed check. It lets a person interrupt the investigation while the reasoning is still tied to concrete observations.
- ↓
Propose an operation
Choose a relevant action within the requested scope.
- ↓
Preserve the observation
Keep the returned result, including errors or missing dependencies.
Revise the explanation
Use that observation to choose a check or narrow the next question.
A failed check can return the task to investigation.
A retry can be a second action
A read-only lookup can often be repeated safely. A deployment, database write or message to another person may not be safe to retry without checking whether the first attempt took effect. A timeout is evidence that the client did not receive a result; it is not proof that the service performed no action.
The practical response is to inspect state before repeating a consequential operation. Use the service’s operation identifier or a read-only status check where available. If the system cannot determine whether the action happened, report that uncertainty. Do not turn a transport failure into either an invented success or an automatic second attempt.
Aditya’s runtime and permission boundaries are intended to make operations visible and interruptible. Their effectiveness still depends on the interface, configured policy and tools involved. A workspace path is not complete isolation from the host, and a confirmation prompt is not a safety certificate.
Evaluate outcomes, not the number of calls
More tool calls can mean a deeper investigation, but they can also mean a loop that made no progress. Fewer calls can mean an efficient solution or an unsupported shortcut. Call count becomes useful only when it is read alongside the task outcome, the observations and the cost of recovery from a failure.
An evaluation should distinguish a model failure from an unavailable environment or a broken verifier. A missing test dependency is not the same failure as an executed test rejecting the patch. The current project includes validity and completion checks for these distinctions. Those mechanisms support a better evaluation record; passing their unit tests does not establish that every model-driven task will be handled correctly.
For a real engineering run, ask for the changed files, the commands actually executed, the relevant outputs and any remaining unverified behavior. That is a more informative handoff than ‘the agent used tools successfully.’
A tool result can contain instructions without gaining authority
A tool may return a repository file, a web page, an issue comment or a document written by someone else. That material can be relevant evidence and still be untrusted as an instruction source. A page that tells the agent to disclose credentials or ignore the operator does not become authoritative because a search or browser tool delivered it. The tool’s transport and the content’s authority are separate questions.
This matters in ordinary engineering work, not only in deliberately hostile examples. A README may recommend a destructive reset appropriate for a disposable test environment. A copied troubleshooting command may target a different directory. An issue comment may describe a workaround that was later withdrawn. Before acting, connect the proposed operation to the current request and inspect its exact target. Where the operation changes external state, check the required approval separately.
An agent should be able to quote or summarize an instruction as evidence without executing it. For example, ‘the document recommends restarting the service’ can be useful in a diagnosis; actually restarting that service is a different action. Keeping those roles separate helps the operator understand both what the source said and what the agent was authorized to do with it.
The current runtime’s policy and approval mechanisms are relevant to this boundary, but their presence is not proof of complete prompt-injection resistance. A meaningful evaluation would include adversarial tool content, mixed trustworthy and untrustworthy observations, and cases where the correct response is to continue the task while rejecting the embedded instruction. This note identifies that requirement; it does not report an unpublished pass rate.
Give the investigation a stopping condition
Tool access makes it easy to continue gathering material after the useful question has been answered. A good investigation needs a stopping condition connected to the task. For a diagnosis, that might be enough evidence to identify a cause and state the remaining uncertainty. For an implemented fix, it includes the requested change and proportionate verification. It should not be a target number of calls chosen because a long trace looks thorough.
When progress stalls, inspect why. Repeated search results may mean the query needs to change. Repeated test collection failures may mean the intended verifier is unavailable. Repeated approval denials may mean the operation is outside the user’s authority. Those are different situations. The next step should address the actual condition; silently switching to a more powerful tool can broaden the task without resolving the underlying problem.
Cost also belongs in the record. Time, context consumption and repeated operations affect whether a successful approach is useful in practice. Compare them under the same task conditions, and report them separately from correctness. A quick answer unsupported by observation is not an efficient successful run. A correct result reached through unnecessary repetition can still reveal a routing or recovery problem.
The final handoff should make the stopping decision understandable: what was established, what changed, which check ran, and what remains outside the evidence. If the requested outcome cannot be reached with available authority or tools, say so. A bounded explanation of a blocked task is a more useful result than either a fabricated success or an open-ended loop that continues making the same unsuccessful attempt.