Executor helps AI agents and teams connect to the tools and APIs they need. For Rhys Sullivan, founder of Executor, that meant giving agents reliable context about how to authenticate with company APIs, which APIs to use, and how to interact with them correctly.
That context now powers auth and API information discovery for more than 3,000 integrations on integrations.sh.
Rhys built integrations.sh on top of Context.dev so agents can browse publicly accessible integration specs across MCP, OpenAPI, GraphQL, and CLI formats, grouped by domain and ready for agent workflows.
Here's how Rhys put it:
"Integration was super smooth. Yahia got me set up with a demo that showed exactly how to use it and it working for my use case. I gave that to Claude who had no problem implementing it within 10 minutes."
What is Executor?
Executor is building infrastructure for agents that need to discover and use tools across a wide range of companies and APIs. Instead of asking every agent workflow to figure out authentication, endpoints, and interaction patterns from scratch, Executor gives them a clearer path to the right integration context.
The use case
Executor needed to pull in a large amount of information about company APIs. The core questions were practical:
- How does this company handle authentication?
- Which APIs should an agent use for a given task?
- What does the agent need to know before interacting with those APIs?
For a catalog with thousands of integrations, manually collecting and maintaining that context would slow the product down. Context.dev gave Executor a way to discover the relevant API and auth information programmatically.
How they found Context.dev
Rhys found Context.dev on Twitter while looking for a better way to gather API and authentication context for agents. After a demo with Yahia, the implementation path was clear enough to hand directly to Claude.
That mattered because Executor's use case was not a static one-off lookup. The product needed a repeatable way to enrich integrations with the context agents need before they can call external systems reliably.
Integration experience
The integration was fast. Rhys took the demo, gave it to Claude, and had the implementation working in about 10 minutes.
For an agent infrastructure product, that speed is part of the value. Context.dev returned the information in a shape the implementation could use, so the team did not have to spend days writing scraping logic, normalization code, or custom glue before testing the actual product flow.
Key benefits
For Executor, the win came down to a few things:
- 3,000+ integrations powered: Context.dev now supports auth and API information discovery across Executor's integration catalog.
- Fast agent implementation: Claude implemented the Context.dev flow in about 10 minutes after Rhys received the demo.
- Useful API context: Executor can discover authentication details, API options, and interaction guidance for company APIs.
- Less integration plumbing: The team can focus on the agent experience instead of maintaining a brittle research and scraping pipeline.
By using Context.dev, Executor gives agents the API context they need to connect with more tools and companies. The result is a broader integration catalog, faster implementation work, and less custom infrastructure standing between an agent and the external system it needs to use.
Building agents that need to understand company APIs, auth flows, and web context? Context.dev gives you the data layer so your team can focus on the agent experience.