Gentoro has launched the open-source prototype of OneMCP, a knowledge-driven runtime for the Model Context Protocol (MCP) that enables AI agents to interact with backend APIs accurately, consistently, and at lower cost. By generating and reusing structured execution plans, Gentoro OneMCP helps agents call complex services with predictable behavior, giving teams a practical foundation for production-grade agentic applications.

Why AI agents need a smarter interface to backend APIs

MCP has emerged as the standard for connecting AI systems to tools, backend services, and data workflows. But as organizations add more APIs, they encounter new operational challenges: larger contexts, higher token consumption, slower responses, and agents that struggle to choose the right endpoint at the right time. Static tool definitions drift as backend systems evolve, and multi-step business workflows are difficult to encode as individual tools.

The result is brittle behavior, inconsistent API calls, and a widening gap between how systems actually work and how agents believe they work.

What Gentoro OneMCP is

Gentoro OneMCP addresses this gap by acting as a dedicated open-source MCP runtime. Instead of asking a model to re-learn your API from scratch on every call, OneMCP centralizes knowledge about your services and turns natural-language instructions into reusable execution plans.

Developers provide a “handbook” for each API, combining OpenAPI specifications, documentation, and authentication details. Gentoro OneMCP then uses that handbook to understand how the system works and how agents should interact with it in a consistent, auditable way. If MCP is the language of agent-tool interaction, OneMCP is the map that helps agents navigate complex APIs with clarity and consistency.

How Gentoro OneMCP works

At its core, Gentoro OneMCP introduces cached execution plans for MCP agents. When an agent receives a request such as “Update the credit limit for this customer,” OneMCP retrieves or generates a plan that describes which endpoints to call, how to extract and validate parameters, and how to chain calls where needed. These plans are stored and reused across similar requests, which shrinks context size, reduces token usage, and improves consistency in how APIs are used.

Because plans are grounded in the handbook, those plans can adapt as systems change. When an API or schema evolves, OneMCP detects mismatches, invalidates the outdated plans, and regenerates new ones. Plans can be moved between staging and production environments as long as the underlying API is compatible, helping teams to keep behavior aligned across environments without duplicating tool definitions.

Features of Gentoro OneMCP

Gentoro OneMCP includes several features aimed at real-world MCP deployments:

• A built-in knowledge base that indexes handbooks so the runtime can retrieve only the most relevant documentation for each request.
• A planning engine that uses this context to generate or refine execution plans.
• An execution layer that runs those plans, with optional lightweight TypeScript logic to handle response shaping or multi-step flows.
• Built-in observability using standard telemetry so teams can trace, log, and measure each plan, call, and error.

Gentoro OneMCP is model-agnostic and works with multiple LLM providers through a pluggable interface, making it straightforward to test different models while maintaining a consistent runtime. Multi-handbook support lets teams manage several APIs or tenants side by side, while a simple CLI and Docker image make it easy to run OneMCP locally or in a cluster.

Who Gentoro OneMCP is for

Gentoro OneMCP is aimed at developers, platform teams, and architects who are already using MCP or planning to adopt agentic AI. If you maintain high-value or regulated APIs and need agents to behave with the same care as an experienced engineer, an MCP runtime like OneMCP can provide the missing layer between protocol and production.

How to get involved

The Gentoro OneMCP prototype is available today at https://github.com/Gentoro-OneMCP/onemcp We welcome contributions from the MCP community, including new handbook templates, planning strategies, and integrations.

How to get started with Gentoro OneMCP

You can get started locally in a few minutes using the CLI:

# For Linux/MacOS
brew tap gentoro-onemcp/onemcp
brew install onemcp

# For Windows
scoop bucket add onemcp https://github.com/gentoro-onemcp/onemcp-scoop
scoop install onemcp

# Start chatting
onemcp chat

On first run, the CLI guides you through choosing a model provider, entering your API key, and selecting a handbook such as the built-in ACME Analytics example or your own API. It then starts the OneMCP server, TypeScript runtime, and mock API so you can immediately chat with an agent that is calling real endpoints.

For containerized and production setups, OneMCP also ships a Docker image that can run in three modes: validate a foundation, execute regression tests, or start the full MCP server.

Lower cost. Higher accuracy. More predictable behavior.

We built this because we believe the next leap in agentic AI won’t come from larger models alone, but from better interfaces between reasoning systems and the real-world software they operate. 

With Gentoro OneMCP, we’re taking a big step toward a shared runtime layer for the Model Context Protocol that helps AI agents use enterprise APIs with greater accuracy, predictability, and control.

Stay tuned! More is on the way.

‍