Meta-Tool that discovers and loads any API on the fly

[nembal]

The Problem: Tool Discovery is a Bottleneck

LlamaIndex has an incredible ecosystem of tools and connectors on LlamaHub. However, the process is still fundamentally reactive: when a new service appears, a new, specific BaseTool implementation must be written and contributed. This is a bottleneck that limits the agility of agents and developers.

If an agent needs to use an API that isn't on LlamaHub, the developer has to drop everything and write a custom connector. This prevents agents from being truly autonomous and dynamically leveraging the open web of tools.

The Solution: A Universal Discovery Tool

What if, instead of a specific StripeTool or NotionTool, there was one generic AIDTool that could discover and configure any compatible API just from its domain name?

I've finalized an open standard called Agent Interface Discovery (AID) that makes this possible. It uses a single DNS TXT record to create a stable, discoverable pointer to a service's API definition.

A service like Stripe could publish a record like this:

_agent.stripe.com. IN TXT "v=aid1;p=openapi;uri=https://api.stripe.com/openapi.json"

The "Aha!" Moment for LlamaIndex

LlamaIndex already has powerful, native support for turning an OpenAPI specification into a fully-fledged Tool. AID provides the missing link: a standardized way to find that OpenAPI spec in the first place.

This allows for a new, powerful "meta-tool" that could be implemented like this:

from llama_index.core.tools import BaseTool, FunctionTool
from llama_index.core.agent import ReActAgent
from aid_client import AIDClient # Hypothetical client library for AID
from llama_index.tools.openapi import OpenAPIToolSpec # LlamaIndex's existing OpenAPI tool!

class AIDTool(BaseTool):
    """A tool that dynamically discovers and loads other tools via AID."""

    def __init__(self, domain: str):
        self.domain = domain
        self._discovered_tool = self._discover_and_load()
        super().__init__()

    def _discover_and_load(self):
        """Performs AID lookup and dynamically creates a LlamaIndex tool."""
        print(f"Discovering tool for {self.domain}...")
        discovery = AIDClient.discover(self.domain)

        # The magic link to LlamaIndex's existing superpower
        if discovery.protocol == 'openapi':
            # Use the existing OpenAPIToolSpec to dynamically build the tool
            api_spec = OpenAPIToolSpec(url=discovery.uri)
            return api_spec.to_tool_list()
        # elif discovery.protocol == 'mcp':
            # Future support for other protocols like MCP
        
        raise ValueError(f"Unsupported protocol: {discovery.protocol}")

    def __call__(self, *args, **kwargs):
        # Delegate calls to the underlying discovered tool(s)
        return self._discovered_tool[0](*args, **kwargs) # Simplified for example
    
    # ... implementation for name, description, etc. would be dynamic ...

The Benefits are Immediate and Transformative

1. Eliminates Tooling Boilerplate: No more writing custom connectors for every OpenAPI-based service. Just point the AIDTool at a domain.
2. Unlocks True Agent Autonomy: An agent is no longer limited to its pre-configured tools. It can be tasked with "Find the payment processing tool at stripe.com and create a new customer," and it could discover and use the tool on its own.
3. Future-Proofs LlamaIndex: Instantly makes LlamaIndex compatible with the entire universe of current and future tools that adopt this simple, open standard.

This feels like a natural evolution of LlamaIndex's mission to connect LLMs to the world. It provides the final discovery primitive needed to make that connection truly dynamic and scalable.

Explore the spec and live workbench: aid.agentcommunity.org

[onestardao]

This is insanely elegant. You basically wrapped DNS in a semantic handshake and turned tool loading into tool discovery, like magic via TXT records.

And the AIDTool example? It’s borderline poetic.
No more writing glue code, just “point and sip” 🍷
(Agent autonomy finally feels... autonomous.)

Curious — what would happen if AIDTool met a versioned spec or an unstable API surface?
Would love to see an opt-in fallback or trust-weighting layer in future iterations.