Rayito¶

Sandboxes para agentes de IA, compatibles con E2B, dentro de tu propia cuenta de AWS. Cada sandbox es un MicroVM de AWS Lambda aislado por hardware. Dentro corre rayd, un agente escrito en Rust. No hay servidor de terceros ni API key: el SDK llama directamente a la API de AWS con tus credenciales.

Sandboxes que aparecen en un destello. Dentro de tu propia cuenta de AWS.

Empezar (≈ 15 min) Migrar desde E2B

Nuevo en 0.10

El agente del sandbox puede usar más proveedores de modelo: OpenAI, Gemini, Azure OpenAI, OpenRouter, Groq, Mistral, DeepSeek, xAI o tu propio proxy de LiteLLM, cada uno con un preset listo. Además, el timeout y abort() del agente paran todo lo que lanzó, y deepagents funciona con modelos que no son de Bedrock y cuenta sus tokens. Sin cambios que rompan. Novedades de 0.10.0 · Proveedores del agente · 0.9.1 · 0.9.0

Empieza en tres pasos¶

1. Instala el SDK (Python ≥ 3.11 o Node ≥ 20).

PythonTypeScript

pip install "rayito[cli]"      # o: uv add "rayito[cli]"

pnpm add rayito                # o: npm i rayito / yarn add rayito / bun add rayito
pip install "rayito[cli]"      # la CLI (para el diagnóstico) es Python

2. Comprueba tu cuenta. Con tus credenciales de AWS y una imagen rayito-base publicada (Configurar AWS), el diagnóstico dice qué falta antes del primer sandbox:

export AWS_PROFILE=<tu-perfil> AWS_REGION=us-east-1 RAYITO_TEMPLATE=rayito-base
rayito doctor --template "$RAYITO_TEMPLATE"

RAYITO_TEMPLATE es la imagen que usará Sandbox.create(); rayito doctor no la lee, así que pásasela con --template (sin él comprueba rayito-base).

3. Crea tu primer sandbox.

PythonTypeScriptShim E2B

from rayito import Sandbox

with Sandbox.create() as sbx:  # (1)!
    print(sbx.commands.run("echo hola").stdout)  # "hola\n"
    print(sbx.run_code("x = 40; x + 2").text)  # "42"

with mata el sandbox al salir: un sandbox olvidado factura hasta su timeout.

import { Sandbox } from "rayito";

await using sbx = await Sandbox.create(); // (1)!
console.log((await sbx.commands.run("echo hola")).stdout); // "hola\n"
console.log((await sbx.runCode("x = 40; x + 2")).text); // "42"

await using mata el sandbox al salir del bloque.

from rayito.e2b import Sandbox  # antes: from e2b_code_interpreter import Sandbox

with Sandbox.create(timeout=300) as sbx:
    print(sbx.commands.run("echo hola").stdout)  # "hola\n"
    print(sbx.run_code("x = 40; x + 2").text)  # "42"

El código escrito para E2B 2.x, cambiando sólo el import (Migrar desde E2B).

Guarda el código en primer.py y ejecútalo con python primer.py, o en primer.ts y ejecútalo con npx tsx primer.ts (TypeScript necesita "type": "module" y un tsconfig.json: ver Ejecutar los ejemplos).

Siguiente paso: Primer sandbox recorre comandos, ficheros, código y reconexión en Python, Python async y TypeScript.

Un agente de código dentro del sandbox¶

sbx.agent corre un agente de código (OpenCode o deepagents) dentro del propio sandbox. El agente llama a su modelo (Bedrock, Anthropic, OpenAI, Gemini, Azure OpenAI, OpenRouter, Groq, Mistral, DeepSeek, xAI, tu proxy de LiteLLM o cualquier endpoint compatible con OpenAI; ver Proveedores del agente) sólo a través de la pasarela de secretos: usa la credencial, pero nunca puede leerla. Basta un Sandbox.create() normal sobre la imagen rayito-agent (Templates de agente):

PythonTypeScript

from rayito import AgentModel, AgentSpec, Sandbox, SecretStore, bedrock_gateway

MODEL_ID = "us.anthropic.claude-haiku-4-5-20251001-v1:0"
SecretStore().create("bedrock-key", "Bearer <clave de Bedrock de corta duración>")
spec = AgentSpec(model=AgentModel(provider="bedrock", id=MODEL_ID, gateway="bedrock", region="us-east-1"))

with Sandbox.create(
    template="rayito-agent",
    allow_internet_access=False,
    gateways={"bedrock": bedrock_gateway("bedrock-key", region="us-east-1", models=[MODEL_ID])},
) as sbx:
    result = sbx.agent.run("Lista los ficheros de /home/user y resume qué hay.", spec=spec)
    print(result.text, result.usage.total)

import { AgentModel, AgentSpec, Sandbox, SecretStore, bedrockGateway } from "rayito";

const MODEL_ID = "us.anthropic.claude-haiku-4-5-20251001-v1:0";
await new SecretStore().create("bedrock-key", "Bearer <clave de Bedrock de corta duración>");
const spec = new AgentSpec({
  model: new AgentModel({ provider: "bedrock", id: MODEL_ID, gateway: "bedrock", region: "us-east-1" }),
});

await using sbx = await Sandbox.create({
  template: "rayito-agent",
  allowInternetAccess: false,
  gateways: { bedrock: bedrockGateway("bedrock-key", { region: "us-east-1", models: [MODEL_ID] }) },
});
const result = await sbx.agent.run("Lista los ficheros de /home/user y resume qué hay.", { spec });
console.log(result.text, result.usage.total);

Arrancar más rápido (un pool con warmup) es opcional: cuándo compensa cada opción, en ¿Qué uso?. Lo que cuesta la VM frente a los tokens del modelo: Precios.

Explora la documentación¶

Primeros pasos

Instala el SDK, prepara tu cuenta de AWS y lanza tu primer sandbox.

Empezar
Guías

Una página por función: comandos, código, ficheros, terminal, red, pausa, pool, persistencia, el agente dentro del sandbox y más.

Ver las guías
Migrar desde E2B

Cambia un import y sigue con tu código. Qué cambia, qué no y qué no existe en Lambda MicroVMs.

Migrar
Referencia

API de Python y TypeScript, CLI, errores, variables de entorno y límites.

Referencia
Funciones opcionales

Secretos, pasarela de secretos, montajes S3, tamaños, eventos y webhooks, OTLP, templates, volúmenes EFS y dominio propio: qué activa cada una, qué cuesta y cómo apagarla.

Resumen y coste
Novedades

Qué trae cada versión, cómo actualizar y qué está en desarrollo.

Novedades
Costes

Lo que cuesta cada operación (precio de lista y medido en AWS real), el pool y un agente de IA: VM frente a tokens del modelo. Las funciones con coste propio están apagadas por defecto.

Precios · Agente en el sandbox
Seguridad

Qué protege el SDK por defecto, qué no poner en envs y el modelo de amenazas.

Seguridad

Por qué Rayito¶

El código no sale de tu cuenta. Los sandboxes corren en tu cuenta de AWS y facturan en tu factura de AWS. Nadie más ve los datos.
Sin nada que operar. No hay clúster, plano de control ni servidor de Rayito. El SDK habla con la API de Lambda MicroVMs y con rayd, el agente del MicroVM.
La API de E2B. rayito.e2b (Python) y rayito/e2b (TypeScript) aceptan el código escrito para E2B 2.x cambiando sólo el import. Lo que la plataforma no puede hacer lanza UnimplementedError: nada se aproxima en silencio.
Nunca cobra por sorpresa. Las funciones opcionales que gastan dinero de AWS además del propio sandbox (secretos, pasarela de secretos, índice de metadatos, eventos y webhooks, exportación OTLP, templates, volúmenes EFS, dominio propio…) están apagadas por defecto y sólo se activan con una opción explícita del SDK; su infraestructura la despliegas tú con rayito stack deploy, que imprime el coste antes de pedir confirmación (Funciones opcionales). La otra vía con coste propio, el bucket de transferencias por S3, también la eliges tú (transfer= o RAYITO_TRANSFER_BUCKET; ver Ficheros y S3).

Qué incluye¶

Superficie	Qué hace	Guía
`Sandbox.create / connect / kill / list / get_info`	ciclo de vida del MicroVM, metadatos y plazos	Ciclo de vida
`pause()` / `resume()`, `IdlePolicy`	suspender y reanudar con todo el estado vivo	Pausar y reanudar
`timeout`, `max_lifetime`, `on_timeout`, `set_timeout()`	un plazo que `rayd` impone aunque tu proceso muera	Plazo del servidor
`sbx.commands`	procesos en primer y segundo plano, `stdin`, `kill`, reconexión	Comandos
`sbx.run_code`	kernel Jupyter con estado, resultados, logs, errores y gráficos	Ejecutar código
`run_code(language="bash" / "javascript" / "typescript")`	kernels bash y Deno en `rayito-base-poly`	Lenguajes y kernels
`sbx.pty`	terminales reales con `resize` y reconexión	Terminal (PTY)
`sbx.files`	leer, escribir, listar y vigilar; ficheros grandes y URLs firmadas por S3	Ficheros y S3
`sbx.get_host(port)`	acceso HTTP a un puerto del sandbox	Puertos y host
`network=`, `allow_internet_access=False`	política de salida a internet de E2B en `rayito-base-caps`	Red saliente
`SandboxPool`	sandboxes en menos de un segundo desde un pool de suspendidos	Pool
`persist=`, `reincarnate()`	el `HOME` en S3, más allá de las 8 h	Persistencia
`get_metrics_history()`, `Sandbox.paginate()`	historial de métricas y listado reanudable	Métricas y listado
`sbx.git`	la API git de E2B	Git
`sbx.agent`	un agente de código (OpenCode o deepagents) dentro del sandbox, con el modelo tras la pasarela de secretos	Agente en el sandbox
`rayito.e2b`, `rayito/e2b`	el SDK de E2B 2.x cambiando sólo el import	Migrar desde E2B
`rayito-mcp`	un sandbox para Claude Code, Cursor o VS Code por MCP	Servidor MCP
LangChain, Vercel AI SDK	Rayito como herramienta de un agente que corre fuera del sandbox	LangChain y Vercel AI
`rayito` (CLI)	publicar la imagen, diagnosticar la cuenta, operar sandboxes y pilas	CLI
`make local-up`, `make local-e2e`	probar los SDK contra un `rayd` real y un AWS emulado, sin cuenta	Probar en local

Funciones opcionales, todas apagadas por defecto hasta que pasas su opción (o, en las que son sólo de la CLI, ejecutas su orden):

Superficie	Qué hace	Guía
`secrets=`, `SecretStore`	secretos de AWS Secrets Manager como variables de entorno	Secretos
`gateways=`, `SecretGateway`	usar un secreto desde el sandbox sin poder leerlo	Pasarela de secretos
`mounts=`, `S3Mount`	un bucket S3 como carpeta del sandbox	Montajes S3
`size=`	sandboxes de 512 MiB a 8 GiB desde imágenes por tamaño	Tamaños
`events=`, `LifecycleEvents`	eventos de ciclo de vida y webhooks con la firma de E2B	Eventos y webhooks
`telemetry=`, `TelemetryExport`	métricas del sandbox por OTLP a CloudWatch	Exportación OTLP
`tracer_provider=`	spans OpenTelemetry del lado del SDK	OpenTelemetry
`index=DynamoDbIndex(...)`	filtrar por metadatos también sandboxes en pausa	Índice de metadatos
`Template.build()`	imágenes desde el DSL `Template` de E2B	Templates
`AgentTemplate`, `rayito agent template build`	la imagen `rayito-agent` con OpenCode, ripgrep y deepagents	Templates de agente
`PoolConfig(warmup=agent_pool_warmup(...))`	plazas del pool con el agente ya calentado (arranque rápido, opcional)	Pool
`OptionalStacks`, `rayito stack`	desplegar, consultar y borrar la infraestructura de cada función	Pilas opcionales
`rayito sandbox proxy`	un puerto del sandbox en `http://127.0.0.1` de tu máquina	Proxy local
`volumes=`, `VolumeStore`, `EfsVolumes` (experimental)	un sistema de ficheros EFS compartido en vivo entre sandboxes, en tu VPC	Volúmenes EFS
`domain=`, `CustomDomain`, `rayito domain` (experimental)	una URL HTTPS bajo tu dominio para un puerto del sandbox	Dominio propio

Todo funciona igual en Python (sync y asyncio) y en TypeScript, con snake_case y segundos en Python y camelCase y milisegundos en TypeScript. Los números de costes y límites están medidos contra AWS real, nunca contra un simulador.