---
name: zergaton
description: Disparar e avaliar workers de Claude, Codex, AGY e OpenCode em paralelo. Use para delegacao, fan-out, ensemble, segunda opiniao ou comparacao entre modelos.
---

# Zergaton

Um worker para delegacao simples, workers diferentes para fatias
independentes, ou 3-5 familias para a mesma tarefa dificil. Cada chamada cobra
tokens; diversidade precisa justificar o custo.

## Contrato

Roda de qualquer cwd (no repo alvo), sem script auxiliar. Pre-requisitos da
maquina: `timeout` e `jq` no PATH; CLIs `claude`, `codex`, `agy`, `opencode`
logados; `~/.claude/agents/advisor.md`; perfis
`~/.codex/{scout,dev,advisor}.config.toml` (papel = perfil: scout=Sol low,
dev=Sol medium, advisor=Sol max). Fast mode do Claude vem de `fastMode: true`
em `~/.claude/settings.json`, nao de flag.

O supervisor (no Claude Code: Bash `run_in_background`, todos os workers num
unico bloco de tool calls) deve:

1. fechar stdin;
2. impor deadline e matar a arvore inteira;
3. capturar stdout/stderr fora do repo;
4. rejeitar timeout, exit nao-zero, saida vazia ou formato invalido.

Exemplos em Bash/Git Bash; `timeout` mata a arvore no Windows (provado
2026-08-26). Em outro executor, use a API de processo com stdin nulo e
kill-tree; nunca traduza /dev/null para NUL no Git Bash.

## Workers

P = prompt autocontido; OUT/ERR fora do repo. Escolha um:

```bash
timeout --kill-after=5s 600s claude -p --agent advisor --output-format json "$P" < /dev/null >"$OUT" 2>"$ERR"
timeout --kill-after=5s 300s claude -p --model fable --effort high --output-format json "$P" < /dev/null >"$OUT" 2>"$ERR"
timeout --kill-after=5s 300s claude -p --model opus --effort high --output-format json "$P" < /dev/null >"$OUT" 2>"$ERR"
timeout --kill-after=5s 180s codex exec -p scout --skip-git-repo-check -s read-only -o "$OUT" "$P" < /dev/null >/dev/null 2>"$ERR"
timeout --kill-after=5s 300s codex exec -p dev --skip-git-repo-check -s read-only -o "$OUT" "$P" < /dev/null >/dev/null 2>"$ERR"
timeout --kill-after=5s 600s codex exec -p advisor --skip-git-repo-check -s read-only -o "$OUT" "$P" < /dev/null >/dev/null 2>"$ERR"
timeout --kill-after=5s 180s agy.exe --model gemini-3.7-flash-high --output-format text --print "$P" < /dev/null >"$OUT" 2>"$ERR"
timeout --kill-after=5s 300s opencode run --pure --format json -m deepseek/deepseek-v4-flash --variant max "$P" < /dev/null >"$OUT" 2>"$ERR"
timeout --kill-after=5s 600s opencode run --pure --format json -m qwen-cloud/qwen3.8-max "$P" < /dev/null >"$OUT" 2>"$ERR"
```

Melhor em (opiniao do dono, 2026-08-26; revisar com bench):

| Worker | Melhor em |
|---|---|
| advisor (Fable max) | advisor mais inteligente e critico: plano complexo, arquitetura, design |
| fable-high | advisor de failover em tarefa menos complexa; economiza custo |
| claude-opus (high, fast) | tarefa geral rapida, front-end, design, tech atual; nativo do Claude Code |
| codex scout (Sol low) | leitura em massa, varredura |
| codex dev (Sol medium) | melhor custo/beneficio (Artificial Analysis): passo a passo complexo, back-end |
| codex advisor (Sol max) | segundo advisor |
| agy-flash-high | scout, busca web, deep research; tema critico: complemente com `codex exec --search` |
| oc-dsv4-flash | maior TPS: tarefa ultra rapida e simples; no ensemble, implementacao alternativa (brute force, guie bem) |
| oc-qwen38 | inteligente e lento: ensemble e plano profundo |

Dentro do Claude Code, prefira Agent tool para advisor/Opus. Modelos sao
snapshot; confirme model list/login antes de tarefa longa. Gotchas vivos:

- agy print mode nao carrega AGENTS.md (mande le-lo no prompt); sem login pede
  OAuth no stdin e, com stdin fechado, morre em silencio: logue antes.
- codex: eco e contagem de tokens saem no stderr; a resposta so no `-o`.
- qwen3.8-max sem `--variant`: xhigh aborta em leitura longa; reserve 10 min.
- Escrita so em worktree proprio: `codex exec -C <wt> -s workspace-write`,
  `opencode run --dir <wt> --auto`. No prompt, descarte com `>/dev/null`,
  nunca `> NUL` (Git Bash cria um arquivo NUL no repo).

## Aceite

Resposta: Claude `jq -r .result "$OUT"`; Codex o arquivo `-o`; AGY o stdout;
OpenCode `jq -r 'select(.type=="text").part.text' "$OUT" | tail -1`.

Claude JSON passa somente com type=result, subtype=success, is_error=false e
result nao vazio. Codex e AGY exigem OUT nao vazio. OpenCode exige JSONL
valido, nenhum evento error, ao menos um text nao vazio e um step_finish:

```bash
jq -e '.type=="result" and .subtype=="success" and .is_error==false and ((.result // "")|length)>0' "$OUT" >/dev/null
! jq -e 'select(.type=="error")' "$OUT" >/dev/null
jq -e -s 'any(.[]; .type=="text" and ((.part.text // "")|length)>0) and any(.[]; .type=="step_finish")' "$OUT" >/dev/null
```

## Prompt e avaliacao

Transportado ainda pode estar errado. Antes de disparar, fixe 2-4 eixos.
Template do prompt: "Voce e o worker {NOME} (zergaton). Tarefa: {...}.
Formato de saida: {...}. Criterio de pronto: {...}. Escrita: {proibida | so
em {wt}}. Leia AGENTS.md antes de agir." Criterio de pronto explicito subiu
PASS de 4/6 para 5/6 e cortou o tempo pela metade (BENCH).

Avalie fatos/comandos, pontue 0-10 por eixo e:

- fan-out: aceite cada fatia que satisfaz seu criterio;
- ensemble: melhor como base, incorpore apenas acertos verificados;
- divergencia factual: investigue, nao vote;
- falha: registre tempo/causa, corrija e tente no maximo uma vez.

## Build

Modo padrao com escrita; segue o guia global de git: issue primeiro, branch
issue-<n>-<slug>, progresso e veredito (nota 0-10 por worker) comentados na
issue via gh, PR com merge commit. Um worktree por worker; o advisor julga o
`git diff` real de cada um; so o diff escolhido entra, testes verdes antes.
Historico e medicoes: [BENCH.md](BENCH.md).