El cloud backend para agentes de IA confiables.
Memoria, retries, tools, traces y durable execution — sin construir vos la infraestructura de orquestación. Registrate gratis o self-host en tres comandos.
import { createAgent, builtin, tool } from "@relayhq/sdk";
const reviewPR = tool({
name: "review_pr",
description: "Read a GitHub PR and return a summary",
inputSchema: { type: "object", properties: { url: { type: "string" } } },
async handler({ url }) { return github.pulls.get(url); },
});
const agent = createAgent({
model: "claude-sonnet-4-6",
memory: { namespace: `user:${userId}` },
tools: [builtin.calculator, reviewPR],
});
for await (const e of agent.run("Review the last PR")) {
if (e.type === "token") process.stdout.write(e.text);
}Construido sobre infra aburrida y probada
El problema
Las apps de IA fallan en producción porque la orquestación no es confiable.
Todo equipo que construye agentes reales termina escribiendo la misma plomería: queues, retries, máquinas de estado, dispatch de tools, traces, memoria, replay. Relay es esa plomería — ya construida, probada, fuera del camino.
El cambio
Dejá de construir infraestructura.
El mismo agente. Una llamada al SDK contra nueve sistemas cableados a mano.
- —SDK de OpenAI / Anthropic
- —Redis
- —Queues
- —Retries + backoff
- —Manejo de estado
- —Orquestación de tools
- —Tracing + replay
- —Worker pool
- —Memoria + embeddings
const agent = createAgent({
model: "claude-sonnet-4-6",
tools: [github, slack],
memory: { namespace: "user:42" },
})
await agent.run("Review the last PR")Un SDK. Todos los providers. Memoria, tools, traces, retries — built-in.
Cómo funciona
Tres pasos desde `git clone` hasta un agente con streaming, traces y memoria.
Self-host con Docker Compose. Todo el stack en tu laptop en dos minutos.
Cloná y bootstrappeá
git clone, pnpm bootstrap. Idempotente — genera keys, levanta Postgres, aplica migrations, mintea tu API key.
Traé tus propias keys
Subís credenciales de Anthropic / OpenAI / OpenAI-compatible una sola vez. Encriptadas con AES-256-GCM y resueltas por request.
Corré y observá
Cada token, tool call y hit de memoria queda persistido como event log ordenado. Replay completo de cualquier run en el dashboard.
git clone https://github.com/KevinCorrea5103/relay
cd relay && pnpm install
pnpm bootstrap # mints keys, brings up Postgres, migrates
pnpm dev # runtime + control-plane + dashboard + webQué viene en la caja
Primitivas de producción, no un demo.
Todo lo que un agente necesita en producción, expuesto por un solo SDK.
/ Routing multi-provider
Anthropic, OpenAI, y cualquier endpoint OpenAI-compatible (Ollama, vLLM, Groq, Together, OpenRouter). Cambiás con un string.
/ Orquestación multi-agente
createOrchestrator() arma un supervisor que rutea a especialistas. subagent() convierte cualquier agente en una tool que otro agente puede llamar.
/ Workflows declarativos
La Graph API compone steps, agentes, edges y condicionales — pipelines secuenciales, fan-out en paralelo o loops con estado.
/ Function tools custom
Las tools corren en tu proceso, no en el nuestro. El SDK envía el schema, el runtime pausa en cada tool call, vos resolvés localmente por el mismo stream.
/ Memoria semántica
pgvector + indexación automática. Los agentes recuerdan interacciones pasadas por namespace sin que toques un embedding.
/ Voz de entrada y salida
Transcribí audio con Whisper y generá voz con OpenAI TTS — 11 voces, directo desde el SDK. El audio se streamea, nunca se guarda.
/ Traces de ejecución persistentes
Cada run es un event log ordenado: tokens, tool calls, retrievals de memoria, errores. Replay completo en el dashboard. Mirror opcional a ClickHouse para 10k+ eventos/seg.
/ Streaming + tool calling
SSE nativo end-to-end. Tokens stream mientras se generan. Tool calls se despachan en paralelo sin romper la iteración.
/ Encriptación BYOK
AES-256-GCM por tenant. El runtime nunca ve una Relay key y no tiene acceso a la base. Los costos van directo a los providers.
/ Aislamiento por tenant + audit
Row-level security de Postgres scopea cada lectura. Runs, memorias y credenciales etiquetadas por tenant, y cada acción sensible queda en un audit log.
/ Rate limits y rotación de keys
Rate limiting token-bucket por tenant (con Redis para un fleet), más rotación de API keys y master key sin downtime.
/ 100% self-host
Tres servicios y un Postgres con Docker Compose. Escala horizontal con un broker NATS. Corré en tu laptop o tu propia cloud — sin vendor en el medio.
Componé agentes
Un agente es el principio. Relay está hecho para equipos de agentes.
Delegá, supervisá o cableá grafos explícitos — cada sub-run queda trazado bajo un mismo workflow con el costo sumado del equipo.
- subagent()
- Envolvé cualquier agente como una tool que otro agente puede llamar y delegarle — con un cap de profundidad para que nunca se descontrole.
- createOrchestrator()
- Un supervisor rutea cada pedido al especialista correcto. El system prompt se autogenera a partir de la descripción del equipo.
- Graph API
- Steps, edges y condicionales declarativos: pipelines secuenciales, fan-out en paralelo o loops con estado compartido.
Cada sub-run comparte un workflow_id, así el dashboard arma el árbol completo con tokens y costo agregados de todo el equipo.
import { createAgent, createOrchestrator } from "@relayhq/sdk";
const researcher = createAgent({
model: "claude-sonnet-4-6",
system: "Find and verify facts. Cite sources.",
});
const writer = createAgent({
model: "gpt-4o",
system: "Turn notes into crisp, on-brand prose.",
});
// A supervisor that routes to the right teammate — the system
// prompt is auto-generated from the team description.
const team = createOrchestrator({
model: "claude-sonnet-4-6",
agents: {
researcher: { agent: researcher, description: "Finds and verifies facts" },
writer: { agent: writer, description: "Drafts copy from notes" },
},
});
for await (const e of team.run("Draft a launch post about our new pricing")) {
if (e.type === "token") process.stdout.write(e.text);
}Usalo desde donde quieras
TypeScript hoy. Python hoy. Cualquier otro stack sobre HTTP plano.
Dos SDKs oficiales y un protocolo HTTP + SSE documentado — lo metés en cualquier stack.
import { createAgent } from "@relayhq/sdk";
const agent = createAgent({
apiKey: process.env.RELAY_API_KEY!,
baseUrl: "https://api.relaygh.dev",
model: "gpt-4o-mini",
});
for await (const event of agent.run("Say hi in three languages.")) {
if (event.type === "token") process.stdout.write(event.text);
}¿No hay SDK para tu lenguaje? El protocolo es HTTP + SSE plano — ~30 líneas en cualquier lenguaje. Mirá . /docs/api
Observabilidad
Cada run es una execution trace completa.
Tokens, tool calls, resultados, retrievals de memoria, errores — capturados en orden. Replay de cualquier cosa.
Dashboard built-in. Ves exactamente lo que hizo el modelo — incluidos los errores que corrigió solo.
FAQ
Preguntas
¿Hay versión hosteada?+
Sí — gratis durante la beta, sin tarjeta. Te registrás con tu email + una key de OpenAI/Anthropic, recibís un `relay_live_…` y apuntás el SDK ahí. El cloud y el self-host corren exactamente el mismo código; cambiás de uno a otro con un solo env var.
¿Se quedan con un porcentaje de mis tokens?+
No. Relay es BYOK por diseño — subís tus propias keys de Anthropic / OpenAI (encriptadas con AES-256-GCM apenas llegan) y tus tokens van directo a los providers. Nunca proxeamos billing.
¿Es otro wrapper de LangChain?+
No. Relay es el runtime debajo del agente, no una abstracción de chains. Vos escribís funciones planas; Relay maneja estado, retries, providers, tools, memoria y traces.
¿Dónde vive mi data?+
En el cloud: una porción aislada de Postgres en Supabase por tenant, credenciales encriptadas at rest. En self-host: donde tengas tu Postgres. En cualquier caso, tus tool handlers corren en tu proceso — Relay nunca ve tu lógica de negocio.
¿Qué lock-in hay?+
Casi ninguno. Tus tools son funciones de TypeScript en tu repo. Tus prompts son strings. Tu memoria es una tabla de Postgres exportable. El protocolo del SDK es HTTP + SSE plano. Pasar de cloud a self-host (o al revés) es cambiar un `baseUrl`.
¿Qué hace hoy — y qué viene?+
Hoy ya anda: agentes con streaming, routing multi-provider, tools custom, memoria semántica, voz (Whisper + TTS), orquestación multi-agente y la Graph API, traces de ejecución completos, encriptación BYOK, row-level security, audit logs y rate limiting. Lo que viene: durable execution (resumir ante crashes) y checkpoints de human-in-the-loop. El roadmap completo está en GitHub.
Empezá
Conseguí una API key. Lanzá un agente hoy.
Cloud beta gratis — sin tarjeta. O self-host del stack completo en tres comandos.