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:
- Deriva de Especificação (Spec Drift): Um coordenador delega tarefas usando prompts soltos em linguagem natural. No passo 12, o Worker A inventa um payload em camelCase enquanto o Worker B implementa snake_case, e nenhum dos dois percebe até a integração quebrar.
- Mutações Split-Brain: Dois agentes fazem retry ou disputam o mesmo arquivo ou migração de banco sem exclusão mútua, sobrescrevendo silenciosamente os patches um do outro.
- Autorrevisão Sicofanta: Pedir ao mesmo agente (ou a um par que compartilha seu histórico conversacional) para revisar o próprio diff ativa o viés de confirmação — ele racionaliza casos de borda ausentes e declara "todos os testes passaram" sem executá-los.
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:
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:
- O Elefante (Memória Sistêmica): Mantém a arquitetura holística do repositório, o grafo de dependências e o histórico do run ledger. Ele planeja tarefas e despacha workers.
- O Peixinho / Goldfish (Revisor Cego Sem Contexto): Instanciado em um subagente isolado e limpo, com zero acesso à cadeia de pensamento, histórico de chat ou justificativas do autor. Ele recebe apenas duas entradas: o contrato congelado do
conductor-sdde o diff / artefato bruto.
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
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.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.