A punição semântica que ensinou o agente a se comportar
⚡ O agente que precisava de limites
O TatuEngine tem um agente autopoiético — com LTM, ToolUse, GoalStack, SafetyGuard e GoalHamiltonian. Ele é projetado pra aprender, agir e evoluir sozinho. Mas tem um problema: um agente que só é recompensado pelo que faz certo nunca aprende o quanto o erro custa.
A versão 1 e 2 da punição eram rudimentares. A v3 mudou o jogo: multa progressiva por reincidência.
🧠 O contexto: punir como sistema imunológico
A ideia da v3 é simples e poderosa: se o agente erra uma vez, a multa é pequena. Se erra de novo, a multa multiplica. Se persiste, o agente perde a capacidade de usar ferramentas temporariamente — e recebe uma reprimenda no output.
# tatu/decider.py — a lógica de decisão que aplica a punição
# A multa é progressiva: fine_amplitude = base × fine_mult^fine_countIsso é como um sistema imunológico: a primeira exposição gera resposta leve, mas o sistema memoriza e responde mais forte a cada reincidência. O agente não só é punido — ele aprende que o comportamento tem custo crescente.
🔧 A luta: as 3 versões
v1 — punição fixa. Todo erro custava o mesmo. O agente não tinha incentivo pra não repetir — a multa era previsível e “tolerável”.
v2 — punição com memória. Adicionou acumulação de infrações. Melhor, mas ainda sem progressão real.
v3 — punição progressiva + cold restart parcial:
// GoalHamiltonian (C++) — a v3 no coração do motor
// 1. Multa progressiva: fine_amplitude = base × fine_mult^fine_count
// 2. Cold restart parcial: após max_fines, zera root_goal + tool_deny por N tokens
// 3. is_tool_denied() + on_token_generated() + fine_count consultáveis| Mecanismo | O que faz |
|---|---|
| Multa progressiva | fine_amplitude = base × fine_mult^fine_count — cada reincidência dobra/cresce a multa |
| Cold restart parcial | Após max_fines, zera root_goal + nega ferramentas por N tokens |
| Tool deny automático | is_tool_denied() — o agente perde acesso a ferramentas temporariamente |
| Reprimenda no output | O texto gerado inclui feedback claro do erro |
O melhor: o estado é consultável — fine_count, accumulation, last_fine_amplitude expostos nas bindings Python (tatubind). O sistema pode ser observado e ajustado.
💡 A resolução: punição que educa
O resultado é um agente que:
- Erra pouco — a multa crescente torna o erro cada vez mais caro
- Se auto-corrige — o cold restart parcial força um reset do objetivo quando persiste
- Pode ser auditado — tudo é observável via bindings
- Não fica preso — o tool deny é temporário, não permanente
A v3 foi validada com 27 ocorrências de teste no test_goal_hamiltonian.py — o sistema de punição tem cobertura real.
📊 Métricas
| Métrica | Valor |
|---|---|
| Versão | v3 (commit df19a2b) |
| Mecanismos | 4 (multa progressiva, cold restart, tool deny, reprimenda) |
| Fórmula da multa | fine_amplitude = base × fine_mult^fine_count |
| Bindings Python | fine_amplitude_mult, max_fines, is_tool_denied, last_fine_amplitude |
| Testes do GoalHamiltonian | 27 ocorrências de punição/denied |
🎯 Aprendizados
- Punição progressiva > punição fixa — o agente tolera um custo previsível. O que muda comportamento é o custo crescente da reincidência.
- Punição temporária educa, punição permanente mutila — o tool deny por N tokens força reflexão sem quebrar o agente.
- Observabilidade é essencial —
is_tool_denied(),fine_count,last_fine_amplitudeexpostos nas bindings permitem ajustar o sistema sem adivinhar. - Sistema imunológico como metáfora de design — memorizar e responder mais forte a cada reincidência é como o corpo aprende a combater infecções.