A área de desenvolvimento de Agentes AI tem enfrentado um paradigma contraintuitivo: muitos projetos estão superestimando a necessidade de planejamento complexo quando, na verdade, abordagens mais simples oferecem maior eficiência em cenários específicos. Este artigo explora por que a Engenharia de Agentes AI (Harness Engineering) frequentemente não requer planejamento elaborado, e como duas categorias de cenários se beneficiam significativamente de regras simples.

Conceitos Fundamentais da Engenharia de Agentes AI

Engenharia de Agentes AI refere-se ao sistema que gerencia o fluxo de execução,调度 ferramentas, trata exceções e garante confiabilidade. Pense nela como o "sistema nervoso" do agente. Seu objetivo principal não é necessariamente planejar ações complexas, mas sim garantir que o agente execute tarefas de forma eficiente e confiável.

Muitos desenvolvedores caem na armadilha de acreditar que quanto mais complexo o planejamento, mais "inteligente" o agente se torna. Essa percepção vem principalmente de:

• Academia focada em benchmarks que valorizam capacidades de raciocínio aberto
• Marketing excessivo de produtos como AutoGPT e GPTs que sugerem agentes autônomos completos

Comparação: Planejamento Complexo vs. Regras Simples

A tabela a seguir destaca as diferenças fundamentais entre essas abordagens:

Cenário 1: Operações de Negócio B2B com Alta Determinação

Cenários B2B como processamento de tickets, aprovação de reembolsos, revisão de contratos e consultas de dados ERP se beneficiam enormemente de abordagens baseadas em regras. Esses cenários compartilham características comuns:

• Fluxos altamente padronizados
• Nós completamente enumeráveis
• Regras bem definidas
• Altíssimo custo de erro

Arquitetura Híbrida: Modelo de Linguagem para Percepção, Regras para Controle

A solução ideal para esses cenários é uma abordagem híbrida onde:

1. O modelo de linguagem lida apenas com duas tarefas: compreender entradas de linguagem natural e identificar intenções/parâmetros; converter resultados finais em linguagem natural
2. Todas as tarefas de调度, lógica de negócio, validação e chamadas de API são gerenciadas por regras pré-definidas

Exemplo Prático: Agente de Aprovação de Reembolsos

import openai
import json
from typing import Dict, List

# Inicialização do cliente do modelo de linguagem
openai.api_key = "sua_chave_api"

# -------------------------- Configuração de Regras --------------------------
# Regras de categoria de despesas
EXPENSE_CATEGORY_RULES = {
    "Hospedagem de Viagem": {"max_amount": 500, "required_materials": ["Nota Fiscal", "Aprovação de Viagem"]},
    "Compras de Escritório": {"max_amount": 1000, "required_materials": ["Nota Fiscal", "Lista de Compras"]},
    "Refeições e Entretenimento": {"max_amount": 2000, "required_materials": ["Nota Fiscal", "Justificativa"]}
}

# Fluxo de aprovação
AUDIT_FLOW = [
    "check_materials",  # Verificar materiais obrigatórios
    "check_invoice_valid",  # Verificar autenticidade da nota fiscal
    "check_duplicate_reimbursement",  # Verificar reembolsos duplicados
    "check_amount_standard",  # Verificar se o valor está dentro do padrão
    "generate_result"  # Gerar resultado da aprovação
]
# -----------------------------------------------------------------------------

def recognize_intent(user_input: str) -> Dict:
    """Modelo de linguagem reconhece intenção e extrai parâmetros"""
    prompt = f"""
    Você é um assistente de reconhecimento de intenção para aprovação de reembolsos.
    Extraia as seguintes informações da entrada do usuário, retorne em formato JSON:
    1. expense_category: Categoria de despesa (apenas uma das opções)
    2. amount: Valor da despesa (número)
    3. materials: Lista de materiais fornecidos (array)
    4. invoice_number: Número da nota fiscal
    Entrada do usuário: {user_input}
    """
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}],
        temperature=0
    )
    return json.loads(response.choices[0].message.content)

def check_materials(params: Dict) -> Dict:
    """Regra: Verificar materiais obrigatórios"""
    required = EXPENSE_CATEGORY_RULES[params["expense_category"]]["required_materials"]
    missing = [m for m in required if m not in params["materials"]]
    if missing:
        return {"pass": False, "reason": f"Materiais obrigatórios ausentes: {','.join(missing)}"}
    return {"pass": True}

def check_invoice_valid(params: Dict) -> Dict:
    """Regra: Verificar autenticidade da nota fiscal"""
    if len(params["invoice_number"]) != 8:
        return {"pass": False, "reason": "Número de nota fiscal inválido, nota fiscal é falsa"}
    return {"pass": True}

def check_duplicate_reimbursement(params: Dict) -> Dict:
    """Regra: Verificar reembolsos duplicados no banco de dados"""
    if params["invoice_number"] == "12345678":
        return {"pass": False, "reason": "Esta nota fiscal já foi reembolsada, não submeta novamente"}
    return {"pass": True}

def check_amount_standard(params: Dict) -> Dict:
    """Regra: Verificar se o valor está dentro do padrão da categoria"""
    max_amount = EXPENSE_CATEGORY_RULES[params["expense_category"]]["max_amount"]
    if params["amount"] > max_amount:
        return {"pass": False, "reason": f"Limite máximo para {params['expense_category']} é {max_amount} reais"}
    return {"pass": True}

def generate_result(params: Dict, audit_results: List[Dict]) -> str:
    """Modelo de linguagem gera resultado em linguagem natural"""
    all_pass = all([r["pass"] for r in audit_results])
    if all_pass:
        prompt = f"Genere um amigável aviso de aprovação de reembolso informando que o valor de {params['amount']} reais será creditado em 3 dias úteis"
    else:
        reasons = [r["reason"] for r in audit_results if not r["pass"]]
        prompt = f"Genere um amigável aviso de reprovação de reembolso explicando: {','.join(reasons)}, informando para corrigir e submeter novamente"
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.7
    )
    return response.choices[0].message.content

def reimbursement_audit_agent(user_input: str) -> str:
    """Ponto de entrada principal do agente"""
    # 1. Reconhecimento de intenção
    params = recognize_intent(user_input)
    # 2. Execução sequencial das verificações
    audit_results = []
    for step in AUDIT_FLOW[:-1]:
        step_func = globals()[step]
        res = step_func(params)
        audit_results.append(res)
        if not res["pass"]:
            break
    # 3. Geração de resultado
    result = generate_result(params, audit_results)
    return result

# Teste
if __name__ == "__main__":
    user_input = "Quero reembolsar hospedagem de viagem, valor 300 reais, forneci nota fiscal e aprovação de viagem, número da nota é 87654321"
    res = reimbursement_audit_agent(user_input)
    print(res)

Cenário 2: Interações de Consumidor com Alta Concorrência e Baixa Latência

Cenários de interação com consumidores como assistentes de streaming e-commerce, atendimento ao cliente automático, respostas automáticas em redes sociais e consultas em plataformas de entrega exigem:

• Alta concorrência
• Latência ultra-baixa (geralmente abaixo de 1 segundo)
• Caminhos de interação curtos
• Tolerância a erro do usuário baixa

Arquitetura de Roteamento por Regras com Preenchimento de Modelo

A solução ideal para esses cenários envolve:

1. Reconhecimento de intenção pelo modelo de linguagem, classificando em categorias pré-definidas
2. Roteamento por regras para o fluxo apropriado
3. Preenchimento de modelos de resposta com parâmetros de ferramentas

Exemplo Prático: Assistente de Streaming E-commerce

import openai
import json
from typing import Dict

# Inicialização do cliente do modelo de linguagem
openai.api_key = "sua_chave_api"

# -------------------------- Configuração de Regras --------------------------
# Lista pré-definida de intenções
INTENT_LIST = [
    "consultar_descontos",
    "consultar_estoque",
    "consultar_status_entrega",
    "consultar_tamanho_produto",
    "consultar_politica_devolucao",
    "outras_perguntas"
]

# Modelos de resposta
RESPONSE_TEMPLATES = {
    "consultar_descontos": "Olá, o produto atualmente tem promoção de {} por {}, mais {}. A promoção termina hoje, aproveite!",
    "consultar_estoque": "Olá, o tamanho {} que você procura ainda tem {} unidades em estoque, são poucas unidades, não perca!",
    "consultar_status_entrega": "Olá, seu pedido {} já foi enviado e está a {}km de você. Previsão de entrega em {} minutos. Se atrasar, você pode solicitar um voucher de R$5!",
    "consultar_tamanho_produto": "Olá, esse produto tem modelo {}, recomendamos para pessoas com {}kg usar tamanho {}. Se estiver com dúvida, pegue um tamanho maior!",
    "consultar_politica_devolucao": "Olá, nós oferecemos devolução sem motivos em 7 dias, troca por defeito em 15 dias e garantia de 1 ano. Compre com segurança!",
    "outras_perguntas": "Olá, anotei sua pergunta. Em breve um de nossos atendentes entrará em contato com você!"
}

# Mapeamento de ferramentas
TOOL_API_MAPPING = {
    "consultar_descontos": "get_discount_info",
    "consultar_estoque": "get_stock_info",
    "consultar_status_entrega": "get_logistics_info",
    "consultar_tamanho_produto": "get_size_guide"
}
# -----------------------------------------------------------------------------

def recognize_intent(user_input: str, room_id: str) -> Dict:
    """Reconhecimento de intenção com parâmetros extraídos"""
    prompt = f"""
    Você é um assistente de reconhecimento de intenção para streaming.
    Identifique a intenção na entrada do usuário, escolhendo apenas desta lista: {','.join(INTENT_LIST)}.
    Extraia parâmetros-chave, retorne em formato JSON:
    1. intent: Intenção identificada
    2. params: Parâmetros extraídos (ID do produto, número do pedido, peso, tamanho, etc.)
    ID da sala de streaming atual: {room_id}
    Entrada do usuário: {user_input}
    """
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}],
        temperature=0,
        timeout=1
    )
    return json.loads(response.choices[0].message.content)

def get_discount_info(params: Dict, room_id: str) -> Dict:
    """API de consulta de descontos"""
    return {"valor_minimo": 200, "desconto": 30, "brinde": "esponja de maquiagem"}

def get_stock_info(params: Dict, room_id: str) -> Dict:
    """API de consulta de estoque"""
    return {"tamanho": params.get("tamanho", "M"), "quantidade": 12}

def get_logistics_info(params: Dict, room_id: str) -> Dict:
    """API de consulta de entrega"""
    return {"pedido_id": params.get("pedido_id", "123456"), "distancia": 200, "tempo_estimado": 3}

def get_size_guide(params: Dict, room_id: str) -> Dict:
    """API de consulta de tamanhos"""
    return {"modelo": "amplo", "peso": params.get("peso", 100), "tamanho": "G"}

def generate_response(intent: str, tool_data: Dict) -> str:
    """Preencher modelo com dados da ferramenta"""
    template = RESPONSE_TEMPLATES[intent]
    if intent == "consultar_descontos":
        return template.format(tool_data["valor_minimo"], tool_data["desconto"], tool_data["brinde"])
    elif intent == "consultar_estoque":
        return template.format(tool_data["tamanho"], tool_data["quantidade"])
    elif intent == "consultar_status_entrega":
        return template.format(tool_data["pedido_id"], tool_data["distancia"], tool_data["tempo_estimado"])
    elif intent == "consultar_tamanho_produto":
        return template.format(tool_data["modelo"], tool_data["peso"], tool_data["tamanho"])
    else:
        return template

def live_ai_assistant(user_input: str, room_id: str) -> str:
    """Ponto de entrada principal do assistente"""
    # 1. Reconhecimento de intenção
    try:
        intent_result = recognize_intent(user_input, room_id)
        intent = intent_result["intent"]
        params = intent_result["params"]
    except Exception as e:
        return RESPONSE_TEMPLATES["outras_perguntas"]
    
    # 2. Roteamento por regras
    if intent in TOOL_API_MAPPING:
        tool_func = globals()[TOOL_API_MAPPING[intent]]
        tool_data = tool_func(params, room_id)
    else:
        tool_data = {}
    
    # 3. Geração de resposta
    response = generate_response(intent, tool_data)
    return response

# Teste
if __name__ == "__main__":
    user_input = "Eu tenho 120kg, qual tamanho eu uso?"
    room_id = "10086"
    res = live_ai_assistant(user_input, room_id)
    print(res)

Framework de Decisão: Quando Usar Regras Simples vs. Planejamento Complexo

Para determinar qual abordagem é mais adequada para seu cenário específico, utilize este framework de decisão:

1. Seu cenário tem fluxos bem definidos e passos previsíveis? → Regras Simples
2. A latência de resposta é crítica (menos de 2 segundos)? → Regras Simples
3. Os erros teriam consequências sérias para o negócio? → Regras Simples
4. Os inputs podem ser altamente variados ou imprevisíveis? → Planejamento Complexo
5. O tempo de resposta não é um fator crítico? → Planejamento Complexo
6. Os objetivos podem mudar dinamicamente durante a execução? → Planejamento Complexo

Arquiteturas Híbridas: O Melhor de Dois Mundos

Para muitos cenários, a abordagem ideal é uma arquitetura híbrida que combina o melhor das duas abordagens:

• Cobrir 80% dos cenários comuns usando regras simples (baixo custo, alta performance)
• Usar planejamento complexo para os 20% de casos de cauda longa (cobertura completa)
• Monitorar continuamente e converter casos de cauda longa comuns em regras

Conclusão

A Engenharia de Agentes AI está evoluindo de uma fase de "conceito" para uma fase de "implementação prática". A tendência futura será claramente o uso de "tecnologia adequada para o cenário apropriado", em vez de simplesmente empilhar tecnologias complexas.

Para a maioria das aplicações comerciais, especialmente aquelas com fluxos bem definidos, altas exigências de determinismo ou necessidade de baixa latência, regras simples oferceem ROI significativamente maior que planejamento complexo.