Agents and Tool Use: Models Are More Than Chat
Intuition: give the model a pair of “hands”
Section titled “Intuition: give the model a pair of “hands””Chat models can only talk; agents can act on the world through tools: check weather, write code, query databases, call APIs. The core idea is to combine “thinking” and “acting”: the model first reasons about what information it needs, then calls a tool to obtain it, and continues reasoning from the result.
The ReAct framework makes this loop explicit: the model outputs an alternating sequence of “thought → action → observation → thought.” This is like how humans solve problems—not by pure contemplation, but by looking things up while reasoning.
Engineering view: reliability, state, and safety
Section titled “Engineering view: reliability, state, and safety”In practice, the core challenge of agent systems is reliability:
- Tool definition: Describe tool interfaces with JSON Schema or OpenAPI so the model knows each tool’s parameters and purpose. MCP (Model Context Protocol) aims to standardize this layer.
- Call parsing: Model output is usually text; you need robust parsing to extract structured tool calls. Function-calling training lets models natively output structured calls, which is more stable than post-hoc parsing.
- Error handling: Tools can fail, time out, or return errors. Agents need to retry, fall back, or switch to alternative tools.
- State management: Multi-step tasks require maintaining conversation history, intermediate results, and plans. Reflexion and related work let agents self-reflect on failure causes and adjust strategy.
- Safety boundaries: When agents can execute code or access external systems, permission control and sandboxing are critical. Prompt injection can let attackers hijack agent behavior.
Evaluating agents is harder than evaluating pure text generation: you must measure task completion rate, step efficiency, error recovery, and cost. Benchmarks like SWE-bench measure practicality through real coding tasks.
2026: parallel multi-agent and agentic RL
Section titled “2026: parallel multi-agent and agentic RL”Two engineering trends are worth recording in 2026:
- Parallel multi-agent becomes standard in coding agents: mainstream coding agents such as Claude Code, OpenAI Codex CLI, and Devin now support running multiple agent sessions concurrently—each working in an isolated branch or sandbox, with a human (or an orchestrator agent) reviewing and merging. The engineering focus shifts from “is a single agent smart enough” to “how to decompose tasks, arbitrate conflicts, and isolate context.”
- Agentic RL trains in synthetic verifiable environments: Agent World Model ([[ref:agentworld2026]]) represents a new training paradigm—procedurally generating tool-use environments with verifiable rewards (covering MCP calls) at scale, with over a thousand environment instances running in parallel per step. Agent training moves from “expensive human-annotated trajectories” to “a nearly unlimited curriculum of environments.”
Research view: from single agents to multi-agent and autonomous systems
Section titled “Research view: from single agents to multi-agent and autonomous systems”A limitation of single agents is that one model simultaneously handles planning, execution, memory, and reflection, which is error-prone and hard to scale. Multi-agent systems assign different roles to different instances: some plan, some execute, some verify, collaborating through conversation or shared state.
A deeper question is: what are the boundaries of agent “autonomy”? When a model can decide which tools to call, which files to modify, and which data to access, how do we define and supervise its goals? This is a cross-disciplinary area spanning technology, product, and ethics.
🔬 Open Research Questions
Key questions and research directions in this area:
- How can Agent system reliability be formally verified? Are existing benchmarks (e.g., SWE-bench) sufficient?
- Can standardized tool-calling protocols like MCP truly solve cross-model/cross-tool interoperability problems?
- What are the capability boundaries between multi-Agent collaboration and single-Agent reflection (ReAct/Reflexion)?
- In parallel multi-agent systems, how should we model the relationship between task decomposition granularity and merge conflicts? What are the respective failure modes of centralized orchestration and decentralized negotiation?
References
- ReAct: Synergizing Reasoning and Acting in Language Models
ReAct interleaves reasoning and acting: LLM thinks (Thought), executes a tool call (Action), observes the result (Observation), and cycles. This is the prototype for modern AI agent frameworks, directly influencing LangChain, AutoGPT, and similar agent frameworks.
- Toolformer: Language Models Can Teach Themselves to Use Tools
Makes model generate "API-calling tokens" itself and evaluate usefulness through self-supervision. Foundational paper for function-calling/tool-use training paradigm, directly influencing GPT-4 function calling design.
- Reflexion: Language Agents with Verbal Reinforcement Learning
Makes agent do natural language "post-mortem" after failure, injecting reflection into next round's prompt. "Gradient-free self-improvement" approach widely reused in coding agents, SWE-agent.
- SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering
Proposes ACI (Agent-Computer Interface) concept, emphasizing "what tools/interface agent uses ≥ what model used". GPT-4 + good ACI improves SWE-bench 6x, establishing coding agent engineering methodology.
- Model Context Protocol (MCP)
The Model Context Protocol (MCP) is an open standard proposed by Anthropic for how LLM applications communicate standardly with external tools, data sources, and services. Through unified "resources/tools/prompts" interfaces, any MCP-compatible tool can seamlessly connect to any MCP-compatible model — aiming to be the "USB standard" for AI tool use.
- Tree of Thoughts: Deliberate Problem Solving with Large Language Models
Tree of Thoughts (ToT) models problem solving as tree search: LLMs generate multiple "thought steps" as tree nodes, score them with an evaluator, and search with BFS/DFS. On tasks requiring complex planning (e.g., Game of 24), ToT massively outperforms CoT and is a precursor to o1-style slow thinking.
- Agent World Model: Scaling Agentic RL with Synthetic Verifiable Environments
Trains tool-use agents at scale in procedurally generated, verifiable synthetic environments (covering MCP tool calls), running over a thousand environment instances in parallel per step. It sidesteps the cost, latency, and irreproducibility of real environments and is a representative 2026 work on environment synthesis for agentic RL.