DOS Kernel

DOS — o Sistema Operacional de Despacho

Pegue seus agentes de IA quando eles mentem sobre o que entregaram.

📊 Veja funcionando em repositórios reais: o placar pontua 15 repositórios populares construídos por IA (roborev, open-interpreter, crewAI, autogen, …) — quanto os agentes escreveram, quais deles, e se a alegação de cada commit é respaldada pelo próprio diff. Pontue o seu: dos commit-audit --sweep --workspace . BASE..HEAD.

Toda a proposta em uma gravação: o agente alega que dois recursos foram entregues; o git respalda um. dos verify responde a partir dos commits, a mentira sai com 1, e uma trava nesse código de saída recusa o falso "concluído". Cada linha é a saída verbatim da CLI real — scripts/build_caught_lie_cast.py a regrava sempre que a saída muda.

Execute uma frota de agentes em um repositório. O loop à esquerda apenas parece progresso; o da direita você pode direcionar. A única diferença é um veredito que o DOS lê do mundo real — aqui, o git — nunca da palavra do agente.

Um agente de IA vai te dizer que terminou. O DOS verifica o mundo real em vez de aceitar a palavra dele — e a peça mais próxima do mundo real é o seu histórico do git. Um agente diz que entregou o endpoint de login; entregou? Execute um comando, dos verify, e ele responde a partir dos artefatos que o trabalho deixou para trás, não do que o agente digitou: um commit respalda a alegação → SHIPPED, saída 0; nada foi entregue → NOT_SHIPPED, saída 1. A história do agente nunca entra nisso. (O git é apenas a primeira testemunha que o DOS lê; a árvore de arquivos, o relógio, um status de CI, o estado de um ambiente de teste são outras — qualquer coisa que o agente não tenha criado.)

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

Essa é a versão mais simples. Ela também escala: aponte uma dúzia de agentes para um repositório — em CI, em uma frota, competindo nos mesmos arquivos — e o DOS também diz quais estão pisando uns nos outros, qual está girando em círculos, e qual alegação de "concluído" é real. Cada resposta vem dos artefatos (git, a árvore de arquivos, o relógio), nunca da narração. Funciona em um repositório git simples com zero configuração e fica mais inteligente quanto mais você o informa, e a única coisa que você instala é um pequeno pacote Python.

Configuração — use o DOS no seu repositório

O DOS é um pacote Python que você instala no repositório git existente onde seus agentes trabalham. Você não precisa clonar ou bifurcar o código-fonte do DOS, a menos que planeje desenvolver o próprio DOS.

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 daí, seu agente não pode te dizer "concluído" a menos que o trabalho realmente tenha sido entregue, dois agentes não podem sobrescrever silenciosamente os arquivos um do outro, e uma execução que trava é sinalizada em vez de girar silenciosamente. dos init imprime a configuração e as entradas de hook que escreveu; remover essas entradas geradas desfaz a configuração. Se nenhum runtime for detectado, ele avisa e lista as escolhas explícitas — nunca adivinha.

_{v0.30.0 · 5.600+ testes · CI: Python 3.11–3.13 no Linux + um teste rápido de fumaça no Windows 3.13 · a única dependência de runtime é PyYAML · MIT.}

🧭 Para onde ir agora: o porquê e evidências (história em palavras simples, a resposta de 20 linhas de bash, o que está comprovado), integre à sua stack (MCP · hooks · instalação), a referência de syscall + CLI, ou, lendo isto como um agente de IA?, AGENTS.md — build/teste/verificação em três linhas. O mapa completo é o roteador logo abaixo.

🔤 Cinco palavras nas quais o resto desta página se apoia. Um plano é uma meta nomeada (AUTH); uma fase é um passo entregável dele (AUTH1); uma pista é a fatia da árvore de arquivos que um agente pode tocar; o oráculo é a parte do DOS que lê as evidências e decide; um carimbo é a marca que uma fase entregue deixa no assunto de um commit (AUTH1: …) — a coisa que o oráculo procura. Esse é todo o vocabulário.

Em palavras simples

Um agente de codificação faz o trabalho e depois conta como foi. Normalmente a história é verdadeira; às vezes é o alegre "todo o trabalho concluído!" de um trabalhador que não entregou nada. Com um agente, você percebe isso sozinho relendo a saída dele — um custo real que você já paga. Execute vinte de uma vez e esse custo deixa de ser pagável: ninguém lê tudo, cada trabalhador avalia o próprio dever de casa, e os problemas não verificados se acumulam silenciosamente até o código mais ou menos funcionar e ninguém conseguir alterá-lo com segurança. O DOS é o árbitro que nunca lê a história — ele lê o que aconteceu (o commit, o arquivo, o relógio) e entrega um veredito que nenhuma narração pode mover. Custa cerca de uma tarde, tem uma dependência de runtime e fica na sua pista: ele diz o que aconteceu, nunca se o código é bom — a qualidade continua com seus testes e revisões. (A versão completa em palavras simples.)

Medido, não afirmado

Cada número aqui é pontuado contra um fato que o agente não pode falsificar (o estado do banco de dados de um ambiente de teste, o histórico do git). Uma trava do DOS pegou 15 mentiras de "eu entreguei" em 258 tarefas em dois modelos com zero alarmes falsos; o mesmo árbitro impediu 6 de 8 colisões silenciosas em um registro compartilhado; encerrar execuções condenadas no momento certo economizou ~11% do compute da frota com 0 de 1.634 vencedores mortos erroneamente; e o rótulo de admissão do conjunto de recompensas elevou a precisão de aceitação 60% → 100% ao eliminar o veneno que um coletor autoavaliado mantém. A metodologia, as duas figuras do momento-chave e o gradiente de honestidade projetado-vs-apostado estão em o que está comprovado e o que ainda é uma aposta.

Onde está o resto da documentação

Esta página mantém o gancho, a demonstração e a falha que ela corrige. Tudo mais profundo vive em uma página focada — encontre a pergunta com a qual você chegou e pule:

Demonstração opcional — experimente em 60 segundos

Tem um terminal? Isso executa tudo em um repositório descartável — um comando cria a estrutura, faz um commit real, verifica e limpa depois de si:

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

Um SHIPPED, um NOT_SHIPPED: o primeiro é uma alegação que o git pode respaldar, o segundo é uma alegação para a qual nada foi entregue. Esse contraste é o produto. A demonstração termina com um roteador para onde quer que você já execute agentes — uma aba Claude Code / Cursor (dos init --hooks), um host MCP, uma etapa de CI ou uma frota — para que seu próximo passo seja uma linha, não uma escavação em docs. (Adicione --keep ./demo para manter o repositório e explorá-lo. Não quer nem a instalação? uvx --from dos-kernel dos quickstart executa a mesma demonstração de forma efêmera — nada fica para trás.) A mesma coisa manualmente, em cinco linhas, está em docs/QUICKSTART.md.

_{Duas alegações igualmente confiantes, um veredito para cada — SHIPPED para a que o git pode respaldar, NOT_SHIPPED para a que nada foi entregue. Cada string é a saída verbatim de examples/demo/verify_demo.sh. Percorra localmente para a versão clicável (é um arquivo HTML — clone o repositório e abra em um navegador; o GitHub mostra o código-fonte, não a página em execução).}

A menor vitória real: em uma etapa de CI ou loop de despacho, substitua a linha que confia no "concluído" de um agente por dos verify PLAN PHASE e ramifique no código de saída dele (0 entregue / 1 não). Sem parsing, sem plano, sem configuração — o livro de receitas de integração com CI guia isso de ponta a ponta. Para executar em um repositório com o formato do seu, comece com Integre um repositório em 10 minutos.

Aponte a mesma testemunha para uma fila de revisão quando os commits se acumulam mais rápido do que qualquer um consegue ler. Revisão residual dobra o veredito por commit do commit-audit em três faixas — CLEARED (o diff testemunhou a alegação, então gaste ~0 atenção re-perguntando "fez o que disse"), RESIDUAL (uma alegação que o git não conseguiu respaldar — os 100% do humano), e o resto sem alegação. Nos últimos 200 commits deste próprio repositório, ele liberou 170 de 171 alegações verificáveis: essa é a re-revisão que você pula, comprovada pelo git em vez de uma pontuação de confiança de modelo. (CLEARED significa que o formato da mudança correspondeu à alegação — não que o código esteja correto; a revisão de correção ainda se aplica a cada commit. A faixa só pode pedir mais olhos, nunca menos.)

Próximo nível — integre o veredito à sua própria stack: Integre.

O que dá errado em uma frota

Execute um monte de agentes de uma vez sem ninguém arbitrando, e é assim que acontece: cada trabalhador relata o próprio sucesso, e você acredita nos relatos, porque o que mais há para se basear? Os problemas não verificados se acumulam silenciosamente — uma mentira aqui, dois agentes sobrescrevendo o mesmo arquivo ali, um pouco de expansão de escopo, um trabalhador girando em círculos — até o código mais ou menos funcionar e ninguém conseguir alterá-lo com segurança.

O problema é que você lançou os agentes e depois deixou que avaliassem o próprio dever de casa. O DOS dá o sinal que falta — um veredito da verdade fundamental — para que o loop se feche. Aqui está a mesma frota sob ambos os regimes:

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

Aqui estão as falhas que uma frota realmente produz, cada uma ao lado da verdade fundamental que contradiz silenciosamente a história do trabalhador — e o veredito que o DOS devolve:

A primeira linha é a mais comum. O sinal clássico é uma frase alegre de uma linha, "todo o trabalho concluído!", de um worker que fez pouco ou nada. O DOS nunca lê essa linha; ele lê a verdade real, então a afirmação desmorona no instante em que nenhum artefato a sustenta (mais em docs/108). Isso também é o que torna barato adotá-lo: verify não precisa de plano, registro, config, e o código de saída é o veredito — qualquer shell ou etapa de CI pode ramificar sem analisar uma palavra.

_{Prefere ver em movimento? Os dois loops também são uma animação autônoma que você percorre um quadro por vez — clone o repositório e abra docs/assets/loop_visual.html em um navegador. (É um arquivo HTML, então o GitHub mostra o código-fonte em vez de executá-lo — abra localmente.)}

Escopo do lease — apenas sistema de arquivos único hoje. A metade de verificação (verify, commit-audit, liveness) viaja entre máquinas livremente porque lê o histórico do git. A metade de admissão (arbitrate, leases de lane) é apenas para sistema de arquivos local: o WAL vive em um disco, e workers em máquinas separadas não compartilham ponto de serialização. Uma frota que executa todos os seus workers em uma máquina ou em um sistema de arquivos compartilhado está totalmente coberta; uma frota que abrange vários hosts deve tratar dos arbitrate como consultivo (não um mutex rígido) até que um driver de lease remoto seja lançado. Veja docs/366 para o design.

Até onde você leva

Funciona em um git init simples com zero config, e fica mais inteligente quanto mais você informa. Você não adota um framework e escolhe um nível; você começa na extremidade rasa e ele continua valendo a pena conforme você avança — o mesmo kernel o tempo todo:

• Zero config. Aponte dos verify PLAN PHASE para um repositório git simples — sem plano, sem registro, sem dos.toml. Ele responde apenas pelo histórico de commits (via grep-subject / via none). Isso é tudo do QUICKSTART e a vitória de CI do primeiro dia acima.
• Conte sua estrutura. dos init escreve um dos.toml (lanes, caminhos, gramática de envio como dados); adicione um documento de plano e dos plan coloca a afirmação de cada fase ao lado do veredito do oráculo. Aqui está exatamente como um arquivo de plano se parece (copiável, faz round-trip com o leitor integrado), e quatro exemplos de workspaces trabalhados.
• Ensine seus próprios tipos. Declare seus próprios motivos de bloqueio, vereditos de gate, renderizadores de saída, predicados de admissão, um juiz baseado em modelo, um dialeto de plano personalizado ou um driver de host inteiro — tudo como política do workspace, nunca um fork. O mapa é docs/HACKING.md (sete eixos de extensão) + o copie-me examples/dos_ext/.

Como você conecta

Essa inclinação é o quão profunda sua config vai. O outro eixo é como você chama o árbitro — e você adota por qualquer superfície que corresponda a como você já trabalha, não reestruturando sua stack. Os mesmos vereditos do kernel são alcançáveis por cada linha aqui, da menor fricção primeiro:

Os dois eixos são independentes: um repo de zero config pode adotar por qualquer superfície, e um profundamente configurado ainda responde pelas mesmas ferramentas CLI e MCP. Comece na linha do topo — é a que custa nada para tentar. As duas primeiras linhas também compõem: MCP aconselha (o agente verifica seu próprio trabalho), hooks impõem (o host para uma ação ruim) — conecte ambos para o loop completo.

Essas superfícies são a metade upstream da cadeia de valor — quem chama o árbitro. Os mesmos vereditos também fluem downstream, para os sistemas que agem neles: cada adjudicação cai em um diário de vereditos que dos export drena para sua stack de observabilidade (Datadog / Honeycomb / Grafana — docs/266), dos notify envia o que-precisa-de-um-humano para o Slack, dos reward faz gate do que um fine-tune pode treinar, e dos attest emite um recibo assinado que um cético pode verificar sem acesso ao loop (docs/246). Um kernel, um vocabulário de vereditos, da chamada de ferramenta do agente ao seu dashboard.

Próximo nível — execute diariamente: Operando uma frota.

Da mesma equipe

O DOS é uma das três ferramentas abertas de Anthony Chaudhary para executar agentes de IA em que você pode realmente confiar — em três momentos diferentes:

• fak — o kernel de agente — o DOS lê o que um agente já fez (depois do fato, de git e outras testemunhas que ele não pode forjar); fak governa o que um agente tem permissão para fazer conforme acontece. Um único binário Go estático que fica na frente do seu motor de tokens e adjudica cada chamada de ferramenta na fronteira — gate de capacidade, quarentena de resultado de ferramenta, trilha de auditoria — o gate inline para o árbitro fora do loop do DOS. go install github.com/anthony-chaudhary/fak/cmd/fak@latest · docs.
• Diffgram — o datastore de IA para supervisão humana de dados de IA (rotulagem, fluxo de trabalho, catálogo). Onde o DOS e fak supervisionam os agentes, o Diffgram supervisiona os dados que eles aprendem e produzem.

Citação

As ideias aqui estão escritas em um artigo — "Verification Is All You Need — But Not Where You Think" — sobre o árbitro fora do loop para frotas de agentes. Um PDF compilado está em paper/releases/; o preprint do arXiv está em preparação. Até o ID do arXiv ser publicado, cite o repositório:

@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}
}

Licença

MIT — veja LICENSE.