AURA es un runtime de código abierto que opera en vivo sobre los sistemas que ya tienes, compone el trabajo por sí mismo desde una meta en lenguaje natural, y sella cada acción que toca el mundo en una bitácora encadenada por hash que cualquiera verifica sin conexión: sin el nodo corriendo y sin confiar en nosotros.
Empieza sin adoptar nada
Un comando. Sin runtime que levantar, sin puerto que elegir, sin reescribir nada, sin SDK. Cada llamada a herramienta que haga tu agente pasa ahora por una política que tú controlas, se detiene ante un humano si actúa sobre el mundo, y aterriza en una bitácora que se verifica sin conexión.
Una herramienta se bloquea por defecto. `readOnlyHint` es una afirmación del mismo servidor sobre el que trata la llamada, y el envenenamiento de descriptores es la vulnerabilidad más frecuente del lado cliente según estudios a gran escala del ecosistema MCP. Creerle a esa anotación se activa a mano; no es lo predeterminado.
Si no hay nada escuchando, guard arranca un kernel embebido por ti. No hay ningún paso de infraestructura entre leer esto y tener un punto de control frente a tu agente.
Una llamada MCP regresa cargando lo que hizo —capacidad, decisión, resultado y el humano que lo firmó— en `_meta`, así la evidencia viaja con el resultado en vez de quedarse en un log que alguien tiene que correlacionar después.
Figura 1
Hoy
Con aura guard
El agente, los servidores y la configuración no cambian. Un proceso se mete en el camino.
Esto se sostiene exactamente hasta donde llega tu control sobre la configuración del agente. No hay imposición a nivel de red: a un agente al que se le puede cambiar la configuración se le puede dar la vuelta al punto de control.
Cómo funciona guard
$ aura guard --config claude_desktop_config.json
no node on port 9080 — running an embedded kernel
ledger every guarded call is sealed here
TOOL CAPABILITY ON CALL
probe/read_thing motor.mcp.probe.read_thing human approval + sealed
probe/write_thing motor.mcp.probe.write_thing human approval + sealed
2 of 2 act on the world and are gated; the rest are read-only.Auditabilidad
Los frameworks de agentes registran lo que alguien se acordó de registrar, en código que tú escribiste: el código que lo olvida no deja rastro. AURA sella la evidencia en el único punto por el que pasa toda entrega. Por eso puede seguir respondiendo seis meses después, con el nodo apagado.
Figura 2
Llega el sobre
tipado, causal, deduplicado
La política del nodo decide
permitir / compuerta / denegar
Un humano firma
Ed25519, una clave que el nodo nunca tuvo
Sellado en la cadena
hash + cabecera Merkle firmada
Entregado con recibo
el efecto ocurre, y es demostrable
¿Rechazado? También se sella. Un auditor pregunta qué se intentó, no sólo qué tuvo éxito.
Esto lo aplica el ejecutor, no tu grafo. Un grafo puede pedir más escrutinio del que exige la política, nunca menos.
En las librerías de agentes la interrupción vive en tu código. Aquí el ejecutor la aplica en el único punto que cruza toda entrega, guiado por la política del nodo. Un grafo puede pedir más escrutinio del que exige la política — nunca menos. Incluso un grafo cuyo autor nunca escribió una compuerta tiene una.
Un log que dice «un humano aprobó» no evidencia a nadie. El operador firma un enunciado ligado a esa única entrega con una clave que el nodo nunca tuvo — así el aprobador no puede negarlo después, y el nodo no puede fabricar una aprobación. Lo redactamos como Internet-Draft.
Sellado en un registro encadenado por hash comprometido a una cabecera Merkle RFC 6962 que el nodo firma y un tercero puede contrafirmar. `aura verify` recomputa cadena, árbol y firmas desde el archivo de base de datos solo.
Una credencial con alcance puede conectarse, registrarse como esa única capacidad y gastar los recibos que le entregan — y no puede registrar un grafo, leer la bitácora ni dar de alta a un aprobador. Una sola tabla ordenada decide qué alcanza cada alcance, denegando por defecto.
La credencial vive en el kernel y solo se libera contra el recibo de un efecto que acaba de pasar el punto de control. Saltarse la compuerta deja de ser una forma de evitar escrutinio y se convierte en una forma de recibir un 401.
Una skill atestigua motor, modelo, revisión, cuantización, parámetros de muestreo y semilla, ligados a cada efecto que esa salida causó. La sustitución silenciosa de modelo se convierte en un hash roto dentro de una cadena que solo crece. Donde el hardware puede estrecharlo, un quote TEE se liga a esa declaración exacta.
Figura 3
Cada entrada se compromete a la anterior, y una cabecera Merkle firmada se compromete a todas a la vez. aura verify recomputa ambas desde el archivo de base de datos solo.
Por qué esto está especificado, no inventado
El Reglamento (UE) 2024/1689 —la Ley de IA de la UE— lo exige a los sistemas de alto riesgo desde el 2 de diciembre de 2027. Ese plazo era el 2 de agosto de 2026 hasta que el Ómnibus Digital sobre IA lo aplazó. Lo que se movió fue el calendario, no el requisito.
⚖︎ Nada de esto hace que un despliegue sea conforme. AURA emite registros; no realiza una evaluación de conformidad, y ninguna herramienta puede hacer esa parte por ti. Lo que sí elimina es el fallo habitual: descubrir en la auditoría que tus únicos registros son logs de aplicación que nadie puede probar que no fueron editados.
El reporte trae los conteos, los distintos documentos de política vigentes, un desglose por capacidad y por operador firmante, y un recibo portátil por cada efecto con compuerta. Se verifica por sí solo.
aura audit — 2026-05-21 to 2026-08-19
node node-ffdb6552fdedeea5
1 effect(s) acted on the world · 1 delivered · 0 refused
1 passed a human gate · 0 cleared by policy
WHAT ACTED
CAPABILITY EFFECTS GATED WAIVED
motor.api.shop.refund_order 1 1 0
INTEGRITY
1 entries · chain intact · 1/1 checkpoint(s) valid
SOUND — the record verifies from the database file alone.
Note: unwitnessed. This rests on the node's own key.IA en tiempo real
n8n, Zapier y Make disparan un trigger, corren una cadena una vez y terminan. Eso le queda bien a una sincronización nocturna y se cae en cuanto el trabajo está vivo: una conversación, un video, una base de datos cambiando bajo tus pies, un modelo respondiendo token a token.
Figura 4
No es un benchmark, es una forma. La barra por lotes no puede empezar hasta sondear la fuente, ni entregar nada abajo hasta que la respuesta esté completa.
Unidad de trabajo
Herramientas por lotes Una ejecución: arranca, corre, se desmonta
Deep Axiom AURA Una conexión que permanece abierta
Obtener datos
Herramientas por lotes Sondear cada 5 minutos
Deep Axiom AURA La fuente empuja, conforme ocurre
Un LLM respondiendo
Herramientas por lotes Esperar la respuesta completa
Deep Axiom AURA Token a token; lo de abajo reacciona a media frase
Audio y video
Herramientas por lotes Realmente no soportado
Deep Axiom AURA PCM ritmado, transcripciones parciales, barge-in funcional
Un paquete perdido
Herramientas por lotes Atasca todo lo que va detrás (TCP)
Deep Axiom AURA Atasca solo su propio carril (QUIC)
Cancelar
Herramientas por lotes Al mejor esfuerzo
Deep Axiom AURA Garantía del kernel — la salida de una cadena cancelada no llega a ningún lado
Un nodo sirve QUIC (WebTransport) en el mismo número de puerto que su listener TCP. `realtime` es un datagrama que no puede atascar ni ser atascado, `reliable` es un stream ordenado por arista, y `bulk` recibe su propio stream. Un par que no alcanza UDP conserva la ruta WebSocket intacta. Los plazos son absolutos y se heredan — un salto puede apretarlos, nunca extenderlos.
realtime Un datagrama QUIC — no puede atascar ni ser atascado reliable Un stream ordenado por arista bulk Su propio stream, fuera del paso de todos La ventana de deduplicación, los índices causales, las compuertas pendientes y los contadores por salto se reconstruyen desde el log de eventos, sin importar si lo que murió fue el cliente o el kernel. La literatura de dataflow con estado lo llama transparencia ante fallos, y es la propiedad de la que un asistente en vivo no puede prescindir: no existe «vuelve a correr el trabajo» para una conversación.
Figura 5
En un solo stream TCP, todo lo que va detrás del hueco lo espera.
En QUIC sólo se atasca ese carril; los otros dos siguen entregando.
Un nodo sirve QUIC en el mismo número de puerto que su listener TCP. Un par que no alcanza UDP conserva la ruta WebSocket intacta.
Cada sobre se registra de forma durable antes de reconocerse. Eso antes significaba una transacción por evento haciendo fila en un único candado de escritura — 200 sesiones concurrentes hacían menos trabajo total que una. El commit en grupo mantiene a cada llamante esperando su propia durabilidad mientras todos los que ya esperaban se suman a la misma transacción.
| Sesiones concurrentes | Antes | Después |
|---|---|---|
| 1 | 1,556 msg/s · p50 0.47 ms | 1,504 msg/s · p50 0.58 ms |
| 50 | 365 msg/s · p50 96 ms | 1,631 msg/s · p50 19 ms |
| 200 | 344 msg/s · p50 489 ms | 1,908 msg/s · p50 63 ms |
| 1,000 (8×) | no lograba conectar | 28,202 msg/s · p50 0.51 ms |
Lee la tabla por su forma, no por los números absolutos: mide una skill de eco sobre loopback, así que es el costo de ruteo y durabilidad del kernel sin trabajo real en el bucle. La afirmación honesta es la fila de en medio — con 200 sesiones el mismo nodo pasó de 344 msg/s a 1,908, y el p50 de 489 ms a 63 ms, sin debilitar la durabilidad.
La codificación JSON era el 1% del CPU mientras la E/S de archivo de SQLite era el 54%. El log causal de eventos salió de SQLite hacia archivos de segmento que solo crecen, con un CRC por registro y escrituras confirmadas en grupo — 1.5M eventos/seg contra los 27k de SQLite a durabilidad equivalente. La bitácora de efectos se queda en SQLite a propósito: un bug en el log de eventos pierde historial de replay, un bug en la bitácora pierde evidencia.
Arquitectura
Los contratos están versionados, solo admiten cambios aditivos, y vienen con una suite de conformidad que cualquier kernel alternativo puede correr. Eso es lo que hace que la neutralidad de este ecosistema sea algo que puedes comprobar en vez de algo que prometemos.
Figura 6
Sólo la arista que entra a una skill motora lleva compuerta, y sólo una entrega motora se sella. Lo demás es tráfico ordinario, y el log de eventos lo registra todo para que aura why narre la cadena.
Qué es una skill: identidad, puertos tipados, permisos declarados y el tipo de efecto que decide cómo la trata el kernel.
Cómo se conectan las skills. Un humano escribe unas líneas de JSON o un planificador lo genera desde una meta — ambos compilan al mismo IR y corren por el mismo ejecutor.
El sobre en el cable: tipado, causal, deduplicado, con contrapresión y QoS por arista sobre WebSocket o QUIC.
Qué actuó sobre el mundo, bajo qué política, aprobado por quién, sellado en una cadena de hashes con cabecera Merkle firmada.
Lo que el modelo afirmó sobre sí mismo —motor, revisión, cuantización, semilla— ligado criptográficamente a los efectos que causó.
Los cinco tipos son un sistema de tipos de efecto, no una taxonomía para la documentación. «¿Es seguro correr esto antes de tener certeza?» lo responde el manifiesto y no el criterio del autor del grafo — por eso aquí la especulación es segura y en todos lados es artesanal.
Percibe. ASR, OCR, cámaras, CDC de una base de datos, o la proyección de solo lectura de una API que ya tienes.
Actúa sobre el mundo. Toda arista que llega a una lleva una compuerta que aplica el kernel — y toda entrega se sella en la bitácora.
Razona. Cualquier LLM tras una sola interfaz: un GGUF local sin cuenta, o cualquier endpoint compatible con OpenAI.
Transforma de forma determinista. Parsers, validadores, troceadores — la plomería entre dos puertos tipados.
Recuerda. Persiste y recupera el contexto que un grafo tiene permitido gastar, contra un presupuesto declarado.
La unidad atómica y reutilizable — lógica, un modelo, o la proyección de un sistema que ya operas. Conectado al kernel, nunca reescrito.
Skills conectadas por canales tipados. Escrito a mano o generado por el planificador, ambos compilan al mismo IR. Un depurador, un modelo de permisos, un camino de replay.
Una ejecución viva, causal y explicable. Cada mensaje nombra al mensaje que lo causó, y el log sobrevive al proceso que lo escribió.
`write: true` es la única línea aquí que habla de seguridad, y es una declaración, no una implementación. A partir de ella el kernel clasifica la llamada como capacidad motora, aplica una compuerta de aprobación humana en toda arista que la alcanza —incluso en un grafo cuyo autor nunca pidió una— y sella el efecto. CI lo demuestra contra un binario real en cada push.
Ver el ejemplo funcionandoimport { createNode } from "@deepaxiom/aura";
const aura = createNode({ org: "acme", app: "shop" });
aura.expose("get-order", ({id}) => db.orders.find(id), { params: ["id"] });
aura.expose("refund-order", ({id}) => db.orders.refund(id), { params: ["id"], write: true });
await aura.start();
// write:true → motor capability → gated on every edge → sealedUn servidor MCP: cada skill es una herramienta para Claude Code o Cursor, y `tools/call` transmite en streaming. Un cliente MCP en sentido inverso, para que servidores externos se vuelvan skills.
`aura connect --openapi` convierte cada operación en una skill. Solo lectura por defecto, con simulación y promoción por operación antes de que algo escriba.
Exportación OpenTelemetry del árbol causal, tarjeta de descubrimiento A2A, webhooks de entrada, y skills de inversión de control que marcan hacia afuera para correr tras NAT sin puertos entrantes.
Federa un nodo y empieza a resolver capacidades que físicamente viven en otra parte, con causalidad y cancelación intactas al cruzar la frontera.
Cómo se compara
Las herramientas de flujo automatizan lotes desde fuera de tu código. Los frameworks de agentes te dan un bucle y le dejan la seguridad al desarrollador. Ninguno se construyó para responder «demuestra qué hizo» — y eso no es una función que se agrega después.
Esto compara diseños, no es un benchmark. Los frameworks de agentes hacen cosas que AURA no hace — un ecosistema de herramientas mucho más grande y una curva de madurez de años de ventaja. Elige este cuando tengas que responder por lo que hizo el agente.
Qué hace realmente el runtime
No son eslóganes. Cada uno es una restricción contra la que se mide el código en cada push.
El primer comando útil no es «crea un proyecto», es «conecta lo que ya tienes». Apúntalo a una especificación OpenAPI y sus operaciones se vuelven skills, de solo lectura por defecto, con las escrituras tras aprobación humana.
La unidad de comunicación es un stream tipado, causal y con contrapresión, no una llamada a función. El texto fluye token a token; la misma primitiva lleva audio, documentos y eventos.
LLMs, ASR, OCR, TTS y embeddings viven tras una sola interfaz, local o remota. El mismo grafo lógico corre en una laptop o se reparte en una flota cambiando solo dónde se colocan las skills.
La especificación y los SDKs son Apache-2.0 para siempre, el registro es federable y cualquiera puede alojar uno. Bifurcar el estándar siempre es trivial — eso es lo que hace creíble la neutralidad en vez de prometida.
Construye y distribuye
Las skills se distribuyen por un registro federable — cualquiera aloja uno, igual que un registro de contenedores. Versiones inmutables, vinculación del publicador por confianza en el primer uso, y una revisión de permisos antes de que algo aterrice. Todo impuesto y probado.
Figura 7
Tu skill
un manifiesto, código, dependencias
aura publish
comprime + firma (Ed25519) + sube
Un registro que tú alojas
versiones inmutables / confianza al primer uso
aura add --capability
descubre por función, no por nombre
Cualquiera aloja un registro, igual que uno de contenedores. Eso es lo que hace la neutralidad comprobable en vez de prometida.
Una skill es un directorio: un manifiesto, código, dependencias. El SDK maneja conexión, causalidad, idempotencia y descubrimiento de credenciales. La skill funcional más pequeña son unas 100 líneas — parte de `skills/echo/` y reemplázala.
Lee la guía del SDK`aura publish` comprime, firma (Ed25519) y sube. `aura add --capability` descubre por función, no por nombre. Republicar una versión con contenido distinto se rechaza, y una versión posterior firmada con otra clave no puede secuestrar un id de paquete.
Explora las skills de ejemploUna skill que escribas y vendas no carga obligación de copyleft, nunca. El kernel es AGPL-3.0-or-later para que un proveedor de nube no pueda tomarlo, alojarlo y revendérselo a tus usuarios sin contribuir — con licencia comercial disponible para quien quiera otros términos.
Lee el mapa de licenciasDónde está parado, honestamente
Esto es pre-1.0 y pre-producción. Todos los proyectos dicen que sus huecos son pequeños; aquí están listados, y la misma lista está en el roadmap del repositorio, donde es más difícil borrarla en silencio.
Sobres en streaming con QoS por arista sobre WebSocket y QUIC · la bitácora y su verificación sin conexión · la compuerta como invariante del kernel · identidad firmada del aprobador · credenciales de skill con alcance · el broker de credenciales · el log publicado del propio testigo · cancelación · reanudación de sesión · replay determinista · regresión a nivel de efecto · reportes de auditoría por periodo que se verifican solos · puertos tipados con gramáticas de decodificación compiladas · la frontera MCP en ambos sentidos · `aura guard` · skills Wasm en un sandbox real · CDC de Postgres · rotación y recuperación del log de eventos.
Voz con barge-in · el planificador (`aura do`) · `aura why` · exportación OpenTelemetry · ML-BOM.
Sin failover si el nodo muere — un proceso, y el estado vivo de ruteo se va con él · sin vista multidispositivo de una misma sesión en vivo · la evidencia TEE llega a `bound`, nunca a `verified` · los SDKs están empaquetados pero sin publicar · no hay procedimiento documentado de respaldo/restauración, ni para rotar la clave del nodo.
Una skill `format: source` no está contenida. `--sandbox process` limpia su entorno, encierra su directorio de trabajo y verifica la salida declarada antes de arrancar, lo que detiene fugas accidentales de credenciales y paseos casuales por el sistema de archivos. No detiene código hostil en absoluto. `format: wasm` sí está genuinamente aislado, en un sandbox WASI real. Una frontera real para skills de código fuente significa una microVM, que se declara y se rechaza al arrancar en vez de degradarse en silencio. Hoy la propuesta honesta del registro es publica y aloja lo tuyo — no instales código de desconocidos.
Una suite de 59 comprobaciones de conformidad corre el kernel sobre el cable. Trabajos separados demuestran que la bitácora detecta manipulación editando una base de datos real a espaldas de un binario real, que un token con alcance no puede actuar como el operador, que el contenedor arranca sano sobre un volumen vacío y drena con SIGTERM, y que un nodo arrancado con su autenticación por defecto puede manejarse de extremo a extremo — esto último existe porque todas las demás vías arrancan su nodo con `--no-auth`, y tres bugs de credenciales se colaron por ese hueco.
Figura 8
| internal/approvals | 97.6% |
| internal/channel | 97.5% |
| internal/signing | 90.4% |
| internal/executor | 84.2% |
| internal/seglog | 83.2% |
| internal/ledger | 75.3% |
| internal/projection | 58.6% |
| internal/gateway | 54.1% |
| internal/store | 53.7% |
| cmd/aura | 8.8% |
Publicada porque las partes delgadas son las interesantes. cmd/aura es parseo de argumentos y formato de salida sobre lógica probada donde vive: el atípico honesto, y de bajo riesgo.
Preguntas que la gente hace de verdad
AURA es un kernel de runtime cognitivo de código abierto: un solo binario que corre cargas de IA en tiempo real como grafos de skills tipadas y en streaming. Toda acción que toca el mundo se detiene ante una aprobación humana que impone el kernel, y queda sellada en una bitácora de efectos encadenada por hash que un tercero puede verificar sin conexión. Corre local, sin cuenta, sin nube y sin base de datos.
Esos son librerías con las que construyes un bucle de agente dentro de tu proceso. AURA es un runtime al que tus skills se conectan. La diferencia práctica es dónde vive la seguridad: en un framework la interrupción de aprobación humana es código que escribiste, así que el código que la olvida no tiene compuerta. En AURA el ejecutor aplica la compuerta en el único punto por el que pasa toda entrega, guiado por una política de nodo que un grafo no puede debilitar. La segunda diferencia es la evidencia: un framework te da trazas, AURA te da un registro firmado y encadenado por hash que se verifica con el runtime apagado.
Produce la evidencia que piden los artículos 12 y 14 —registro automático de eventos durante la vida del sistema, y supervisión por una persona física identificable— pero no hace que un despliegue sea conforme. AURA emite registros; no realiza una evaluación de conformidad, y ninguna herramienta puede. El régimen de alto riesgo aplica desde el 2 de diciembre de 2027 para sistemas autónomos del Anexo III tras el aplazamiento del Ómnibus Digital. La cláusula 9.2 de ISO/IEC 42001 pide una cadena de evidencia comparable y está vigente hoy.
Sí, y es la vía de entrada más rápida. `aura guard --config <tu-config-mcp.json>` pone tus servidores MCP existentes tras un punto de control sin levantar ningún runtime: cada llamada a herramienta pasa por una política que tú controlas, se detiene ante un humano si actúa sobre el mundo, y aterriza en la bitácora. Las herramientas se bloquean salvo que su servidor demuestre que solo leen y tú elijas explícitamente creerle a esa anotación. AURA también es servidor MCP en el otro sentido, así que cada skill se vuelve una herramienta para Claude Code o Cursor.
No — es pre-1.0 y lo dice en todas partes. El hueco bloqueante es el failover: un nodo es un proceso, y si muere el log de eventos sobrevive pero el estado vivo de ruteo no. La prueba honesta es si tu app se degrada o se detiene cuando AURA se cae. Si se degrada, hoy es desplegable como servicio auxiliar. Si se detiene, lee primero el roadmap. Tampoco hay todavía sandbox microVM para skills en formato código fuente.
No. `aura up` es todo el runtime: kernel, UI del plano de control, almacén de estado, bitácora y cliente de testigo en un binario de unos 18.6 MB, sin CGO y sin servicios externos. Los modelos pueden ser archivos GGUF totalmente locales, o cualquier endpoint compatible con OpenAI si prefieres un modelo alojado. Nada llama a casa.
Significa que `aura verify` lee la bitácora directo del archivo de base de datos y recomputa la cadena de hashes, el árbol Merkle RFC 6962 y cada firma de checkpoint y de aprobación — sin que corra el nodo que la escribió y sin confiar en ese proceso. También te dice el límite de lo que probó: verificar contra la clave del propio nodo establece que nadie alteró la bitácora sin la clave, no que el poseedor de la clave no lo hizo. Anclar con un testigo externo es lo que cierra eso.
Texto, audio, documentos y eventos viajan como el mismo sobre tipado. Un nodo sirve QUIC (WebTransport) en el mismo número de puerto que su listener TCP, así que tres clases de QoS se vuelven tres primitivas reales de transporte: `realtime` es un datagrama que no puede atascar ni ser atascado, `reliable` es un stream ordenado por arista, y `bulk` recibe el suyo. Las skills de abajo reaccionan a media frase en vez de esperar la respuesta completa, y el barge-in funciona porque está garantizado que la salida de una cadena cancelada no llega a ningún lado.
La especificación y los SDKs son Apache-2.0 para siempre, así que una skill que escribas y vendas no carga obligación de copyleft. El kernel, la UI del plano de control y las skills de primera parte son AGPL-3.0-or-later, que solo se activa cuando ofreces un kernel modificado a terceros por red — autoalojarlo, modificarlo y correrlo dentro de tu propia organización no obliga a publicar nada. Una licencia comercial reemplaza los términos AGPL para quien la quiera.
Python y TypeScript/Node tienen SDKs de primera parte hoy, y una skill no es más que un proceso hablando el protocolo de canal C3 sobre un WebSocket — así que cualquier lenguaje capaz de abrir un socket y parsear JSON puede implementar una. La suite de conformidad es de caja negra y habla el protocolo crudo, así que un SDK en un lenguaje nuevo puede demostrarse contra las mismas 59 comprobaciones que pasa el kernel.
60 segundos, por la ruta larga
Go 1.25+, sin CGO, sin servicios externos. Un binario es el kernel, la UI del plano de control, el almacén de estado, la bitácora y el cliente de testigo. Sin cuenta, sin lista de espera, sin nada que registrar.
$ git clone https://github.com/DeepAxiom/deepaxiom_aura && cd deepaxiom_aura/kernel
$ go build -o aura ./cmd/aura # Go 1.25+, no CGO
$ ./aura up # kernel, UI, store, ledger, witness
aura 0.3.0 — kernel up
ui http://localhost:9080
ledger 0 effect(s) sealed · 0 checkpoint(s)Un nodo nuevo es un kernel funcional con catálogo vacío y cuatro grafos precargados —`echo`, `chat`, `plan` y `voice`— a los que apuntar una skill.