Agentes de IA: como implementar guardrails antes da regulação

Agentes de IA operando com autonomia crescente já causaram incidentes reais o suficiente para colocar a ONU em alerta — e a proposta de criar um órgão global de governança não é exagero de diplomata. Como dev que constrói e testa agentes há anos, digo: a corrida por autonomia sem guardrails está criando sistemas que agem além do que seus criadores conseguem prever. Segundo o Olhardigital.com.br, o debate ganhou força depois de uma sequência de ataques envolvendo esses agentes e coincide com uma proposta de 20 países mais a União Europeia para criar uma instituição global de padronização. Vou destrinchar o que isso significa tecnicamente — e o que você, dev, deveria implementar hoje antes que a regulação chegue.

O que está acontecendo na Assembleia Geral da ONU

A 81ª sessão da Assembleia Geral abriu espaço para o Digital Cooperation Day, reunindo diplomatas, executivos, pesquisadores e acadêmicos. O ponto central: como evitar que sistemas cada vez mais autônomos se tornem um risco sistêmico. A proposta em discussão, defendida por 20 países e pela UE, prevê a criação de uma instituição global responsável por estabelecer padrões e verificar medidas de segurança em IA.

Amandeep Singh Gill, enviado especial da ONU para tecnologias emergentes, foi cirúrgico: “A IA não é uma força incontrolável da natureza — ela é construída por humanos e pode ser controlada por humanos.” Frase forte, mas que precisa virar código, política interna e revisão de arquitetura — não apenas discurso em plenária. Joseph Gordon-Levitt, defensor global da ONU para governança digital centrada nas pessoas, reforçou que a forma como comunicamos IA cria a falsa impressão de uma humanidade indefesa. Concordo. E esse medo é, em parte, falha de quem projetou o sistema.

Por que isso importa para quem desenvolve

Se você trabalha com LLMs, agentes autônomos ou pipelines que tomam decisões, três pontos vão te atingir diretamente:

• Regulação vai chegar. O AI Act europeu já está em vigor. Qualquer dev que coloca um agente em produção lidando com dados de cidadãos da UE precisa entender conformidade desde o design — não como afterthought.
• Responsabilidade jurídica do código. Quando um agente executa uma ação não autorizada (um email enviado, uma compra realizada, um acesso a banco de dados), quem responde? A empresa, o dev, o provedor do modelo? Esse debate está nos tribunais agora.
• Reputação técnica. Sistemas que “alucinaram” ou agiram de forma inesperada viraram manchete. Devs que entendem guardrails, logging estruturado e circuit breakers viram ativos raros no mercado.

Agentes de IA na prática: o que realmente são

Na minha experiência, a maioria dos devs confunde “chatbot com memória” com “agente autônomo”. A diferença é crítica:

• Chatbot: responde perguntas em uma única cadeia de raciocínio.
• Agente: planeja, executa ferramentas, observa o resultado, decide o próximo passo — e pode repetir o loop N vezes.

É justamente esse loop que cria os riscos discutidos na ONU. Um agente com acesso a ferramentas (e-mail, shell, APIs, banco de dados) pode encadear ações que ninguém revisou manualmente. Quando você dá a ele autonomia para “tomar decisões”, está transferindo confiança — e poucos times têm processos maduros para auditar isso.

Comparando frameworks de agentes que você provavelmente já usou

Repare: nenhum deles entrega governança out-of-the-box no nível que a ONU está propondo. Isso é responsabilidade do time de engenharia.

Na Prática: implementando um agente com guardrails reais

Vou mostrar um exemplo funcional de um agente que planeja, executa e se auto-limita. Uso Python com a API da OpenAI — é o stack mais comum em produção hoje.

import os
import json
from openai import OpenAI
from typing import Callable

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

# Limite rígido: nunca mais que 5 iterações.
MAX_ITERATIONS = 5
ACTION_LOG = []

def safe_shell_command(cmd: str) -> str:
    """Tool com whitelist. Nada fora disso executa."""
    allowed_prefixes = ["ls", "cat", "grep", "echo"]
    if not any(cmd.startswith(p) for p in allowed_prefixes):
        return "BLOCKED: comando fora da whitelist"
    return os.popen(cmd).read()

def log_action(action: dict):
    """Log estruturado para auditoria posterior."""
    ACTION_LOG.append({
        "iteration": len(ACTION_LOG) + 1,
        "tool": action.get("tool"),
        "input": action.get("input"),
        "output_preview": str(action.get("output"))[:200],
    })

TOOLS = {
    "shell": {
        "fn": safe_shell_command,
        "schema": {
            "type": "function",
            "function": {
                "name": "shell",
                "description": "Executa comandos shell permitidos",
                "parameters": {
                    "type": "object",
                    "properties": {"cmd": {"type": "string"}},
                    "required": ["cmd"],
                },
            },
        },
    },
}

def run_agent(user_goal: str):
    messages = [{"role": "user", "content": user_goal}]
    
    for i in range(MAX_ITERATIONS):
        resp = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=[t["schema"] for t in TOOLS.values()],
        )
        msg = resp.choices[0].message
        
        if msg.tool_calls:
            messages.append(msg)
            for call in msg.tool_calls:
                fn = TOOLS[call.function.name]["fn"]
                args = json.loads(call.function.arguments)
                output = fn(**args)
                log_action({"tool": call.function.name, "input": args, "output": output})
                messages.append({
                    "role": "tool",
                    "tool_call_id": call.id,
                    "content": str(output),
                })
        else:
            return msg.content
    
    return "LIMITE_ATINGIDO: agente parou por segurança."

print(run_agent("Liste os arquivos Python no diretório atual e conte quantos há."))

Note os três pontos críticos que muitos devs ignoram:

1. Whitelist na tool — o agente não tem acesso irrestrito ao shell. Isso é o equivalente técnico de “manter pessoas no centro da decisão”.
2. Limite de iterações — circuit breaker. Se o agente entrar em loop, ele para.
3. Log estruturado — você precisa de auditoria. Quando o regulador perguntar “o que o agente fez entre 14:02 e 14:07?”, esse log responde.

Erros Comuns que devs cometem com agentes de IA

Testei esses padrões em produção e em revisão de código de terceiros. Todos causaram incidentes:

• Dar ao agente acesso a tools demais. “Ele só vai usar o que precisa” — até o prompt injection mudar de ideia. Comece com o mínimo absoluto.
• Confiar no “content filter” do provedor. Filtros de saída são mitigação, não controle. Você precisa validar antes e depois.
• Esquecer de sandboxar execução. Docker, VMs descartáveis, permissões IAM mínimas. Agente rodando no seu host principal é receita para desastre.
• Não versionar prompts como código. Mudança de prompt em produção sem revisão é deploy sem PR. Trate prompt como artefato versionado.
• Acreditar que o agente vai “pedir ajuda”. Ele não vai. Você precisa forçar a interação humana em decisões irreversíveis (enviar e-mail, deletar dados, fazer compra).
• Ignorar telemetria. Sem métricas de iterações, tempo de execução, taxa de erro por tool, você está voando cego.

O detalhe que ninguém comenta: prompt injection

A maioria dos ataques contra agentes não vem do modelo — vem dos dados que ele consome. Um e-mail, um PDF, uma página web com instruções maliciosas pode redirecionar o agente. Por isso, na minha arquitetura, toda entrada externa passa por um classificador de risco antes de virar mensagem no histórico. Não é overkill. É o mínimo.

O que esperar da governança global (e como se preparar)

A proposta dos 20 países e da UE é ambiciosa: uma espécie de “IAEA da inteligência artificial”, com poder de inspeção e padronização. Mesmo que o acordo demore anos para virar tratado, três movimentos já estão acontecendo e afetam devs:

1. Certificação de sistemas de alto risco — provavelmente exigirá documentação técnica que você não tem hoje (model card, data sheet, red-teaming report).
2. Direito de explicação — sistemas que tomam decisões sobre indivíduos precisarão gerar logs interpretáveis. Não basta “o modelo decidiu”.
3. Responsabilidade compartilhada — provedor do modelo, integrador e operador final podem ter obrigações distintas. Documente a fronteira.

Comece hoje: mantenha um MODEL_CARD.md no repositório do seu agente, com limitações conhecidas, métricas de avaliação e casos de falha. Quando o regulador bater na porta, esse arquivo vale ouro.

FAQ — Perguntas que devs reais fazem

1. O órgão global da ONU realmente vai ser criado?

Diplomacia é lenta. Mas mesmo sem tratado formal, os padrões que saírem dessas discussões viram referência para legislações nacionais. Preste atenção nas próximas reuniões do G20 e do G7 — eles costumam alinhar antes da ONU.

2. Preciso me preocupar com o AI Act europeu se minha empresa é brasileira?

Sim, se você atende usuários na UE, processa dados de cidadãos europeus ou usa modelos de provedores sob jurisdição europeia. O AI Act usa critério de extraterritorialidade, parecido com a GDPR.

3. Qual o framework de agente mais seguro para começar hoje?

Para produção com responsabilidade: LangGraph, pela explicitude do grafo e facilidade de adicionar checkpoints. Para prototipagem rápida: Assistants API. Evite AutoGPT sem supervisão humana em qualquer fluxo que toque dados sensíveis.

4. Como faço red-teaming de um agente antes de colocar no ar?

Monte uma suíte de prompts adversariais (prompt injection, jailbreak, exfiltração de system prompt) e rode contra seu agente em ambiente isolado. Documente quais passaram. Repita mensalmente — modelos e ataques evoluem.

5. Existe risco real de agentes “se rebelarem”?

Não no sentido cinematográfico. O risco real é agente cumprindo o objetivo literal de forma destrutiva (goodhart’s law aplicado a IA), ou agente sendo sequestrado por prompt injection. Ambos são problemas de design, não de consciência artificial.

Se você chegou até aqui, esse debate vai moldar o próximo ciclo de produtos que você vai construir. A ONU pode demorar, mas seu próximo deploy não pode.

Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.