O quê

Agents (no contexto de LLMs) são sistemas onde um modelo de linguagem decide ações em loop, executando ferramentas externas e ajustando seu plano com base nos resultados, até completar uma tarefa. A diferença chave de “LLM regular”: agent não responde uma vez e termina — ele observa → pensa → age → repete indefinidamente.

A formulação canônica vem do ReAct (Yao et al. 2022): combinar Reasoning (thinking out loud) com Acting (chamar tools), num loop estruturado. Toolformer (2023), generative agents (2023), e Claude Computer Use (2024) construíram em cima dessa primitiva.

Em 2025, agents passaram de paper academic para produto enterprise — Devin (Cognition), Anthropic Computer Use, OpenAI Operator, Cursor agent mode, todos rodam loops agentic.

Em Magik LLM Gathering, agents é tratada como Construct · Concept · Rare — a primitiva que transforma Models em sistemas autônomos.

Como funciona

O loop básico

Pseudo-código de um agent:

state = initial_task
while not done:
  thought = LLM(state, "what should I do next?")
  action = LLM(thought, "what tool should I call?")
  observation = execute_tool(action)
  state = state + thought + action + observation
  done = LLM(state, "is the task complete?")
return state.final_answer

Cada iteração: o LLM lê o histórico completo (incluindo seus próprios pensamentos anteriores e resultados de ações), decide próxima ação, executa, registra resultado. Loop continua até completar tarefa ou bater limite.

Componentes

• Planning: agent decompõe tarefa complexa em sub-tarefas. Pode ser implícito (LLM apenas escolhe próxima ação) ou explícito (LLM produz plano estruturado primeiro, depois executa).
• Memory: contexto persistente entre iterações. Short-term (working memory) é a janela de contexto atual; long-term é storage externo (vector DB, file system).
• Tools: ações executáveis. Web search, code execution, file read/write, API calls, sub-agents.
• Reflection: agent avalia próprio progresso periodicamente, ajusta plano. Vital para tarefas longas.

Frameworks e patterns

• ReAct: o template original. Thought → Action → Observation, repeat.
• Plan-and-Execute (Wang et al. 2023): planejar primeiro tudo, depois executar. Reduz custos mas perde adaptabilidade.
• Reflexion (Shinn et al. 2023): agent reflete sobre erros após cada tentativa, incorpora aprendizado na próxima.
• AutoGPT / BabyAGI (2023, virais): agents autônomos open-source que tentam executar objetivos high-level (frequentemente mal). Demonstraram limitações de agents 2023.
• Anthropic Computer Use (2024): agent que controla browser/desktop via screenshots + clique/teclado. Push pra agents desktop-grade.

Padrões emergentes

Multi-agent systems: vários agents especializados conversam. Coordinator + Researcher + Writer + Reviewer. Útil para tarefas que exigem perspectivas distintas; complexo de orquestrar.

Tool-use vs Direct generation: para tarefas como “qual a capital da França?”, chamar web_search é overkill — modelo sabe. Decisão “preciso de tool ou não” é meta-cognitiva e ainda imatura.

Verification loops: agent gera resposta + segundo agent (ou mesmo agent) critica. Reduces hallucination, custa 2-3x.

Por que importa

Agents marcam a transição de “LLM como chat” para “LLM como worker”:

• Tarefas multi-step viram automatizáveis: book a flight, debug a codebase, summarize 100 papers. Trabalho que antes precisava de humano coordenando.
• Produtos enterprise inteiros se redesenham em torno de agents: Devin (software engineering agent), Harvey (legal agent), Glean Assistant (knowledge work agent).
• Mudança no modelo de cobrança: AI antes era cobrada por chamada API (cents). Agents são cobrados por tarefa completada (dólares a centenas).
• Habilitam test-time compute scaling: agents podem rodar loops longos consumindo muito compute para tarefas valiosas. Inverte a economia tradicional (compute caro = sempre minimize).

A tese subjacente: muito do trabalho humano é loop sequencial de ações + verificações. Se LLMs conseguem fazer isso confiavelmente, virão pra cima de white-collar work.

Pegadinhas

• Compounding errors: cada iteração tem chance pequena de erro; em 50 iterações, probabilidade de algo dar errado é alta. Mitigação: verification, rollback, human-in-the-loop.
• Infinite loops: agent fica preso fazendo a mesma coisa. Detecção via cycle detection ou hard step limits.
• Cost explosion: 50 iterações × $0.10/chamada = $5 por tarefa. Comparado a $0.01 de chamada única, escala diferente.
• Hallucinated tools: agent imagina ferramentas que não existem (“vou chamar database.delete_all”). Schema validation no executor é mandatório.
• Security nightmare: agent com acesso a filesystem + API keys + execução de código é vetor de ataque massivo. Sandboxing + permission prompts + audit trails são essenciais.
• Brittle on novelty: agents performam mal em tarefas fora da distribuição de treino. ReAct funciona em benchmark; em produção real, frequentemente quebra em casos edge.
• Hard to evaluate: como medir se um agent “fez bem” uma tarefa complexa? Metricas tradicionais (accuracy, BLEU) não se aplicam. Eval de agents é área de pesquisa ativa.

Estado em 2026

Em 2026, agents deixaram de ser demo e viraram a forma dominante de consumir LLMs em trabalho técnico. Coding agents — Claude Code, Cursor agent mode, OpenAI Codex, Devin — executam loops de horas, editando repositórios inteiros, rodando testes e iterando sobre falhas. O gargalo migrou de “o modelo consegue raciocinar?” para “o modelo consegue manter coerência por 50+ passos sem acumular erro?”. A METR mediu o “horizonte de tarefa” (duração de tarefa que um agent completa com 50% de sucesso) dobrando a cada ~7 meses — evidência empírica de que a confiabilidade de longo prazo está, de fato, escalando.

A grande mudança técnica foi treinar agents com RL sobre recompensas verificáveis (testes que passam, problemas matemáticos corretos), em vez de só fazer prompting sobre modelos de chat. Os modelos “thinking” (o-series, Claude com extended thinking, DeepSeek-R1) embutiram parte do loop reasoning/acting dentro do próprio modelo. Em paralelo, padrões de engenharia se consolidaram: sub-agents para isolar contexto, “context engineering” para gerenciar a janela, e MCP como camada de tools padronizada entre fornecedores.

Os trade-offs permanecem agudos. Custo por tarefa subiu de centavos (uma chamada) para dólares ou dezenas de dólares (um loop completo); compounding errors ainda derrubam tarefas longas; e a segurança virou central — um agent com acesso a shell, filesystem e API keys é superfície de ataque enorme, com prompt injection via conteúdo lido pelo próprio agent como a ameaça mais discutida. Avaliação também segue difícil: SWE-bench Verified e GAIA ajudam, mas medir “um agent fez bem uma tarefa aberta” continua em aberto. O consenso de 2026: agents funcionam muito bem onde a verificação é barata (código, dados) e ainda quebram em workflows longos e ambíguos.

Tratamento de carta — proposta

Em Magik LLM Gathering, agents aparece como Construct · Concept · Rare: no início de cada turno, um Model aleatório que você controla executa uma Technique aleatória da sua mão sem pagar custo. Você não escolhe qual. Mecânica espelha a essência: autonomia loop sem controle determinístico do jogador.

É a carta que recompensa decks com sinergia consistente — quando qualquer Technique do seu deck funciona bem, agents te dá uma grátis por turno. Quando o deck é fragmentado, agents joga coisa ruim.

Veja também

• ReAct — Reason + Act — paper seminal de agents
• Function Calling / Tool Use — primitivo de tool-use
• MCP — Model Context Protocol — protocolo padronizando tools de agents
• Computer Use — agent específico que controla browser
• Multi-Agent Orchestration — sistemas com múltiplos agents coordenando