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.
/ 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 sin que toques un embedding.
/ Traces de ejecución persistentes
Cada run es un event log ordenado: tokens, tool calls, retrievals de memoria, errores. Replay completo para debuggear.
/ 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.
/ Streaming + tool calling
SSE nativo end-to-end. Tokens stream mientras se generan. Tool calls se despachan en paralelo sin romper la iteración.
/ Aislamiento por tenant
Las API keys scopean cada lectura. Runs, memorias, credenciales — todo etiquetado con su tenant. Multi-tenancy desde día uno.
/ 100% self-host
Tres servicios y un Postgres. Corré en tu laptop con Docker, o en tu propia cloud. Sin vendor en el medio.
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é viene?+
Durable execution (agentes resumibles ante crashes), checkpoints de human-in-the-loop, multi-agent orchestration, voice agents. 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.