Hook
Agentic coding is often described as a conversation.
That description misses the main event.
The work does not happen only in messages. It happens through searches, file reads, patches, shell commands, browser checks, validation runs, plan updates, git-state inspections, failed proofs, reruns, and closeouts. The chat is the visible thread. The tool calls are the medium.
The Problem
If we study agentic software work as chat, we see prompts and responses. That is useful, but incomplete. A model can sound capable in prose while never inspecting the right file. It can describe a fix without applying it. It can say tests pass without running them. It can miss dirty state, stale refs, generated artifact drift, or a failed proof.
The operational truth lives in the choreography between human message, assistant reasoning, tool call, tool result, source state, and final claim.
That means a serious account of agentic coding has to treat tool use as first class evidence.
The Idea
Tool calls are not incidental implementation details. They are the way agentic development becomes inspectable.
A file search tells us what source surface the agent tried to find. A read command tells us what it inspected. A patch tells us what it changed. A proof command tells us what bounded predicate it attempted to verify. A git status check tells us whether the closeout matched the working tree. A plan update tells us how the task state was represented.
None of those events proves success by itself. Together, they give us a medium for accountable work.
What We Saw
The source manuscript inherits the aggregate-only privacy boundary from A Longitudinal Corpus of Human-Codex Software Work. At the inspected snapshot, the local corpus contained 7,514 session files, 22,923 user messages, 79,110 assistant messages, 245,480 function calls, and 238,745 shell command calls.
The top tool families were not exotic. They were ordinary work surfaces: exec_command for shell-mediated inspection and proof, write_stdin for long-running terminal interaction, and update_plan for task-state tracking.
Those counts do not prove productivity or quality. They do prove that a chat-only story would miss a lot of the observed work.
The tool trace is where source inspection, proof, recovery, and closeout become visible.
Why It Matters
Once tool calls are treated as the medium, the design questions change.
Instead of asking only whether the model produced a good answer, we can ask:
- did it inspect the right source state?
- did it use read-only tools before mutation?
- did it run the proof that matches the claim?
- did it preserve failed or blocked states?
- did it distinguish local proof from release authority?
- did the final answer match the actual tool results?
That is a better way to evaluate agent work because it studies the whole loop, not just the polished final sentence.
It also helps with privacy. A public methods artifact can publish aggregate tool families and authority classes without exposing raw command arguments, private paths, local outputs, session identifiers, or transcript bodies. The public surface can say "this work is heavily shell-mediated" without revealing exactly which private command was run.
The right unit is not a raw transcript. It is a redacted event model:
- event kind;
- tool family;
- mutation level;
- source-state class;
- proof state;
- redaction class;
- claim ceiling.
That gives reviewers something more honest than vibes and less dangerous than raw logs.
What This Does Not Prove
This post does not claim that more tool calls mean better work. A hundred source reads can still end in a wrong claim. A proof can fail and be forgotten. A shell command can inspect the wrong directory. A plan can be tidy and still miss the user's goal.
It also does not claim that the local corpus represents all agent users or all agent products. Raw command arguments, outputs, local paths, session IDs, and transcript bodies remain withheld by default.
The claim is narrower and more useful: if tool calls are where agent work becomes inspectable, then tool-call families, proof states, and mutation levels belong in the evidence model.
Where To Go Deeper
Read the source manuscript: Tool Calls Are the Medium: Agentic Coding as Human-Agent-Tool Choreography by A.G. Mauro and C.A. Harris.
Related archive work: A Longitudinal Corpus of Human-Codex Software Work, Proof-Carrying Development, Cached Context Infrastructure, and When the Green Checkmark Lies.