Your REST API, ready for every AI agent.
Connector Foundry converts the API you already have into a tested, reliable agent connector. Bring an OpenAPI 3.x or Swagger 2.0 spec — or a Postman collection. We propose the tools, prove them in a sandbox eval, and ship only what you approve.
DEMO WALKTHROUGH — GITHUB REST API
612 operations ingested · 8 tools proposed · 12-scenario eval harness · signed v3 release candidate
From your REST API to a signed agent connector, in seven gates.
Every stage is a checkpoint, not a black box. The service proposes — you review and approve. Nothing reaches an agent without your sign-off.
Import
OpenAPI 3.x is preferred; Swagger 2.0 is fully supported. Postman Collection v2.1 imports natively too. Docs-URL probing (we draft the spec from your live API) lands in v2. Import findings surface immediately: recursive schemas, undocumented error codes, scope gaps.
Normalize
Everything compiles into a platform-neutral tool model — effects (read / write / destructive), idempotency, auth schemes, error mappings. Your connector is designed once, against no single platform's quirks.
Propose
The tool compiler drafts agent-ready tools with plain-language intents, input schemas, parameter bindings, retry policies, and recovery mappings. Destructive operations are flagged for your decision — never smuggled into the connector.
get_repository · create_issue · merge_pull_request
destructive ops require ALWAYS-confirm
Review
Ambiguities land in a decision queue with evidence, impact, and a recommendation — not a config file. Should merging a PR require confirmation? What does "merge it" mean with no PR number? You decide; the connector records it.
Evaluate
An automated harness runs your connector against a frozen sandbox: tool selection, argument handling, safety gates, execution, and recovery. Failures become review questions with traces — never silent auto-patches.
Publish
The release manager freezes a versioned, signed bundle — an MCP server bundle for Claude and OpenAI function-calling / GPT Actions artifacts — ready to submit everywhere. The Meta Muse connector adapter follows in v2. A release checklist gates every publish: blockers resolved, eval green, approvals complete.
Operate
Data-plane telemetry keeps watch after launch: traffic, errors, latency, prompt→tool attribution, and drift alerts when your API changes. Suggested fixes route straight back into curation — the connector improves instead of rotting.
See it running on a real API.
These are actual snapshots of the customer console, running on mocked data from the GitHub REST API walkthrough — 612 operations in, a signed v3 connector candidate out. Click through the seven screens.
Command center
One screen answers "can we ship?" — pipeline KPIs, the next blocking step, and every open blocker with its owner.
- 5 of 8 tools approved, 3 awaiting your review — the pipeline never moves without you.
- 75% eval pass rate (9 of 12 scenarios) — every failure links to its trace and fix.
- 10 open blockers enumerated: 2 findings, 5 questions, 3 tools — "nothing ships without sign-off."
Bring what you have
Submit an OpenAPI 3.x spec, Swagger 2.0, or a Postman collection. The importer inventories every operation and flags what needs your attention before a single tool is drafted.
- GitHub REST API: OpenAPI 3.1.0, 612 operations, 428 schemas, host verified.
- Blockers caught early: 4 recursive schemas over the depth limit, an undocumented 409 on merge.
- Warnings with teeth: 9 POSTs lack idempotency docs, 2 ops need scopes beyond the OAuth grant.
Curate the toolset
Every proposed tool shows its intent, effect, confirmation policy, and error recovery. You include, edit, or exclude — destructive operations are fenced, never hidden.
merge_pull_requestis tagged DESTRUCTIVE with ALWAYS-confirm — v3 made it stricter than v2.DELETE /repos/{owner}/{repo}is excluded outright: "irreversible admin action — outside agent scope."- Each tool carries retry policy + error mappings: 409 → don't retry, check mergeable state, escalate.
Decide with evidence
Where the spec is ambiguous or the eval found a gap, you get a question — with evidence, impact, and a recommendation. Pick an option; the connector records your decision.
- "What does 'merge it' mean with no PR number?" — the eval caught the agent guessing PR #482.
- "How should the agent handle a 409 on merge?" — live probing confirmed the undocumented response.
- Auth and scope decisions too: grant actions:write, or keep release tooling scoped down?
Proof, not promises
The harness runs your connector against a frozen sandbox and scores five dimensions. Failures ship with millisecond traces and a proposed fix — routed to your review queue, never auto-applied.
- Run eval-2026-09-27-01: 9/12 pass — selection 2/3, arguments 2/2, safety 1/2, execution 2/3, recovery 2/2.
- "Close without confirmation": the agent skipped the WRITES gate — fix keys confirmation to effect, not vibes.
- "Retry storm on 500": 4 retries, duplicate drafts — fix consults the dedupe cache before every retry.
Ship with a signature
A release checklist gates every publish — blockers resolved, eval green, review queue empty, approvals complete, adapter contract verified. Then the bundle is frozen and signed.
- Release v3 candidate: 8 tools, 1 breaking change, sha256 digest — immutable once signed.
- Two targets from one review: MCP server bundle (Claude), OpenAI function-calling / GPT Actions — Muse adapter in v2.
- The checklist is honest: 5/8 approvals, eval at 75% — this candidate is blocked, and it says so.
Watch it behave
After launch, the data plane reports what agents actually do with your API — which prompts become which calls, where they fail, and what your API changes break.
- 57,028 calls in 14 days, 1.91% errors, 456ms p95 — with prompt→tool attribution per call.
- Unmapped prompts are gap candidates: "merge the release branch into main" ×23 → propose a new tool.
- Drift alerts: 4 new endpoints in the 2026-10-01 draft, a deprecated preview header — re-import before v4.
Snapshots are illustrative, from a GitHub REST API walkthrough. In the console you start by importing your own API.
Conversion is commoditized. Trust isn't.
Turning an OpenAPI spec into an MCP server is a solved problem — open-source CLIs do it, and platforms are absorbing it. We don't compete on conversion. We compete on the trust infrastructure around it: proof it works, auth your security team will sign, telemetry that watches it after launch, and an approval trail that survives procurement.
Eval harness, not a playground
No competitor offers an automated reliability certification for API owners: sandboxed scenarios across selection, arguments, safety, execution, and recovery — with traces, gates, and version-gated releases. Manual playgrounds don't count.
Spec inference from a docs URL
Every vendor we surveyed requires a clean spec upload. Point us at your docs or sandbox and we probe and infer the spec — then show you exactly what we found before anything is generated.
Live telemetry & drift detection
After launch, every call reports back: traffic, errors, latency, prompt→tool attribution — redacted before logging. When your API changes, drift alerts fire with one-click re-import and re-eval. Nobody else watches your connector after it ships; we never stop.
Propose → review → approve → publish
No formal human-approval pipeline exists anywhere else in this market. The service proposes; you dispose. Every tool, error mapping, and confirmation policy waits for explicit sign-off — nothing ships silently.
| Capability | Connector Foundry | Spec→MCP generators Gram · Scalar · Zuplo · OSS CLIs |
Integration platforms Composio · Arcade · Nango |
Platform-native intake Meta · Anthropic · AWS |
|---|---|---|---|---|
| Spec inference from docs URL / sandbox probe | ✓ Yes — probe & infer, then show our work | ✗ Clean spec upload required | ✗ Prebuilt integrations only | ✗ "Raw API + optional OpenAPI," you do the work |
| Automated reliability eval & certification | ✓ Yes — sandboxed harness, 5 dimensions, gates | ~ Manual playgrounds, no harness | ✗ Evals serve agent builders, not API owners | ~ Opaque gatekept testing on submission |
| Post-launch telemetry, prompt attribution & drift alerts | ✓ Yes — every call observed, redacted; drift → re-import & re-eval | ✗ Ship and forget | ~ Basic usage dashboards, no drift story | ✗ Their analytics, not yours |
| Propose → review → approve → publish | ✓ Yes — formal approval pipeline, auditable | ~ Partial — PR previews, no approval gate | ✗ Scoped access controls only | ✗ Their review, not yours |
| Platform-neutral canonical core | ✓ Yes — design once, adapters per platform | ✗ Single artifact, usually MCP | ✗ MCP-focused tool calling | ✗ Their platform only |
| Credential vaulting for upstream API keys | ✓ Yes — KMS-envelope broker; keys injected at call time, never in artifacts | ~ Bundled in their hosted runtime | ✓ Yes — but built for agent builders | ~ Their platform's auth plumbing |
| Built for API owners without AI teams | ✓ Yes — managed, trust-first service | ~ Self-serve dashboards | ✗ Agent-builder customer | ~ Self-serve intake forms |
The underserved middle.
Mid-market SaaS, this is your lane.
You want to be agent-ready — your customers are asking for it — but you don't have an AI team to build and babysit connectors.
Enterprise has gateways and six-figure platform deals. The low end has free tiers racing to zero. Nobody serves the middle with a managed, trust-first service priced below enterprise deals. That's us.
- You own a REST API with real customers.CRM, billing, devtools, support, logistics — if agents should act on it, we make it safe.
- Your security team has opinions.Vaulted API keys, redacted telemetry, auditable approvals — built for their checklist.
- Not for you if…you're an agent builder shopping for 1,500 prebuilt integrations — that's Composio/Arcade territory, and they're good at it.
Simple tiers, buyer-friendly metering.
Priced on telemetry lookback and project count — not per tool call. Early-access pricing is set at onboarding; these are the packaging levers.
Starter
Your first connector, end to end.
- 5 API projects
- 3-month telemetry lookback
- Full pipeline: import → eval → publish → operate
- 3 team seats included
- Eval harness & approval workflow included
- MCP server (Claude, Meta Muse) + OpenAI artifacts
Growth
A portfolio of agent-ready APIs.
- 25 API projects
- 6-month telemetry lookback
- Everything in Starter
- Telemetry & error monitoring across all projects
- 10 team seats included
Scale
Agent-ready as a platform strategy.
- Unlimited API projects
- 12-month telemetry lookback
- Everything in Growth
- 25 team seats included
- Multi-platform adapters as they ship
- Dedicated support & onboarding
Seats, support tier, and eval depth are set at onboarding · Lookback windows beyond your plan show as locked with the required tier named
Straight answers.
Be agent-ready before your customers ask twice.
Join the early-access list. We'll walk your API through the full pipeline — import to signed release — in a trial workspace first, so you see the workflow before you commit.
- Free guided walkthrough of your API (docs URL is enough)
- Eval report on your connector candidate — keep it either way
- Locked early-access pricing when we launch tiers