05-04-02 — Loops, terminação e controle de custo

Por que loops são perigosos

Um agente entra em loop quando:

• A ferramenta retorna resultados ambíguos ou inconclusivos em loop
• O critério de "tarefa concluída" não está bem definido
• Duas ferramentas se contradizem e o agente fica tentando resolver
• Erro de tool que o agente tenta corrigir indefinidamente

Estimativa de custo de agentes

Preços aproximados GPT-4o: US$ 2,50/1M input tokens, US$ 10/1M output tokens (abril 2025).

Guardrails de terminação

1. Max iterations

from langchain.agents import AgentExecutor

executor = AgentExecutor(
    agent=agent,
    tools=tools,
    max_iterations=10,          # Máximo de steps
    max_execution_time=60,      # Segundos máximos
    early_stopping_method="generate"  # Gera resposta parcial ao atingir limite
)

2. Token budget

import tiktoken

class TokenBudgetTracker:
    def __init__(self, budget: int = 50_000):
        self.budget = budget
        self.used = 0
        self.enc = tiktoken.encoding_for_model("gpt-4o")
    
    def track(self, text: str) -> bool:
        tokens = len(self.enc.encode(text))
        self.used += tokens
        return self.used < self.budget  # False = orçamento esgotado
    
    def remaining_pct(self) -> float:
        return (self.budget - self.used) / self.budget * 100

# No loop do agente:
tracker = TokenBudgetTracker(budget=30_000)

while True:
    response = call_llm(messages)
    if not tracker.track(response.content):
        return graceful_degradation_response(partial_results)
    # ... continua loop

3. Graceful degradation

Quando o agente atinge um limite, não deve simplesmente falhar — deve retornar o melhor resultado possível com o que tem:

def graceful_degradation_response(
    partial_results: list,
    reason: str
) -> str:
    """Retorna resultado parcial com aviso claro ao usuário"""
    if not partial_results:
        return f"Não foi possível completar a tarefa ({reason}). Tente dividir em partes menores."
    
    summary = "\n".join(f"- {r}" for r in partial_results)
    return f"""⚠️ Resultado parcial ({reason}):
    
{summary}

Para resultado completo, divida a tarefa em etapas menores ou aumente o budget."""

Monitoramento em produção

import time
import logging
from dataclasses import dataclass, field

@dataclass
class AgentRunMetrics:
    run_id: str
    start_time: float = field(default_factory=time.time)
    iterations: int = 0
    input_tokens: int = 0
    output_tokens: int = 0
    tool_calls: list = field(default_factory=list)
    
    @property
    def duration(self) -> float:
        return time.time() - self.start_time
    
    @property
    def estimated_cost_usd(self) -> float:
        # GPT-4o pricing
        return (self.input_tokens / 1_000_000 * 2.50 + 
                self.output_tokens / 1_000_000 * 10.00)
    
    def log(self):
        logging.info(f"""
        Run: {self.run_id}
        Duration: {self.duration:.1f}s
        Iterations: {self.iterations}
        Tokens: {self.input_tokens + self.output_tokens:,}
        Cost: US$ {self.estimated_cost_usd:.4f}
        Tools used: {[t['name'] for t in self.tool_calls]}
        """)