What Is a Tool Registry?

Quick Definition#

A tool registry is a centralized catalog that stores, manages, and serves tool definitions to AI agents at runtime. Rather than hardcoding which tools an agent can use into its source code, a tool registry acts as a dynamic service layer — agents query the registry to discover available tools, retrieve their JSON schemas, and verify their access permissions before invoking them.

Browse all AI agent terms in the AI Agent Glossary. For how agents invoke tools once discovered, see Tool Calling and MCP Server.

Why Tool Registries Matter#

In a simple agent, tools are defined inline as a list passed to the agent at instantiation:

agent = Agent(tools=[search, calculator, email_sender])

This works for prototypes. In production at scale, it breaks down:

• Multiple teams: Team A builds a web search tool; Team B needs the same tool. Without a registry, they share code or duplicate the implementation.
• Tool updates: When a database query tool changes its schema, every agent using it requires redeployment.
• Governance: Security policy requires that certain agents cannot call certain tools. With inline definitions, enforcement is inconsistent and easy to miss.
• Discovery: An orchestrator agent needs to know what specialized tools exist without having all of them pre-configured at build time.

A tool registry solves these problems by externalizing tool metadata into a managed service that agents query at runtime.

What a Tool Registry Contains#

Tool Schema#

The JSON Schema definition describing the tool's inputs and outputs — exactly what the LLM receives when deciding whether to invoke the tool.

Tool Description#

A natural language description explaining what the tool does, when to use it, and any constraints. This is injected into the LLM's context alongside the schema.

Endpoint Configuration#

The URL, authentication method, and connection details for calling the tool at runtime. Separating endpoint config from the schema means the tool's backend can change without updating agent code.

Version Information#

Tools evolve. A registry tracks versions, enabling agents to request specific versions and facilitating gradual rollouts.

Access Control#

Policies defining which agents, teams, or environments are permitted to invoke each tool. A production financial data tool might be restricted to approved agents with audit logging requirements.

Health Status#

Whether the tool is currently available, degraded, or offline — enabling agents to handle tool unavailability gracefully rather than failing unexpectedly.

Tool Registry in Practice#

Simple Python Tool Registry#

from dataclasses import dataclass, field
from typing import Callable, Dict, Any, List

@dataclass
class ToolDefinition:
    name: str
    description: str
    input_schema: Dict[str, Any]
    function: Callable
    version: str = "1.0.0"
    allowed_agents: List[str] = field(default_factory=list)  # empty = unrestricted

class ToolRegistry:
    def __init__(self):
        self._tools: Dict[str, ToolDefinition] = {}

    def register(self, tool: ToolDefinition):
        self._tools[tool.name] = tool

    def get_tool(self, name: str, agent_id: str = None) -> ToolDefinition:
        tool = self._tools.get(name)
        if not tool:
            raise ValueError(f"Tool '{name}' not found in registry")
        if tool.allowed_agents and agent_id not in tool.allowed_agents:
            raise PermissionError(f"Agent '{agent_id}' not authorized for '{name}'")
        return tool

    def list_schemas(self, agent_id: str = None) -> List[Dict]:
        """Return LLM-compatible tool schemas for authorized tools."""
        accessible = [
            t for t in self._tools.values()
            if not t.allowed_agents or agent_id in t.allowed_agents
        ]
        return [
            {"name": t.name, "description": t.description, "parameters": t.input_schema}
            for t in accessible
        ]

# Register tools once
registry = ToolRegistry()
registry.register(ToolDefinition(
    name="search_web",
    description="Search the web for current information on any topic",
    input_schema={
        "type": "object",
        "properties": {"query": {"type": "string", "description": "Search query"}},
        "required": ["query"]
    },
    function=web_search_function,
    allowed_agents=["research-agent", "orchestrator"]  # restrict access
))

# Agents load only their authorized tools at runtime
research_tools = registry.list_schemas(agent_id="research-agent")

Integration with LangChain#

LangChain's StructuredTool can wrap registry-served tools:

from langchain.tools import StructuredTool

def build_agent_tools_from_registry(registry: ToolRegistry, agent_id: str):
    """Build LangChain tool objects from the registry for a specific agent."""
    tools = []
    for tool_def in [registry.get_tool(name, agent_id)
                     for name in registry._tools
                     if not registry._tools[name].allowed_agents
                     or agent_id in registry._tools[name].allowed_agents]:
        lc_tool = StructuredTool.from_function(
            func=tool_def.function,
            name=tool_def.name,
            description=tool_def.description,
        )
        tools.append(lc_tool)
    return tools

# Different agents get different tool subsets automatically
research_tools = build_agent_tools_from_registry(registry, "research-agent")
finance_tools = build_agent_tools_from_registry(registry, "finance-agent")

Tool Registry vs Direct Tool Definition#

Common Misconceptions#

Misconception: Tool registries are only needed for large systems Any time multiple agents share tools, a registry adds value. Even a small team with three agents sharing common tools benefits from a central source of truth for schemas and access policies.

Misconception: MCP makes tool registries obsolete MCP standardizes how agents communicate with tools. A tool registry manages the catalog and governance of those tools. They solve different problems: MCP is a transport protocol, a registry is a metadata and policy service. Production systems often use both.

Misconception: Tool registries add unnecessary complexity For single-agent prototypes, inline tool definitions are appropriate. For production systems with governance, versioning, and multi-team access requirements, a registry reduces complexity by centralizing what would otherwise be scattered, hard-to-maintain configuration.

Related Terms#

• Tool Calling — How agents invoke the tools stored in a registry
• MCP Server — A protocol standard for exposing tools that a registry might serve
• Agent SDK — Frameworks that include implicit tool registries
• Model Context Protocol (MCP) — The interoperability standard for tool exposure
• AI Agents — The consumers of tools served by a registry
• Build Your First AI Agent — Tutorial covering tool definition and registration patterns
• CrewAI vs LangChain — How different frameworks approach tool registration and management

Frequently Asked Questions#

What is a tool registry in AI agents?#

A tool registry is a centralized service that stores tool definitions — including JSON schemas, descriptions, endpoint configurations, and access controls — and serves them to AI agents at runtime. Rather than hardcoding tool configurations into each agent, the registry acts as a single source of truth for tool discovery and governance.

How does a tool registry differ from MCP?#

MCP standardizes how agents communicate with tools at the protocol level. A tool registry manages the metadata catalog of available tools — their schemas, permissions, versions, and health status. They complement each other: an MCP server exposes tools using a standardized protocol, while a tool registry provides the backing catalog and governance layer.

Do all AI agent frameworks use a tool registry?#

All frameworks include implicit registries — in LangChain, it is the tools list; in OpenAI Agents SDK, it is the Agent object's tools parameter. Explicit, externalized registries are an advanced pattern for production systems requiring shared governance and dynamic tool management without redeployment.

What metadata does a tool registry store?#

A complete tool registry stores: tool name and description (for LLM injection), input/output JSON schemas, endpoint configuration and authentication, version information, access control policies, usage limits and quotas, and health status indicators for each tool.