Something happened this week that changed my understanding of what we’re building.
We connected Claude to our meta-tool system. Three tools: find_api, learn_api, call_api. No pre-registered operations. Just the ability to discover, learn, and execute dynamically.
I asked it to create a GitHub issue. The agent searched for relevant operations, found issues/create, requested the TypeScript interface, constructed valid arguments, and made the API call. An issue appeared in the repository.
Then I asked it to create a Stripe subscription for a test customer. Same flow: search, discover, learn, execute. A subscription was created.
Then I asked it to do both in sequence—create the issue, then create the subscription, then post a Slack message about it. Three different APIs, three different auth schemes, composed into a workflow I never explicitly defined.
It worked.
Why this matters
For nine months we’ve been building infrastructure. JSON Schema parsing, OpenAPI execution, semantic indexing, credential management. Component after component, each solving a piece of the puzzle.
There’s always a moment in a complex project where the pieces come together. Where you stop testing components in isolation and see the whole thing work. This was that moment.
The universal API bridge wasn’t a concept anymore. It was running.
What “universal” means
An agent connected to our system can use any API we’ve indexed. Not because we built integrations for each one—we haven’t. Because the meta-tools provide a uniform interface to every operation.
GitHub and Stripe use completely different authentication schemes. Different parameter patterns. Different response formats. The agent doesn’t know or care. It describes what it wants to accomplish, discovers operations that accomplish it, learns their interfaces, and executes them.
The number of APIs doesn’t matter. We have a corpus of over a hundred thousand operations from thousands of services. The agent accesses all of them through the same three tools it uses for any of them.
This is what universal means: not special-cased, not per-API, not bounded by what we’ve explicitly integrated.
The architecture that enables this
Everything we’ve built over the past months exists to support this moment:
Semantic discovery lets agents find operations by intent. When the agent wants to “create a GitHub issue,” it doesn’t need to know the operation name. It searches, and the system returns relevant operations ranked by semantic similarity.
Interface synthesis generates TypeScript types from OpenAPI specs. The agent sees clean interfaces—function signatures with documented parameters—not raw JSON Schema.
Hygienic execution translates agent arguments into valid HTTP requests. Every encoding style, every authentication scheme, every content type—handled by the execution engine, invisible to the agent.
Credential bridging applies the right credentials automatically. OAuth tokens, API keys, bearer tokens—stored encrypted, decrypted for each request, never visible in the conversation.
Each piece is necessary. None is sufficient alone. The universal bridge exists at the intersection of all of them.
The test that convinced me
After the individual API calls worked, I tried something harder. I described a complex workflow spanning multiple services, with conditional logic, error handling, data transformation between steps.
The agent figured it out. Not perfectly—there were retries, clarifications, adjustments. But it composed a multi-service workflow from natural language description, executing each step correctly.
This isn’t scripted. The workflow doesn’t exist as code anywhere. The agent constructed it dynamically from available operations.
That’s when I knew we had something real.
What comes next
The core architecture works. The hard infrastructure problems are solved—or at least solvable with the approaches we’ve developed.
Now we have a different kind of work: scaling, hardening, polishing. Making it fast enough, reliable enough, elegant enough. Building the product around the technology.
The research phase is ending. The product phase is beginning. We know what we’re building now. The question is how well we can make it accessible, usable, and rigorously secure.
A possible outcome
When we started this project, a universal AI-API bridge was aspirational. A vision of what might be possible if everything went right.
It’s not aspirational anymore. It’s running in our test environment. It works.
That doesn’t mean we’re done. That doesn’t mean it’s ready. But it means success is now one of the possible outcomes.
That’s a good week.