Ruby UTCP

Product Introduction

1. Definition: Ruby UTCP is the official Ruby SDK (Software Development Kit) implementation of the Universal Tool Calling Protocol (UTCP) 1.1. It is a protocol bridge and development framework that enables AI agents and applications to discover and directly invoke existing software tools over their native communication protocols.
2. Core Value Proposition: Ruby UTCP exists to eliminate the "wrapper tax" and complexity in AI tool integration. It allows Ruby developers to connect AI agents directly to any existing API, CLI, database, or service endpoint without building custom adapters or middleware, leveraging native authentication, security, and transport layers for lower latency and simpler architecture.

Main Features

1. Multi-Transport Support: Ruby UTCP provides a unified interface to call tools across 12+ native transport protocols. This includes synchronous protocols like HTTP (REST, OpenAPI/Swagger), gRPC, and GraphQL, as well as asynchronous and streaming protocols like WebSocket, Server-Sent Events (SSE), and CLI (command-line interface). It also supports specialized AI protocols like the Model Context Protocol (MCP) and WebRTC for real-time data channels.
2. Direct Native Endpoint Calling: The core mechanism bypasses proxy servers. After a tool's capabilities are discovered via a UTCP manifest, the Ruby agent runtime establishes a direct connection to the tool's actual endpoint (e.g., https://api.service.com/v1/resource). It uses the endpoint's native authentication scheme (OAuth, API keys, certificates) and communicates using its native data format (JSON, Protobuf, plain text).
3. CodeMode Integration for Workflow Automation: Ruby UTCP integrates with the separate CodeMode project. This feature allows developers to write a single, multi-step TypeScript function that orchestrates complex workflows across multiple UTCP (and MCP) tools. Instead of an AI model making dozens of sequential, uncertain tool calls, CodeMode executes a deterministic script in a secure sandbox, significantly improving reliability and performance for programmable agent logic.

Problems Solved

1. Pain Point: The high cost and latency of building and maintaining custom wrapper servers or adapters for every tool an AI agent needs to use. This "wrapper tax" introduces development overhead, points of failure, and delays as calls are routed through intermediary servers.
2. Target Audience: Ruby developers building AI-powered applications and autonomous agents; DevOps and platform engineers needing to securely expose internal services to AI; teams integrating AI into existing Ruby on Rails, Hanami, or Sinatra applications; developers seeking a standardized alternative to bespoke tool-calling logic.
3. Use Cases: A customer support chatbot in a Rails app that directly queries the internal PostgreSQL database and updates a CRM via its REST API; an autonomous DevOps agent that executes shell commands on servers via SSH/CLI and monitors logs via WebSocket; a data analysis agent that calls internal gRPC microservices and streams results via SSE to a dashboard.

Unique Advantages

1. Differentiation: Unlike the Model Context Protocol (MCP), which requires tools to be adapted into MCP servers, UTCP calls tools directly on their existing terms. Compared to framework-specific toolkits (e.g., LangChain tools), Ruby UTCP is transport-agnostic and protocol-native, avoiding lock-in and supporting a wider range of connection types beyond HTTP.
2. Key Innovation: The protocol's transport abstraction layer is its key innovation. By defining a common discovery and invocation schema that sits atop diverse protocols (HTTP, gRPC, CLI, etc.), it provides a universal interface for AI agents while preserving the unique advantages and security models of each underlying technology.

Frequently Asked Questions (FAQ)

1. What is the difference between Ruby UTCP and the Model Context Protocol (MCP)? Ruby UTCP is a protocol for directly calling existing tools on their native endpoints, whereas MCP is a protocol for serving new tool interfaces via a standardized server. UTCP avoids the wrapper tax; MCP requires it but offers rich resource management. They can be bridged, as seen in the utcp-mcp server project.
2. How does Ruby UTCP handle authentication and security for direct tool calls? Ruby UTCP does not invent new security models. It leverages the authentication and authorization mechanisms already built into the native protocol (e.g., OAuth 2.0 for HTTP, mTLS for gRPC, SSH keys for CLI). Credentials are managed by the calling application, ensuring the AI agent operates with the same security perimeter as a human user.
3. Can I use Ruby UTCP to call internal or private APIs within my company's network? Yes, this is a primary use case. Ruby UTCP excels at connecting AI agents to internal services. As long as the Ruby runtime executing the UTCP SDK has network access to the endpoint (e.g., within a VPC) and the necessary credentials, it can call private REST APIs, gRPC services, or internal databases directly.
4. Is Ruby UTCP only for AI agents, or can it be used in traditional applications? While designed for AI agent tool-calling, the Ruby UTCP SDK can be used as a generic, unified client for multi-protocol service integration in any Ruby application, simplifying code that needs to interact with diverse external systems.