Ruby UTCP

Ruby UTCP is the Ruby implementation of UTCP — the Universal Tool Calling Protocol — an open standard that gives apps and AI agents a single, consistent way to discover and call tools over native protocols. It brings UTCP 1.1 to Ruby, so Ruby developers can define the tools their agents are able to use and then call them directly, whether those tools live behind HTTP APIs, command-line interfaces, WebSocket endpoints, gRPC services, GraphQL schemas or other transports. The library is open source, MIT licensed and free, and it is built specifically for the Ruby ecosystem. Its intended audience is Ruby developers creating AI agents and tool-powered applications who want a standard way to handle tool calling instead of writing a bespoke integration for every service they connect. Tool calling became a mainstream developer concern once large language models started being wired into real, day-to-day tools. MCP (Model Context Protocol) paved the way for that ease of use, but it typically relies on a heavier client/server architecture: for Ruby specifically, connecting to a tool usually means running a separate server process that sits between the model and the underlying API. UTCP was created as a lightweight alternative to that arrangement. Instead of routing every call through an intermediary, UTCP uses a simple JSON manifest to describe how a tool is reached, then connects to the native API directly. The project calls the overhead it removes the "wrapper tax", and eliminating that layer is what delivers lower latency. As the makers put it, allowing LLMs to call endpoints directly is much easier and more efficient to implement than a heavy client/server setup, and reviewers have noted that UTCP takes the idea further with better specification and security from the get-go. The most visible capability of Ruby UTCP is the breadth of connectivity it offers. It supports 12 transports, including HTTP, CLI, WebSocket, gRPC, GraphQL, MCP and WebRTC, all from one open-source library. In practice this means a Ruby application does not have to change its tool-calling approach depending on how a given tool is exposed: a REST endpoint, a local command-line tool, a realtime WebSocket service, a gRPC service or a GraphQL API can all be described and invoked through the same protocol. For developers this reduces the amount of per-tool code they have to write and keep consistent, and reviewers have specifically highlighted that supporting 12 transports in a single library is a lot of surface area to keep coherent. A WebRTC transport also extends the reach of tool calling beyond conventional request/response APIs. Alongside raw transport support, Ruby UTCP provides tool discovery, so applications and agents can determine which tools are available rather than hard-coding a static list of endpoints. It also supports OpenAPI discovery, which means services that already publish an OpenAPI description can be discovered and used as tools, letting teams expose existing APIs to agents without hand-authoring manifest entries for every operation. Authentication is supported as part of the protocol as well, addressing a common gap in tool-calling setups where credentials have to be handled ad hoc outside the tool definition. Together, discovery and authentication make it practical to point an agent at a real, secured production API rather than a prototype endpoint. Ruby UTCP also supports streaming, so tools that return results progressively rather than in a single response can be used within the same unified tool-calling model. On top of that sits CodeMode, a capability for orchestrating multi-tool workflows with compact Ruby code. Rather than describing long chains of individual tool invocations one at a time, CodeMode lets developers express programmable, multi-step workflows in Ruby itself. A related UTCP launch, Code Mode, was positioned around slashing MCP token usage by 68%, and another project with similar goals, UTCP Agent, focused on building tool-calling agents in four lines of code — both illustrating the direction of travel toward less boilerplate and more compact orchestration. The overall approach is manifest-based and direct. A single JSON manifest describes the tool and how to reach it, and the library then calls the native transport rather than standing up a wrapper server. UTCP version 1.0.0 introduced a lean core, protocol plugins and a cleaner configuration, with the stated goal of letting teams scale their tool usage without wrestling with glue code. Because the protocol is plug-in oriented, the transport layer is extensible rather than monolithic, which is how one library can cover HTTP, CLI, WebSocket, gRPC, GraphQL, MCP, WebRTC and the other supported transports while keeping a consistent interface for the developer. The benefits that follow from this design are the ones the project states directly: lower latency because there is no intermediary wrapper layer, a lighter integration because no separate server process has to be run and maintained for a simple connection, and less glue code as tool usage grows. For Ruby teams, that means adopting UTCP does not require introducing a new runtime component into their stack — the gem lives inside the application they are already building. The protocol is also an open standard published by the Universal Tool Calling Protocol project, so work invested in tool manifests and workflows is not locked into a single vendor, and the MIT licence keeps both the specification implementation and the Ruby library free to use. Concrete uses follow from the stated capabilities. Ruby developers building AI agents can connect those agents to existing native APIs through a JSON manifest instead of running a wrapper server. Teams that need to combine several tools in a sequence can use CodeMode to express the multi-tool workflow as compact Ruby code rather than long chains of individual calls. Services that already publish an OpenAPI description can be picked up through OpenAPI discovery and exposed to an agent without hand-written definitions. Applications that need realtime tools can reach WebSocket, WebRTC or streaming endpoints. Ruby projects that already depend on MCP servers can consume them through the MCP transport while using UTCP for everything else, which a reviewer suggested as a desirable outcome: implementing the UTCP standard alongside MCP. The wider UTCP ecosystem also points to enterprise scenarios — a project called Hexis uses UTCP behind the hood for tool calling as a layer on top of Git where a company's AI skills, tools and knowledge live, centrally managed, reviewed and access-controlled. In terms of audience, tech stack and cost, Ruby UTCP is aimed squarely at Ruby developers creating AI agents and tool-powered applications, and it is distributed as an open-source Ruby gem. Its documentation and repository are published by the Universal Tool Calling Protocol organisation, and the launch page lists it as free. The makers explicitly invited feedback on the API and CodeMode, and on which integrations should come next, signalling that the library is intended to grow with the Ruby ecosystem it targets. Reviewers have noted that the docs cover the transports well individually, while suggesting that a single decision guide for picking the right transport for a given use case would help newcomers evaluating UTCP against MCP. Ruby UTCP's core value proposition is straightforward: it gives Ruby developers and their AI agents one open, manifest-based standard for discovering and calling tools across many native protocols, removing the wrapper-server overhead that makes tool calling heavier and slower than it needs to be. With 12 transports, streaming, authentication, OpenAPI discovery and CodeMode for programmable multi-tool workflows, all packaged as a free, MIT-licensed gem, it offers the Ruby ecosystem a scalable and secure alternative to MCP for connecting agents to the tools they need.