When execution knowledge is reusable, agents can reason about less¶
November 7, 2026 · Kishore Babu Gutta
When an AI agent receives a familiar engineering task, how much of its work is truly new reasoning?
It may need to decide what should change. But if an organisation has already solved how to change it—required API calls, ordering, dependencies, admission, and verification—the agent should not have to reconstruct that procedure every time.
That is the motivation behind reusing Engineering Runtime (ENGRT) capabilities.
A related finding from Anthropic¶
Anthropic's November 2025 article Introducing advanced tool use for Claude describes programmatic tool calling: rather than sending each intermediate tool result back to the model, code can orchestrate several calls and return a smaller final result. Anthropic reported a 37% average reduction in token usage on its complex research tasks.
That is Anthropic's result for its own approach and evaluation, not a measured ENGRT result.
There is a related but distinct opportunity in engineering: if the procedure itself has already been reviewed, why make a model author the orchestration code again?
Two kinds of reasoning¶
Consider applying a standard GitHub repository configuration.
With fresh agent-generated execution, the model may need to discover provider operations, choose API or CLI syntax, arrange calls, handle dependencies, interpret results and decide how to verify success.
With a reviewed compatible capability, the model can focus on the requested outcome, target, parameters, whether the capability is suitable, and how to interpret the final evidence.
Fresh orchestration Reused execution knowledge
------------------- --------------------------
Interpret request Interpret request
Discover provider operations Discover compatible capability
Construct requests and ordering Supply declared inputs
Write handling logic Request admitted execution
Interpret intermediate results Inspect outcome and evidence
Reconstruct next time Reuse reviewed contract next time
The agent still reasons. It must select the correct capability, respect authorization, recognize mismatches and assess uncertain outcomes. The claim is narrower: a compatible capability can avoid repeated implementation and orchestration reasoning.
What ENGRT contributes¶
ENGRT capabilities represent engineering intent in a declared executable contract, with bounded inputs and step dependencies. On supported operations, execution passes through Runtime's provider resolution, authentication/context, compiled-safety and policy admission, results, and audit/evidence path.
The capability is not simply a prompt telling an agent what to do. Nor is it a promise that every supported step is idempotent: live verification and stateless reconciliation apply where operations have the necessary observe/mutate/verify semantics.
A useful distinction:
- Programmatic tool calling: the agent writes code to orchestrate tools more efficiently.
- Capability-first execution: an already-reviewed engineering procedure is reused rather than reauthored for each caller.
- Both together: an agent can use programming where new composition is needed and prefer a reviewed capability where execution knowledge is already captured.
A falsifiable efficiency hypothesis¶
We expect capability reuse to reduce repeated model turns, intermediate tool material sent to the model, and generated implementation code for familiar tasks. This is a hypothesis, not a measured ENGRT performance claim.
A fair evaluation should run the same tasks with the same model and starting context:
| Measurement | Fresh agent orchestration | Reused ENGRT capability |
|---|---|---|
| Total input/output tokens | Record | Record |
| Model inference turns | Record | Record |
| Tool calls and intermediate payload size | Record | Record |
| Time to verified outcome | Record | Record |
| Successful/partially completed/failed outcomes | Record | Record |
| Policy refusals and unintended dispatches | Record | Record |
| Repeated runs after partial completion | Record | Record |
Include capability discovery overhead, preparation costs and maintenance costs. Report the number of tasks and repeats, model/version, task difficulty, and whether the capability already existed. A capability may save substantial repeated work on a common operation and offer little advantage for a one-off task.
The same evaluation should verify correctness and governance; lower token counts alone would not demonstrate better engineering outcomes.
Keep the boundary honest¶
An agent can still generate shell or Python for local calculations. The ENGRT design direction is that consequential provider operations from that code should enter the admitted Runtime boundary. General arbitrary-script confinement and prevention of direct provider access outside ENGRT are not established by capability reuse alone. Sandboxing, network restrictions and provider least privilege may still be necessary.
The engineering question is not whether AI should stop reasoning. It is whether AI should repeatedly spend reasoning effort on execution knowledge an organisation has already made durable.
Reason about new intent. Reuse proven execution knowledge where applicable. Verify the outcome.
Further reading: Agents should reuse capabilities, not rewrite shell scripts, Capabilities are executable contracts, and Sandbox isolation and governed execution.