DOS Kernel

DOS — el Sistema Operativo de Despacho

Atrapa a tus agentes de IA cuando mienten sobre lo que entregaron.

📊 Míralo funcionar en repos reales: el marcador puntúa 15 repos populares construidos con IA (roborev, open-interpreter, crewAI, autogen, …) — cuánto escribieron los agentes, cuáles, y si la afirmación de cada commit está respaldada por su propio diff. Puntúa el tuyo: dos commit-audit --sweep --workspace . BASE..HEAD.

Toda la propuesta en una grabación: el agente afirma que dos funciones se entregaron; git respalda una. dos verify responde desde los commits, la mentira sale con 1, y una compuerta sobre ese código de salida rechaza el falso "hecho". Cada línea es la salida textual del CLI real — scripts/build_caught_lie_cast.py la vuelve a grabar cada vez que la salida cambia.

Ejecuta una flota de agentes en un solo repo. El bucle izquierdo solo parece progreso; el derecho puedes dirigirlo. La única diferencia es un veredicto que DOS lee del mundo real — aquí, git — nunca de la palabra del agente.

Un agente de IA te dirá que terminó. DOS verifica el mundo real en lugar de creerle a su palabra — y la pieza más cercana del mundo real es tu historial de git. Un agente dice que entregó el endpoint de login; ¿lo hizo? Ejecuta un comando, dos verify, y responde desde los artefactos que el trabajo dejó atrás, no desde lo que el agente escribió: un commit respalda la afirmación → SHIPPED, salida 0; nada aterrizó → NOT_SHIPPED, salida 1. La historia del agente nunca entra en juego. (Git es solo el primer testigo que DOS lee; el árbol de archivos, el reloj, un estado de CI, el estado propio de un entorno de prueba son otros — cualquier cosa que el agente no haya creado.)

dos verify AUTH AUTH1   # → SHIPPED      AUTH AUTH1 e62f74d   (exit 0)
dos verify AUTH AUTH2   # → NOT_SHIPPED  AUTH AUTH2           (exit 1)

Esa es la versión más pequeña. También escala: apunta a una docena de agentes a un solo repo — en CI, en una flota, compitiendo sobre los mismos archivos — y DOS también te dice cuáles se están pisando entre sí, cuál está girando en círculos, y qué afirmación de "hecho" es real. Cada respuesta viene de los artefactos (git, el árbol de archivos, el reloj), nunca de la narración. Funciona en un repo git simple con cero configuración y se vuelve más inteligente cuanto más le cuentas, y lo único que instalas es un pequeño paquete de Python.

Configuración — usa DOS en tu repo

DOS es un paquete de Python que instalas dentro del repo git existente donde tus agentes trabajan. No necesitas clonar ni bifurcar el código fuente de DOS a menos que planees desarrollar DOS tú mismo.

cd path/to/your-repo
pip install dos-kernel
dos init --hooks auto   # detects the agent runtime(s) already in this repo
dos doctor              # shows exactly what this workspace is using

A partir de entonces, tu agente no puede decirte "hecho" a menos que el trabajo realmente haya aterrizado, dos agentes no pueden sobrescribir silenciosamente los archivos del otro, y una ejecución que se detiene se marca en lugar de girar silenciosamente. dos init imprime la configuración y las entradas de hook que escribió; eliminar esas entradas generadas deshace la configuración. Si no se detecta un runtime, lo dice y lista las opciones explícitas — nunca adivina.

_{v0.30.0 · más de 5,600 pruebas · CI: Python 3.11–3.13 en Linux + una ejecución de humo en Windows 3.13 · la única dependencia de runtime es PyYAML · MIT.}

🧭 A dónde ir después: el porqué y la evidencia (la historia en palabras simples, la respuesta de 20 líneas de bash, lo que está probado), conéctalo a tu stack (MCP · hooks · instalación), la referencia de syscall + CLI, o, ¿lo lees como agente de IA?, AGENTS.md — build/test/check en tres líneas. El mapa completo es el router justo debajo.

🔤 Cinco palabras en las que se apoya el resto de esta página. Un plan es un objetivo con nombre (AUTH); una fase es un paso entregable de él (AUTH1); un carril es la porción del árbol de archivos que un agente puede tocar; el oráculo es la parte de DOS que lee la evidencia y dictamina; un sello es la marca que una fase entregada deja en el asunto de un commit (AUTH1: …) — lo que el oráculo busca con grep. Ese es todo el vocabulario.

En palabras simples

Un agente de codificación hace trabajo, luego te cuenta cómo fue. Normalmente la historia es verdadera; a veces es el alegre "¡todo el trabajo completado!" de un trabajador que no entregó nada. Con un agente lo detectas tú mismo al releer su salida — un impuesto real que ya pagas. Ejecuta veinte a la vez y ese impuesto deja de ser pagable: nadie lee todo, cada trabajador califica su propia tarea, y los problemas no verificados se acumulan silenciosamente hasta que el código más o menos funciona y nadie puede cambiarlo con seguridad. DOS es el árbitro que nunca lee la historia — lee lo que sucedió (el commit, el archivo, el reloj) y te entrega un veredicto que ninguna narración puede mover. Cuesta aproximadamente una tarde, tiene una dependencia de runtime, y se mantiene en su carril: te dice qué sucedió, nunca si el código es bueno — la calidad se queda con tus pruebas y revisiones. (La versión completa en palabras simples.)

Medido, no afirmado

Cada número aquí se puntúa contra un hecho que el agente no puede falsificar (el estado de la base de datos de un entorno de prueba, el historial de git). Una compuerta de DOS atrapó 15 mentiras de "lo entregué" en 258 tareas en dos modelos con cero falsas alarmas; el mismo árbitro detuvo 6 de 8 colisiones silenciosas en un registro compartido; terminar ejecuciones condenadas en el momento correcto ahorró ~11% del cómputo de la flota con 0 de 1,634 ganadores eliminados por error; y la etiqueta de admisión del conjunto de recompensas elevó la precisión de aceptación 60% → 100% al purgar el veneno que un recolector autocalificado mantiene. La metodología, las dos figuras del momento clave, y el gradiente de honestidad proyectado-vs-apostado están en lo que está probado y lo que sigue siendo una apuesta.

Dónde está el resto de la documentación

Esta página mantiene el gancho, la demo, y el fallo que corrige. Todo lo más profundo vive en una página enfocada — encuentra la pregunta con la que llegaste y salta:

Demo opcional — pruébalo en 60 segundos

¿Tienes una terminal? Esto ejecuta todo en un repo desechable — un comando lo prepara, hace un commit real, lo verifica, y limpia después de sí mismo:

pip install dos-kernel      # PyYAML is the only runtime dep
dos quickstart              # → SHIPPED AUTH AUTH1 … then NOT_SHIPPED AUTH AUTH2

Un SHIPPED, un NOT_SHIPPED: el primero es una afirmación que git puede respaldar, el segundo es una afirmación para la que nada aterrizó. Ese contraste es el producto. La demo cierra con un router hacia donde ya ejecutas agentes — una pestaña de Claude Code / Cursor (dos init --hooks), un host MCP, un paso de CI, o una flota — para que tu próximo movimiento sea una línea, no una búsqueda en la documentación. (Agrega --keep ./demo para conservar el repo y explorarlo. ¿Ni siquiera quieres la instalación? uvx --from dos-kernel dos quickstart ejecuta la misma demo de forma efímera — no deja nada atrás.) Lo mismo a mano, en cinco líneas, está en docs/QUICKSTART.md.

_{Dos afirmaciones igualmente confiadas, un veredicto para cada una — SHIPPED para la que git puede respaldar, NOT_SHIPPED para la que nada aterrizó. Cada cadena es la salida textual de examples/demo/verify_demo.sh. Recórrelo localmente paso a paso para la versión clicable (es un archivo HTML — clona el repo y ábrelo en un navegador; GitHub muestra su fuente, no la página en ejecución).}

La victoria real más pequeña: en un paso de CI o un bucle de despacho, reemplaza la línea que confía en el "hecho" de un agente con dos verify PLAN PHASE y ramifica según su código de salida (0 entregado / 1 no). Sin análisis, sin plan, sin configuración — el libro de cocina de integración con CI lo recorre de principio a fin. Para ejecutarlo en un repo con la forma del tuyo, comienza con Integra un repo en 10 minutos.

Apunta al mismo testigo a una cola de revisión cuando los commits se acumulan más rápido de lo que alguien puede leerlos. Revisión residual pliega el veredicto por commit de commit-audit en tres bandas — CLEARED (el diff fue testigo de la afirmación, así que gasta ~0 atención en volver a preguntar "¿hizo lo que dijo?"), RESIDUAL (una afirmación que git no pudo respaldar — el 100% del humano), y el resto sin afirmación. En los últimos 200 commits de este propio repo, despejó 170 de 171 afirmaciones verificables: esa es la re-revisión que te saltas, probada por git en lugar de la puntuación de confianza de un modelo. (CLEARED significa que la forma del cambio coincidió con su afirmación — no que el código sea correcto; la revisión de corrección aún aplica a cada commit. La banda solo puede pedir más ojos, nunca menos.)

Siguiente nivel — conecta el veredicto a tu propio stack: Conéctalo.

Qué sale mal en una flota

Ejecuta un montón de agentes a la vez sin nadie que arbitre, y así es como va: cada trabajador reporta su propio éxito, y crees los reportes, porque ¿qué más hay para guiarte? Los problemas no verificados se acumulan silenciosamente — una mentira aquí, dos agentes pisando el mismo archivo allá, un poco de expansión de alcance, un trabajador girando en círculos — hasta que el código más o menos funciona y nadie puede cambiarlo con seguridad.

El problema es que lanzaste los agentes y luego los dejaste calificar su propia tarea. DOS te da la señal que falta — un veredicto desde la verdad del terreno — para que el bucle se cierre. Aquí está la misma flota bajo ambos regímenes:

flowchart LR
  subgraph OPEN["NO REFEREE — you believe the narration"]
    direction TB
    A1["agent: 'done!'"] --> B1[["believed"]]
    A2["agent: 'done!'"] --> B1
    A3["agent: 'done!'"] --> B1
    B1 --> C1["silent corruption piles up<br/>(lies · collisions · spin)"]
    C1 --> D1["'sorta works' — can't be changed"]
  end
  subgraph CLOSED["DOS ADJUDICATES — you steer on a verdict"]
    direction TB
    A4["agent: 'done!'"] --> V{{"dos verify<br/>reads git"}}
    V -->|in git ancestry| S["SHIPPED (exit 0)"]
    V -->|found nowhere| N["NOT_SHIPPED (exit 1)"]
    S --> L["land it"]
    N --> R["re-dispatch / flag — caught"]
    R -.verdict steers the loop.-> A4
  end

Aquí están los fallos que una flota realmente produce, cada uno junto a la verdad del terreno que contradice silenciosamente la historia del trabajador — y el veredicto que DOS devuelve:

La primera fila es la más común. La señal clásica es una línea alegre de una sola frase, "¡todo el trabajo completado!", de un trabajador que hizo poco o nada. DOS nunca lee esa línea; lee la verdad de fondo, así que la afirmación se derrumba en el instante en que ningún artefacto la respalda (más en docs/108). Eso también es lo que lo hace barato de adoptar: verify no necesita plan, ni registro, ni configuración, y el código de salida es el veredicto — cualquier shell o paso de CI puede ramificar según él sin analizar una palabra.

_{¿Prefieres verlo en movimiento? Los dos bucles también son una animación autocontenida que recorres fotograma a fotograma — clona el repositorio y abre docs/assets/loop_visual.html en un navegador. (Es un archivo HTML, así que GitHub muestra su fuente en lugar de ejecutarlo — ábrelo localmente).}

Alcance del arrendamiento — un solo sistema de archivos hoy. La mitad de verificación (verify, commit-audit, liveness) viaja entre máquinas libremente porque lee el historial de git. La mitad de admisión (arbitrate, arrendamientos de carril) es solo de sistema de archivos local: el WAL vive en un disco, y los trabajadores en máquinas separadas no comparten ningún punto de serialización. Una flota que ejecuta todos sus trabajadores en una máquina o en un sistema de archivos compartido está completamente cubierta; una flota que abarca múltiples hosts debería tratar dos arbitrate como consultivo (no como un mutex estricto) hasta que un controlador de arrendamiento remoto se publique. Ver docs/366 para el diseño.

Hasta dónde lo llevas

Funciona en un git init simple con cero configuración, y se vuelve más inteligente cuanto más le cuentas. No adoptas un marco y eliges un nivel; empiezas en el extremo superficial y sigue dando frutos a medida que te adentras — el mismo núcleo en todo el camino:

• Cero configuración. Apunta dos verify PLAN PHASE a un repositorio git simple — sin plan, sin registro, sin dos.toml. Responde solo desde el historial de commits (via grep-subject / via none). Esto es todo el QUICKSTART y la victoria de CI del primer día mencionada arriba.
• Cuéntale tu estructura. dos init escribe un dos.toml (carriles, rutas, gramática de envío como datos); añade un documento de plan y dos plan coloca la afirmación de cada fase junto al veredicto del oráculo. Aquí está exactamente cómo se ve un archivo de plan (copiable, con ida y vuelta con el lector integrado), y cuatro ejemplos de espacios de trabajo trabajados.
• Enséñale tus propios tipos. Declara tus propias razones de bloqueo, veredictos de compuerta, renderizadores de salida, predicados de admisión, un juez respaldado por modelo, un dialecto de plan personalizado, o un controlador de host completo — todo como política del espacio de trabajo, nunca un fork. El mapa es docs/HACKING.md (siete ejes de extensión) + el copiable examples/dos_ext/.

Cómo lo conectas

Esa pendiente es cuán profunda llega tu configuración. El otro eje es cómo llamas al árbitro en absoluto — y adoptas a través de la superficie que coincida con cómo ya trabajas, no reestructurando tu pila. Los mismos veredictos del núcleo son alcanzables a través de cada fila aquí, de menor fricción primero:

Los dos ejes son independientes: un repositorio de cero configuración puede adoptar a través de cualquier superficie, y uno profundamente configurado aún responde a través de las mismas herramientas CLI y MCP. Empieza en la fila superior — es la que no cuesta nada probar. Las dos primeras filas también se componen: MCP aconseja (el agente verifica su propio trabajo), los hooks hacen cumplir (el host detiene una mala acción) — conecta ambas para el bucle completo.

Esas superficies son la mitad aguas arriba de la cadena de valor — quién llama al árbitro. Los mismos veredictos también fluyen aguas abajo, hacia los sistemas que actúan sobre ellos: cada adjudicación aterriza en un diario de veredictos que dos export drena hacia tu pila de observabilidad (Datadog / Honeycomb / Grafana — docs/266), dos notify empuja lo-que-necesita-un-humano a Slack, dos reward compuerta lo que un ajuste fino puede entrenar, y dos attest acuña un recibo firmado que un escéptico puede verificar sin acceso al bucle (docs/246). Un núcleo, un vocabulario de veredictos, desde la llamada de herramienta del agente hasta tu panel.

Siguiente nivel — ejecútalo todos los días: Operando una flota.

Del mismo equipo

DOS es una de tres herramientas abiertas de Anthony Chaudhary para ejecutar agentes de IA en los que realmente puedes confiar — en tres momentos diferentes:

• fak — el núcleo de agente — DOS lee lo que un agente ya hizo (después del hecho, desde git y otros testigos que no puede falsificar); fak gobierna lo que un agente tiene permitido hacer mientras sucede. Un único binario estático de Go que se sitúa frente a tu motor de tokens y adjudica cada llamada de herramienta en el límite — compuerta de capacidad, cuarentena de resultados de herramientas, rastro de auditoría — la compuerta en línea al árbitro fuera del bucle de DOS. go install github.com/anthony-chaudhary/fak/cmd/fak@latest · docs.
• Diffgram — el almacén de datos de IA para la supervisión humana de datos de IA (etiquetado, flujo de trabajo, catálogo). Donde DOS y fak supervisan a los agentes, Diffgram supervisa los datos de los que aprenden y que producen.

Cita

Las ideas aquí están escritas en un artículo — "Verification Is All You Need — But Not Where You Think" — sobre el árbitro fuera del bucle para flotas de agentes. Un PDF construido vive en paper/releases/; la preimpresión de arXiv está en preparación. Hasta que el ID de arXiv se publique, cita el repositorio:

@misc{dos_kernel,
  title        = {Verification Is All You Need --- But Not Where You Think},
  author       = {Chaudhary, Anthony},
  howpublished = {\url{https://github.com/anthony-chaudhary/dos-kernel}},
  note         = {DOS --- the Dispatch Operating System; arXiv preprint in preparation},
  year         = {2026}
}

Licencia

MIT — ver LICENSE.