Development of Tool-Using Language Models and Agents
Tool use developed because fluent language models still failed at tasks that ordinary software handles cleanly: arithmetic, search, database lookup, code execution, and transactions. The historical move was from asking a model to answer directly toward wrapping it in tool schemas, execution policies, and agent loops.
Verified chronology
| Year | Milestone | Why it followed |
|---|---|---|
| 2022 | Karpas and coauthors described MRKL systems: modular language-model systems connected to external knowledge and reasoning modules. | The paper framed tool use as a systems architecture problem, not a single-model capability. |
| 2022 | Yao and coauthors introduced ReAct, prompting language models to interleave reasoning traces with actions. | Chain-of-thought helped planning, but actions let the model inspect environments or retrieve facts before continuing. |
| 2023 | Schick and coauthors introduced Toolformer, training a model to decide which API calls to insert and how to use results. | Tool calls moved from hand-written demonstrations toward self-supervised data creation for API use. |
| 2020s | Application stacks standardized structured calls, permission checks, retrieval tools, code tools, and stopping rules. | The hard part became tool routing: selecting the right action, validating arguments, and deciding when the task is done. |
Historical mechanism
The early pattern was “model as assistant”: prompt in, text out. Tool use changed the contract to “model as controller inside a bounded system.” A model may propose an API call, but software owns schema validation, credentials, rate limits, retries, logging, and side-effect control. This is why tool-use and function-calling pages are systems pages as much as modeling pages.
Agents added temporal structure. A typical loop observes the state, reasons or plans, selects a tool, executes it, reads the result, and either revises the plan or stops. That made planning and agent evaluation central: a tool-using model can fail by calling the wrong tool, calling the right tool with unsafe arguments, ignoring the observation, or continuing after the correct answer is already available.
The historical lesson is that tool use increased capability by narrowing trust. The model became more useful when it was no longer expected to internalize every capability. The surrounding system had to become stricter.
References
- Karpas et al., 2022, MRKL Systems
- Yao et al., 2022, ReAct: Synergizing Reasoning and Acting in Language Models
- Schick et al., 2023, Toolformer: Language Models Can Teach Themselves to Use Tools
Nav