Can AI Agents Learn to Use New Tools Over Time

Adding New Tools Is Instant

When you add a new tool definition to an agent's tool set, the model can use it immediately on the next API call. There is no training period, no warmup, and no need to update the model. The model reads the tool name, description, and parameter schema, reasons about when and how to use it, and generates calls that match the schema. This is one of the most powerful properties of function calling: the model's tool capabilities are defined at deployment time, not training time.

The quality of tool use for a brand-new tool depends entirely on the quality of the schema. A well-described tool with clear parameters gets used correctly from the first interaction. A vague schema requires iterations as the developer observes how the model interprets it and refines the description and parameters. But this iteration is in the schema, not in the model. The model itself does not change.

Memory-Based Tool Learning

Where agents do exhibit genuine learning is through persistent memory of tool outcomes. After using a tool many times, the agent accumulates experience about what works and what does not, just as a human worker learns the nuances of their tools through practice. The agent does not modify the tool schema or update its weights. Instead, it stores observations about outcomes and retrieves them when similar situations arise.

Over hundreds of interactions, an agent with memory builds a knowledge base of tool usage patterns: "When searching for products, including the category filter reduces results from hundreds to under 20, which produces much better model responses." "The inventory API returns stale data on weekends because the sync job runs Monday through Friday." "This user always wants order details in a table format, so use the detailed_order tool instead of the summary_order tool." These observations accumulate into functional expertise that improves tool use quality without any change to the underlying model or tool definitions.

Schema Evolution: Tools That Get Better Over Time

While the model itself does not change, tool schemas can evolve based on observed usage patterns. This is a developer-driven form of learning where the human reviews how the model uses tools and refines the schemas to improve accuracy. If logs show that users frequently ask questions that require a date range filter but the tool only accepts exact dates, the developer adds a date range parameter. If the model frequently confuses two similar tools, the developer sharpens the descriptions to disambiguate them more clearly.

This schema evolution cycle creates a form of institutional learning that accumulates over time. The tool set for a production agent in its twelfth month of operation is substantially better than the tool set it launched with because months of real-world usage revealed edge cases, ambiguities, and missing capabilities that the developer addressed through schema refinements. The model did not learn these improvements, but the system did, and the user experience improves just the same.

MCP servers enable a particularly smooth form of tool evolution because the server can update tool schemas without any changes to the client application. When Adaptive Recall adds a new parameter to its recall tool or refines the description of its store tool, every MCP-connected application sees the updated schema automatically on the next connection. The model adapts to the updated schema immediately because it reads tool definitions at runtime, not at training time.

The Limits of Tool Learning

Agents cannot discover tools that have not been defined. Unlike a human who can experiment with an unfamiliar system and figure out its capabilities, an agent can only use tools that are explicitly described in its tool set. If a capability is not represented as a tool, the agent cannot learn to use it regardless of how much experience it accumulates.

Agents also cannot generalize tool skills across fundamentally different domains the way humans can. A human who learns to use one database query tool can transfer that knowledge to a different database. An agent's "knowledge" about one tool does not automatically transfer to a new tool with a different schema, even if the underlying functionality is similar. Each tool is evaluated independently based on its schema and the agent's accumulated memories about that specific tool.

There is a partial exception to this generalization limit. When two tools share a similar structure (both accept a "query" parameter and return search results), the model's general understanding of the pattern does transfer. It knows how search tools work in general and can apply that understanding to a new search tool it has never seen. But this is the model's pre-trained knowledge about common tool patterns, not something it learned through use. Truly novel tool interfaces that do not match any common pattern require clear descriptions and examples to use effectively.

Memory-based learning requires a memory system that supports tool outcome storage and retrieval. Without persistent memory, the agent resets between sessions and cannot build on past experience. Adaptive Recall provides this capability through its standard tool interface, with cognitive scoring that prioritizes recent, frequently accessed, and well-corroborated tool memories for retrieval. The combination of instant schema comprehension (the model reads new tool definitions and uses them immediately) and accumulated outcome memory (the system remembers what worked and what failed) creates an agent that adapts to new tools quickly and uses existing tools with increasing expertise.