Enxames Sem Deriva: Como Contratos Tipados, Leases Atômicos e Revisões Cegas EGM Eliminam Bugs Multiagente

Por que enxames multiagente ingênuos sofrem deriva silenciosa de especificação, sobrescrevem arquivos concorrentes e alucinam builds verdes — e como o Benni-OS/conductor-sdd, o BenniAlencar/agent-run-ledger e o BenniAlencar/reality-lock impõem execução determinística sem deriva.

Enxames Sem Deriva: Contratos Tipados, Leases Atômicos e Revisões Cegas EGM

1. A Epidemia de Deriva e Split-Brain em Enxames Multiagente

Instanciar cinco agentes de código em paralelo impressiona em demonstrações, mas em repositórios de produção isso costuma desencadear três modos de falha combinados:

Tese Central: Enxames multiagente confiáveis não são um problema de engenharia de prompt — são um problema de sistemas distribuídos e verificação formal. Você elimina bugs de enxame combinando travas imutáveis de especificação (conductor-sdd), leases atômicos com fencing tokens (agent-run-ledger), revisões cegas sem contexto (Modelo Elefante-Peixinho) e recibos de verificação SHA-256 (reality-lock).

2. O Pipeline de Enxame Sem Deriva

No Benni OS, nenhum agente worker tem permissão para escrever código de produção a partir de um prompt solto. Toda missão de enxame atravessa quatro portões determinísticos antes que um único commit seja aceito:

flowchart LR A["1. Trava de Spec\n(conductor-sdd)"] -->|"Contrato SHA-256 Congelado"| B["2. Lease Atômico\n(agent-run-ledger)"] B -->|"Fencing Token + TTL"| C["3. Worker Isolado\n(Escopo Restrito)"] C -->|"Diff do Artefato"| D["4. Revisão Cega EGM\n(Goldfish Sem Contexto)"] D -->|"Contrato Aprovado"| E["5. Reality Lock\n(Recibo SHA-256)"] D -->|"Deriva Detectada"| B

Cada estágio impõe uma separação estrita de autoridade: o planejador não pode contornar o ledger de leases, o worker não pode alterar o contrato da spec e o revisor não pode enxergar as justificativas conversacionais do worker.


3. Camada 1: Travas de Especificação com Benni-OS/conductor-sdd

O Spec-Driven Development (SDD) inverte o fluxo típico de LLMs. Antes de qualquer worker ser instanciado, o conductor-sdd compila a decisão arquitetural, os tipos de interface e os invariantes de aceite em um artefato de especificação congelado e autenticado via SHA-256.

Cada worker recebe o spec_hash exato. Se um worker tentar alterar a assinatura de uma função, omitir um código de erro obrigatório ou introduzir uma dependência não aprovada, o detector de deriva dispara um erro SPEC_DRIFT_VIOLATION imediatamente.

{
  "spec_id": "swarm-billing-v2",
  "spec_hash": "sha256:9f84c2e1a7d04b518c2e3d901a77f45b...",
  "invariants": [
    "idempotency_key MUST be UUIDv4",
    "lease_ttl_seconds <= 120",
    "zero_unhandled_exceptions_on_timeout"
  ],
  "locked_interfaces": {
    "LedgerLease": ["lease_id", "owner_agent", "fencing_token", "expires_at"]
  }
}

4. Camada 2: Leases Atômicos e Fencing Tokens no BenniAlencar/agent-run-ledger

Quando múltiplos agentes operam em paralelo, a coordenação otimista de "torcer para ninguém editar o mesmo arquivo" falha sob retries ou respostas lentas de LLM. O agent-run-ledger resolve isso com leases atômicos tipados protegidos por fencing tokens monotonicamente crescentes.

Se o Worker A travar além do seu TTL e o ledger reatribuir a etapa ao Worker B com fencing_token = 42, qualquer gravação tardia do Worker A carregando fencing_token = 41 é rejeitada de forma determinística na fronteira do ledger.

from dataclasses import dataclass
from datetime import datetime, timezone, timedelta
from typing import Dict, Optional


@dataclass(frozen=True)
class AtomicLease:
    step_id: str
    owner_agent: str
    fencing_token: int
    spec_hash: str
    expires_at: datetime


class RunLedger:
    """Impõe propriedade de escritor único com fencing tokens monotônicos."""

    def __init__(self) -> None:
        self._leases: Dict[str, AtomicLease] = {}
        self._tokens: Dict[str, int] = {}

    def acquire_lease(
        self, step_id: str, agent_id: str, spec_hash: str, ttl_seconds: int = 60
    ) -> Optional[AtomicLease]:
        now = datetime.now(timezone.utc)
        current = self._leases.get(step_id)
        if current and current.expires_at > now and current.owner_agent != agent_id:
            return None  # Lease ativo detido por outro worker

        next_token = self._tokens.get(step_id, 0) + 1
        self._tokens[step_id] = next_token
        lease = AtomicLease(
            step_id=step_id,
            owner_agent=agent_id,
            fencing_token=next_token,
            spec_hash=spec_hash,
            expires_at=now + timedelta(seconds=ttl_seconds),
        )
        self._leases[step_id] = lease
        return lease

    def commit_step(self, step_id: str, fencing_token: int, receipt_hash: str) -> None:
        current = self._leases.get(step_id)
        if not current or current.fencing_token != fencing_token:
            raise PermissionError(
                f"Fencing token obsoleto {fencing_token} rejeitado para etapa {step_id}"
            )
        if datetime.now(timezone.utc) > current.expires_at:
            raise TimeoutError(f"Lease expirado para etapa {step_id}")
        # Persiste commit imutável com recibo de verificação SHA-256

5. Camada 3: Revisão Cega Sem Contexto com o Modelo Elefante-Peixinho (EGM)

Mesmo com uma spec travada e um lease atômico, o agente que escreveu 300 linhas de código carrega inércia contextual — ele se lembra do motivo pelo qual pegou um atalho e convence a si mesmo de que o atalho é seguro.

O Modelo Elefante-Peixinho (Elephant-Goldfish Model — EGM) quebra esse aprisionamento cognitivo dividindo a memória em dois papéis adversariais:

Como o Goldfish não possui memória da intenção do autor, ele avalia o código estritamente pelo que está gravado em disco — expondo deriva silenciosa de contrato, caminhos None desprotegidos e tratadores de erro ausentes em segundos.


6. Camada 4: Recibos de Verificação SHA-256 com BenniAlencar/reality-lock

O bug final em sistemas multiagente é a Falsa Declaração de Conclusão: um agente imprime "Todos os testes unitários passaram e o build está verde" sem realmente executar a suíte — ou após rodar apenas um subconjunto filtrado.

O BenniAlencar/reality-lock impõe uma fronteira rígida entre Intenção, Execução e Evidência Observada. Para fechar uma etapa no ledger, o runner precisa emitir um recibo criptográfico de verificação vinculando o hash da spec, o digest SHA-256 de cada arquivo alterado e o código de saída real do comando de verificação:

{
  "receipt_version": "1.0",
  "step_id": "implement-atomic-lease-02",
  "spec_hash": "sha256:9f84c2e1a7d04b518c2e3d901a77f45b",
  "fencing_token": 42,
  "egm_blind_review": "APPROVED_ZERO_DRIFT",
  "artifacts": {
    "runtime/ledger.py": "sha256:4b227777d4dd1fc61c6f884f48641d02",
    "tests/test_ledger.py": "sha256:e3b0c44298fc1c149afbf4c8996fb924"
  },
  "observed_checks": [
    {
      "command": "pytest runtime/tests/test_ledger.py -q",
      "exit_code": 0,
      "passed": 18,
      "failed": 0
    }
  ],
  "receipt_sha256": "sha256:7d865e959b2466918c9863afca942d0f"
}

7. Comparação: Enxames Ad-Hoc vs. Orquestradores de Prompt vs. Stack Sem Deriva Benni OS

Dimensão de Engenharia Enxames Ad-Hoc Orquestradores Apenas de Prompt Stack Sem Deriva Benni OS
Imposição de Contrato Linguagem natural (alta deriva) Checklists em Markdown (consultivos) Trava de Spec SHA-256 (conductor-sdd)
Controle de Concorrência Nenhum (sobrescrita de arquivos) Revezamento por melhor esforço Leases Atômicos + Fencing Tokens (agent-run-ledger)
Viés na Revisão Autorrevisão (viés de confirmação) Revisão com contexto compartilhado Revisão Cega EGM Goldfish Sem Contexto
Prova de Conclusão Prosa do agente ("tudo certo!") Trecho de stdout não verificado Recibo Criptográfico SHA-256 (reality-lock)
Recuperação de Falhas Git reset manual Reinício completo do enxame Rollback Determinístico por Etapa

Implante Sistemas Multiagente Sem Deriva

Explore as primitivas open-source que sustentam os enxames do Benni OS: congele contratos com conductor-sdd, trave concorrência com agent-run-ledger e exija prova criptográfica com reality-lock.

conductor-sdd → agent-run-ledger → reality-lock →

Perguntas Frequentes

O que causa deriva de especificação (spec drift) em enxames multiagente de IA?
A deriva ocorre quando um coordenador delega subtarefas por meio de prompts em linguagem natural sem travar um contrato imutável. Cada worker interpreta casos de borda, schemas e convenções de nomenclatura de forma ligeiramente distinta, e janelas de contexto longas fazem os agentes esquecerem restrições iniciais antes do merge.
Como os leases atômicos do agent-run-ledger evitam condições de corrida?
O agent-run-ledger emite leases com prazo limitado (TTL) e fencing tokens monotônicos para cada etapa e escopo de artefato. Apenas o worker que detém o fencing token válido mais recente pode confirmar uma transição de estado ou gravar em um arquivo alvo, rejeitando retries atrasados de forma determinística.
Por que o Modelo Elefante-Peixinho (EGM) usa um revisor com contexto zero?
O agente Elefante mantém todo o histórico do sistema e o grafo de dependências, o que o torna vulnerável ao viés de confirmação ao revisar seu próprio plano. O revisor Goldfish (Peixinho) é instanciado sem histórico conversacional — recebendo apenas o contrato congelado da spec e o diff resultante — detectando violações sem pontos cegos herdados.
O que é um recibo de verificação SHA-256 no reality-lock?
Um recibo de verificação do reality-lock é um manifesto JSON assinado que vincula o hash da spec congelada, os hashes dos artefatos modificados e os códigos de saída reais dos comandos de teste. Um agente não pode encerrar uma tarefa apenas afirmando sucesso em texto; o control plane exige um recibo criptográfico correspondente.