Super Squad AI

Autonomia para agentes de IA sem abrir mão do controle.

Plataforma local de orquestração multiagente que transforma modelos de IA em uma squad coordenada de desenvolvimento, com planejamento, isolamento Git, verificação determinística, persistência de estado e recuperação de falhas.

Etapa
Funcional · Em desenvolvimento ativo
Produto
AI Product · Developer Tool
Foco
Agent Orchestration · Verification · Git Isolation · Reliability
  • AI Product
  • Multi-Agent
  • Python
  • Git
  • Developer Tools
  • Technical Product

Escopo Técnico

  • 1 + N
    Leader + Workers
  • 2
    Estágios de verificação
  • Capabilities
    Roteamento de agentes
  • SQLite
    Persistência de estado

O problema

Coordenar uma IA é simples. Coordenar várias com segurança não é.

Coding agents conseguem executar tarefas individualmente. Quando vários agentes trabalham sobre um mesmo repositório ao mesmo tempo, surgem outros problemas: conflitos entre mudanças, alterações fora do escopo de cada tarefa, perda de contexto entre agentes, estados incompatíveis, custo acumulado, falhas sem recuperação e uma dificuldade real de auditoria sobre o que cada agente fez.

O desafio do Super Squad AI não é gerar código. É governar a execução de agentes sobre um repositório com regras determinísticas, fronteiras claras e verificação baseada em evidência, não em declaração.

A IA propõe. O sistema verifica.

Este é o princípio central do projeto.

O que um agente pode fazer
  • Afirmar que a tarefa foi concluída
  • Afirmar que os testes passaram
  • Afirmar que o código funciona
  • Produzir um WorkerReport
O que o sistema valida
  • Executar os testes de forma independente
  • Verificar evidências antes de avançar
  • Exigir dois estágios de verificação
  • Promover estado somente com evidência autorizada

Um agente pode afirmar que terminou. Isso não modifica o estado real da tarefa. A tarefa somente avança quando existe evidência autorizada produzida pelo sistema, não pelo agente.

WorkerReport é uma declaração. VERIFIED é um estado que exige prova.

Como funciona

  1. Solicitação do usuário
  2. Squad Leader
  3. Plano estruturado
  4. Task DAG (grafo de dependências)
  5. Seleção de agente por capability
  6. ContextPack por tarefa
  7. Task Worktree isolado
  8. Execução com ferramentas restritas
  9. Verificação da tarefa
  10. Integração controlada
  11. Verificação da Run
  12. Evidência persistida no estado

Cada etapa é determinística. A IA ocupa os nós de execução. O controle do fluxo, das fronteiras e da verificação é do sistema.

Uma squad baseada em capabilities, não em agentes fixos

A arquitetura não define posições rígidas como worker_01, worker_02 ou security_worker. Os agentes registram capabilities. O scheduler seleciona os compatíveis com cada tarefa.

  1. Leader
  2. Agent Registry
  3. Scheduler Seleciona agentes compatíveis com as capabilities da tarefa

Workers disponíveis

  • Backend Worker
  • QA Worker
  • Security Specialist
  • Frontend Worker

Novos especialistas podem entrar na squad sem redesenhar o core. A modularidade é real porque está no contrato de capabilities, não no código de orquestração.

Planejar antes de executar

O Leader não distribui tarefas diretamente. Ele interpreta o objetivo, cria um plano estruturado, decompõe em tarefas, define dependências entre elas e associa a cada uma as capabilities necessárias.

  1. Objetivo recebido
  2. Leader interpreta e estrutura
  3. Tarefas decompostas
  4. Dependências definidas (DAG)
  5. Capabilities associadas a cada tarefa
  6. Scheduler recebe o grafo

A execução começa somente depois que o plano existe. Isso evita que agentes iniciem trabalho paralelo sem contexto sobre o que os outros estão fazendo.

Cada agente trabalha isolado

Esta é a segunda grande história de arquitetura do projeto.

Múltiplos agentes não trabalham livremente sobre o mesmo working tree. Cada tarefa possui uma fronteira Git própria: um worktree isolado criado a partir da Run Branch.

  1. Human Branch (fora do ciclo automático)
  2. Run Branch
  3. Task Worktrees (um por tarefa ativa)
  4. Verificação da tarefa no worktree
  5. Commit controlado para a Run Branch
  6. Verificação da Run integrada

A branch humana permanece fora do ciclo automático. Mudanças chegam a ela somente depois de passar pelos dois estágios de verificação.

Benefícios conceituais dessa abordagem: isolamento entre agentes concorrentes, rollback granular por tarefa, auditoria do que cada agente fez separadamente, integração controlada e menor risco de contaminação entre tarefas.

Funcionar isolado não significa funcionar integrado

A verificação acontece em dois momentos distintos por razão arquitetural.

Verificação de Tarefa
  • Valida a tarefa no worktree isolado
  • Executa antes da integração
  • Evidência local
  • Erros contidos no worktree
Verificação de Run
  • Valida o estado integrado na Run Branch
  • Executa depois de todas as integrações
  • Evidência do sistema combinado
  • Detecta conflitos entre tarefas

Código correto isoladamente pode quebrar o sistema quando integrado. A segunda verificação existe justamente para capturar isso.

Dar a cada agente o contexto necessário, e somente ele

O sistema utiliza um ContextPack por tarefa e por agente. Existe um ContextCache determinístico para reduzir duplicação de contexto entre tarefas correlatas.

  1. Contexto do projeto
  2. Context Cache (determinístico)
  3. ContextPack específico por tarefa
  4. Worker recebe apenas o contexto relevante

O objetivo não é memória de IA. É controle sobre o que cada agente enxerga: menos arquivos irrelevantes, maior isolamento, menor superfície de exposição.

Autonomia limitada por políticas

Os agentes operam dentro de fronteiras definidas pelo sistema. Cada worker tem acesso apenas ao conjunto de ferramentas e caminhos autorizados para aquela tarefa.

O sistema define conceitualmente:

  • quais caminhos um agente pode ler e escrever
  • quais ferramentas estão disponíveis por tarefa
  • quais comandos podem ser executados
  • como segredos são filtrados do contexto
  • quais evidências são necessárias para avançar o estado

Os detalhes de implementação dessas políticas não são publicados. O princípio é: o agente opera dentro do espaço que o sistema define, não no espaço que o agente gostaria de ter.

Falha não significa perder a execução inteira

Falhas fazem parte do design, não são exceções não tratadas.

O sistema utiliza budgets de tentativa por tarefa, estratégias de retry, fail-fast quando o budget é esgotado, persistência do estado entre tentativas, recuperação de runs interrompidas e retenção dos worktrees de tarefas que falharam para análise posterior.

Worktrees de tarefas bem-sucedidas são limpos. Worktrees de tarefas com falha permanecem disponíveis para diagnóstico.

Testar também o sistema contra formas de enganá-lo

O Super Squad AI utiliza regressões adversariais como parte do processo de desenvolvimento.

  1. Finding identificado
  2. Teste de regressão criado
  3. Fix aplicado
  4. Guard permanente

O objetivo é garantir que APIs públicas, registros fabricados ou evidências inválidas não consigam promover artificialmente o estado de uma execução. Detalhes de implementação desses controles não são publicados.

Não é um wrapper de múltiplos modelos

O que não é
  • Um wrapper que chama vários LLMs
  • Uma interface para múltiplos provedores
  • Um framework de prompts encadeados
  • Uma ferramenta de automação de tarefas
O que é
  • Orquestração com controle de estado
  • Git isolation por tarefa
  • Verificação determinística em dois estágios
  • Gerenciamento de contexto por agente
  • Fronteiras de segurança por política
  • Recuperação de falhas por design

Decisões de produto e engenharia

Decisão 1 — Relato do agente não é estado real

O problema era que um modelo pode afirmar sucesso sem prova verificável.

A decisão foi tratar WorkerReport como declaração e exigir evidência autorizada para qualquer avanço de estado. O trade-off é um lifecycle mais complexo em troca de maior confiança operacional sobre o que o sistema realmente executou.


Decisão 2 — Git como fronteira operacional

O problema era que vários agentes alterando o mesmo working tree tornavam rollback e auditoria difíceis de realizar com confiança.

A decisão foi worktrees isolados por tarefa com integração controlada. O trade-off é mais gerenciamento Git em troca de isolamento real entre agentes concorrentes.


Decisão 3 — Capabilities em vez de papéis fixos

O problema era que uma arquitetura com posições fixas de agentes não escala conceitualmente e exige redesenho do core para adicionar especialistas.

A decisão foi seleção por capabilities no scheduler. O trade-off é um scheduler mais sofisticado em troca de modularidade real.


Decisão 4 — Verificação antes e depois da integração

O problema era que código correto isoladamente pode quebrar o sistema quando integrado com outras tarefas concorrentes.

A decisão foi two-stage verification com estágios independentes. O trade-off é mais tempo e custo de execução em troca de maior confiabilidade do estado integrado.

Arquitetura

  1. Usuário
  2. CLI
  3. Leader Planejamento · Decomposição · Task DAG
  4. Scheduler Seleção por capability · ContextPack
  5. Worker Execução · Ferramentas restritas · Git Worktree
  6. Verification Tarefa (isolada) · Run (integrada)
  7. State Persistence SQLite · Evidências · Histórico de runs

Tudo local. Sem backend externo, sem banco de dados remoto, sem serviço de orquestração externo.

  • Git / Worktrees
  • SQLite
  • CLI
  • Structured Outputs

Estado atual

O Super Squad AI é um produto funcional em evolução ativa. O que existe hoje:

  • execução controlada com Leader e Workers dinâmicos
  • persistência de estado em SQLite
  • Git isolation por tarefa com worktrees
  • orquestração multiagente com planejamento estruturado
  • verificação em dois estágios
  • recuperação de runs interrompidas
  • testes automatizados cobrindo os contratos principais

Não há usuários externos, empresas, receita ou métricas de produtividade confirmadas. Esses dados não existem e não são afirmados aqui.

O projeto também serviu como ambiente para experimentação com desenvolvimento assistido por múltiplos agentes, com revisão e validação humana ao longo do processo.

O que este projeto demonstra