Mitos

Computadoras aisladas y bifurcables para tus agentes de IA.
Bifurcación de sandbox microVM en milisegundos en Kubernetes: bifurca una VM en ejecución en intentos paralelos y restáurala desde la memoria en decenas de milisegundos.

Inicio rápido . Documentación . Características . Comparación . Contribuir . Comunidad

Qué es Mitos

Mitos le da a cada agente de IA su propia computadora aislada: una microVM Firecracker con aislamiento de hardware que ejecuta código no confiable de manera segura y que puedes bifurcar mientras se está ejecutando. Una bifurcación en vivo de copia en escritura ramifica una VM cálida en N hermanos independientes en decenas de milisegundos, por lo que un agente puede explorar muchos intentos en paralelo desde un estado compartido y listo, y solo pagas por las páginas que cada hermano modifica.

Ejecútalo hoy en tu propio clúster de Kubernetes, donde el código, los datos y las credenciales de tus agentes nunca salen de tu infraestructura, o en la API alojada sin nodos que administrar. Hasta donde sabemos, es el único runtime que es de código abierto, autoalojable, nativo de Kubernetes y capaz de bifurcar en vivo una VM en ejecución, todo al mismo tiempo.

Inicio rápido

1. Instalar y autenticar```bash

pip install mitos-run export MITOS_API_KEY=sk-... # a key from https://mitos.run; no Kubernetes required

El SDK utiliza por defecto el endpoint alojado. El mismo código se ejecuta contra tu propio clúster o un servidor sandbox independiente configurando `MITOS_BASE_URL`. La clave se resuelve a partir del argumento o de `MITOS_API_KEY` y nunca se registra.

### 2. Crear un sandbox y ejecutar código```python
import mitos

sb = mitos.create("python")                  # Ready microVM sandbox (~27 ms warm-claim)
print(sb.exec("echo hello").stdout)          # hello

# Files and a stateful code interpreter hang off the same flat handle.
sb.files.write("/workspace/plan.txt", "draft")
print(sb.run_code("import math; math.sqrt(144)").text)   # 12.0

Referencia completa: mitos.run/docs/quickstart.

3. Bifurcar en intentos paralelos```python

N-way copy-on-write fork of the live VM: each sibling lands warm and independent.

a, b = sb.fork(2) a.exec("echo conservative > /workspace/plan.txt") b.exec("echo aggressive > /workspace/plan.txt")

sb.terminate()

El cliente asíncrono refleja la misma superficie: `await mitos.aio.create("python")` devuelve un `AsyncDirectSandbox` con los mismos `exec` / `run_code` / `files` / `create_pty` / `fork` / `terminate`.

Los métodos bloqueantes `exec` y `run_code` funcionan en el husk predeterminado. El exec en streaming (`sb.exec(..., on_stdout=...)`), los procesos en segundo plano (`sb.exec_background(...)`) y el PTY interactivo (`sb.create_pty()`) se ejecutan actualmente en la ruta del motor y se están incorporando al husk predeterminado; `run_code` devuelve un `KernelUnavailable` de fallo cerrado hasta que el kernel se incluya en la imagen base del husk.

### Ejecútalo a tu manera

Mismo motor, misma API, más puntos de entrada. La profundidad está a un clic en [la documentación](https://mitos.run/docs).

**Cada idioma, dos modos.** Cada SDK habla la misma API REST de servidor sandbox en **modo directo** (independiente o alojado), y cada uno también tiene **modo clúster** (un `AgentRun` que controla los CRD `mitos.run/v1` a través de la API de Kubernetes). La nomenclatura del pool predeterminado es byte por byte idéntica en los seis.

| Idioma | Instalación | Directo | Clúster | Documentación del SDK |
|---|---|---|---|---|
| Python | `pip install mitos-run` | síncrono + asíncrono | `AgentRun` | [sdk/python](https://github.com/mitos-run/mitos/blob/main/sdk/python) |
| TypeScript | `npm i @mitos/sdk` | sí | `AgentRun` | [sdk/typescript](https://github.com/mitos-run/mitos/blob/main/sdk/typescript/README.md) |
| Go | `go get github.com/mitos-run/mitos/sdk/go` | tipado, compatible con `errors.Is` | `AgentRun` | [sdk/go](https://github.com/mitos-run/mitos/blob/main/sdk/go/README.md) |
| Ruby | gema (solo stdlib) | sí | `AgentRun` | [sdk/ruby](https://github.com/mitos-run/mitos/blob/main/sdk/ruby/README.md) |
| Rust | caja (bloqueante) | sí | `AgentRun` | [sdk/rust](https://github.com/mitos-run/mitos/blob/main/sdk/rust/README.md) |
| Java | JDK 17 (solo stdlib) | sí | `AgentRun` | [sdk/java](https://github.com/mitos-run/mitos/blob/main/sdk/java/README.md) |

El SDK de Go se distribuye en su propio módulo anidado (`github.com/mitos-run/mitos/sdk/go`), por lo que importarlo nunca incorpora el controlador a tu compilación.

**¿Autoalojamiento? Mismo código.** El chart de Helm despliega la misma puerta de enlace que ejecuta el servicio alojado, por lo que el inicio rápido anterior funciona sin cambios en tu propio clúster: apunta `MITOS_BASE_URL` a tu puerta de enlace y mantén todo lo demás. Alojado y autoalojado son una misma experiencia; solo difieren la URL y quién lo opera.

**Control nativo de Kubernetes, cuando lo desees.** Para equipos de plataforma que gestionan pools de forma declarativa (GitOps, automatización con ámbito RBAC, operadores), la ruta de dos niveles `AgentRun` omite la puerta de enlace y controla los CRD `mitos.run/v1` directamente a través de la API de Kubernetes:```python
from mitos import AgentRun

c = AgentRun()                                   # kubeconfig or in-cluster; autodetected
sb = c.sandbox("python", ready=True)             # claims a warm sandbox, waits Ready
print(sb.exec("python -c 'print(40 + 2)'").stdout)   # 42