Ruby UTCP

Ruby UTCP is the Ruby implementation of UTCP 1.1, the Universal Tool Calling Protocol. It gives Ruby applications and AI agents a standard way to discover and call tools over native protocols, so a single library can connect to whatever interface a tool already exposes. Developers describe the tools they want in a simple JSON manifest and call those native APIs directly instead of standing up an intermediary wrapper server. The project is open source and MIT licensed, and it is built specifically for the Ruby ecosystem, which makes it relevant to Ruby developers who are creating AI agents and tool-powered applications and who want one consistent, standard approach to tool calling rather than a new integration pattern for every service. UTCP positions itself as a lightweight alternative to MCP, the protocol many teams reach for by default when connecting language models to external tools. The stated problem with the MCP route is its reliance on a heavy client and server architecture: for Ruby developers it usually means running a separate server process before anything can be called. UTCP describes this overhead as a "wrapper tax", an extra layer that adds latency and integration work on top of the tool itself. Ruby UTCP removes that layer by using a simple JSON manifest to connect to native APIs, so the call travels to the transport the tool already speaks rather than through an added wrapper. The project's broader pitch is that tool calling should be direct, scalable and secure from the start, rather than something that requires extra infrastructure to be stood up first. The most visible capability of Ruby UTCP is its transport coverage: it supports 12 native transports in a single open-source library, including HTTP, CLI, WebSocket, gRPC, GraphQL, MCP and WebRTC. That breadth matters because tool calling in practice is rarely uniform; one tool may be a REST endpoint, another a command-line program, another a GraphQL service, and another an existing MCP server. Supporting them all inside one Ruby library means teams do not have to write separate glue code for each protocol they want to reach. Keeping twelve transports consistent in one library is a large surface area, and community feedback notes that the documentation covers each transport well individually. Alongside transports, Ruby UTCP covers the mechanics that tool calling requires in production. It provides tool discovery so applications and agents can find out what tools are available and how to call them. It supports authentication, so protected tools can be called with credentials in place. It supports OpenAPI discovery, which lets tools described by OpenAPI specifications be discovered for use. Streaming is supported as well, so the library is not limited to simple request-and-response patterns on transports that stream. Together these capabilities mean the library handles discovery, access and data delivery rather than leaving each of them to be rebuilt for every integration a team wants to add. CodeMode is the piece of Ruby UTCP aimed at orchestration: it enables programmable multi-tool workflows written as compact Ruby code rather than long chains of individual calls. Instead of wiring tools together through repeated manual steps, developers can express a workflow in Ruby and have the tools invoked as part of it. The maker of Ruby UTCP specifically asked the community for feedback on the API and on CodeMode, which suggests these are the areas where the project is actively looking to learn from real usage. An earlier UTCP launch, Code Mode, framed the same idea around reducing token usage, with the stated goal of slashing MCP token usage by 68%. CodeMode in Ruby UTCP is therefore presented as the way to move from single tool calls to coordinated, multi-tool behaviour. How Ruby UTCP works overall is defined by the manifest-first approach that UTCP introduced. Rather than deploying a wrapper server that translates a protocol into an API, the developer describes tools in a single JSON manifest and the library calls the native protocols directly. The protocol itself has been through iterations: UTCP 1.0.0 brought a lean core, protocol plugins and a cleaner configuration so teams could scale tool usage without wrestling with glue code, and Ruby UTCP brings the newer UTCP 1.1 to Ruby with those ideas carried forward. In the 1.0.0 framing, the protocol itself is a plug-in protocol that lets apps call tools the same way whether they are HTTP APIs, CLIs or other transports. Ruby UTCP follows that model, keeping the standard consistent while individual transports are connected through the implementation. The benefits that follow from this approach are the ones the project itself emphasises. Removing the wrapper server means lower latency, because calls are not routed through an additional translating layer. It also means less infrastructure to run: a reviewer comparing the two approaches noted that in Ruby, MCP usually means running a separate server process, while UTCP's manifest-based approach skips that layer and calls the native transport directly, which felt lighter for a simple integration. A single library that spans twelve transports reduces the glue code a team has to maintain and keeps tool usage consistent across different kinds of services, so teams can scale how their apps and agents use tools rather than rebuilding the same plumbing repeatedly. Concrete scenarios follow from those capabilities. A Ruby developer building an AI agent can give it a manifest of tools and let it discover and call them, whether those tools are HTTP APIs, CLIs, WebSocket services or others among the twelve supported transports. A team that wants a simple integration without standing up a wrapper server can use one JSON manifest and call the native API directly. Developers orchestrating several tools in sequence can use CodeMode to express that workflow in compact Ruby code. Teams evaluating tool-calling options for Ruby can compare Ruby UTCP with the MCP approach and pick the one that avoids running a separate server process for simple integrations. The wider UTCP ecosystem also shows the pattern in practice: a project called Hexis announced that it uses UTCP behind the scenes for tool calling, providing Git-backed AI skills, tools and knowledge that any agent can use. Ruby UTCP is aimed at Ruby developers creating AI agents and tool-powered applications, and at teams deciding between UTCP and MCP for their tool-calling layer. It is open source under the MIT licence and is listed as free, with the code on GitHub and documentation on the project site. The transports it supports are the integration surface: HTTP, CLI, WebSocket, gRPC, GraphQL, MCP and WebRTC among the twelve, plus OpenAPI discovery for tools described by OpenAPI specifications. Ruby UTCP is the fourth launch from UTCP, following the original UTCP protocol, UTCP Agent for building tool-calling agents in four lines of code, and Code Mode. Community feedback asks for a single decision guide to help newcomers pick the right transport for their use case when evaluating UTCP against MCP. Summary: Ruby UTCP brings the UTCP 1.1 standard to Ruby as an open-source, MIT-licensed library that lets apps and AI agents discover and call tools directly over twelve native transports. By replacing wrapper servers with a JSON manifest, it removes the wrapper tax, lowers latency and reduces glue code, while streaming, authentication, OpenAPI discovery and CodeMode cover the rest of the tool-calling workflow. For Ruby teams building agents and tool-powered applications, it offers a lighter, standard-based route to tool calling.