MCP Bridge auto-generates API tools for AI agents, tackling the hidden cost of manual schemas

The Model Context Protocol is solving one problem well — standardizing how AI agents discover and call tools — but it creates another. Every API an agent wants to talk to needs a hand-written MCP tool definition: typed schemas, auth logic, rate limiting, response parsing. For a team with 200 endpoints, that tax is steep.

Appfactor, a developer tools startup, is launching MCP Bridge today on Product Hunt. The product is an open-source Rust engine that auto-generates MCP tool definitions from any REST, GraphQL, SOAP, or gRPC API. Point it at an endpoint, and it produces typed schemas with auth, rate limiting, and response processing — all through one standard interface for LLM agents.

The core insight is straightforward. The MCP specification is gaining traction across the agent ecosystem, with tools like Claude Code, Cursor, and Kilo Code adopting it as the standard way for models to interact with external services. But the adoption bottleneck has shifted from “can my agent call an API” to “how many person-hours does it take to wire up each one.”

MCP Bridge’s auto-generation handles the easy cases well. For GraphQL, it pulls typed schemas from live server introspection. For gRPC, it uses server reflection, even synthesizing tool descriptions from message fields when proto comments are missing. SOAP endpoints are covered through WSDL parsing. The honest gap, as maker Gabriel Ciuloaica acknowledged in a Product Hunt comment, is REST — the tool still requires an OpenAPI spec and cannot yet infer schemas from sample payloads.

The harder problem is what happens when the API does not behave like Stripe. Enterprise APIs are messy: 200 status codes with error bodies, inconsistent response shapes across endpoints, multi-step auth handshakes that require a nonce signed with a private key exchanged for a session token before the real request. MCP Bridge handles these cases through what Appfactor calls the Tool Builder and a sandboxed JavaScript transform layer.

The Tool Builder imports whatever spec exists — OpenAPI, WSDL, or GraphQL schema — but generates an editable tool definition rather than a sealed wrapper. When an API returns 200 with {"error": "..."} in the body, or different error shapes per endpoint, a developer writes a small transform that maps the mess to a consistent contract. The agent sees a clean tool. The bridge does the dirty work.

Multi-step auth flows are composed into a single tool from the agent’s perspective. The LLM never reasons about flow state. Failure shaping at the adapter layer classifies inconsistent status codes into retry or no-retry decisions, so the agent does not have to figure out whether a 200 with an error body means “try again” or “give up.”

This is the part that makes MCP Bridge more than a schema generator. The product is essentially an abstraction layer that lets developers treat enterprise APIs as if they were well-behaved, even when they are not. That abstraction is valuable because the alternative — teaching every agent to handle every API’s quirks — does not scale.

The security questions are real, and Appfactor is upfront about them. Ciuloaica listed the threat categories the team takes most seriously: prompt injection through tool responses, where malicious servers return content that hijacks agent reasoning; confused deputy attacks, where agents inherit the union of all tool permissions and a harmless tool becomes dangerous next to a powerful one; credential aggregation, where MCP servers concentrate OAuth tokens and become high-value targets; DNS rebinding and host header attacks on local MCP servers; and tool description poisoning, where descriptions are weaponized to bias tool selection.

MCP Bridge leans on per-tool scoping, sandboxed execution for generated code, and full audit trails. The enterprise customers Appfactor works with treat agent runtimes the same way they treat any other privileged service.

The product arrives at a moment when the MCP ecosystem is maturing but still fragmented. Multiple vendors are shipping MCP servers and clients, but the integration layer — the part that connects agents to real enterprise data — remains bespoke. Appfactor is betting that the market will consolidate around a standard bridge rather than every team building its own.

The bet has some evidence behind it. The Product Hunt launch has attracted attention from developers who have spent cycles manually wrapping customer-side APIs with inconsistent auth patterns. One commenter, Gaurav Aroraa, noted that “auto-generating typed MCP schemas from SOAP and gRPC alongside REST is the hard part others skip.” Another, Priya Kushwaha, called building wrappers for legacy SOAP and gRPC services just to make them talk to Cursor or Claude Code “a huge pain.”

The open-source Rust engine approach matters. Rust gives the bridge performance characteristics that matter for latency-sensitive agent calls, and the open-source license lets enterprises inspect and modify the code that handles their credentials and data flows. Appfactor will likely monetize through a hosted version with additional enterprise features — audit logging, team management, compliance controls — but the core engine is free.

The open question is how the MCP ecosystem evolves. If tool definitions become standardized enough that auto-generation is trivial, the bridge layer commoditizes. If APIs continue to be as messy as they are today, MCP Bridge becomes infrastructure.

For now, the product solves a real cost. Every team building agent workflows has encountered the hand-written tool definition tax. Appfactor has built a tool that reduces that tax, and it has done so with honest engineering — acknowledging the gaps, shipping the transforms, and publishing the code. That is a solid launch.