Extras: O Estado da Arte em Abril de 2026

Março de 2026 marca a primeira vez na história da IA em que três modelos mundialmente competitivos coexistem — cada um de um laboratório diferente, cada um com filosofia arquitetural distinta, e cada um com reivindicação credível de ser o melhor em algo importante. A era do "um modelo domina tudo" terminou.

O que mudou: Claude Opus 4.7 e agentic coding

O release de Claude Opus 4.7 em 18/04/2026 representa o maior salto em agentic coding do ano:

• CursorBench: 58% → 70% (ganho absoluto de 12 pontos percentuais).
• SWE-bench Verified: 72.5% — uma das maiores marcas já registradas para qualquer ferramenta de IA de codificação.
• Self-verification nativo: o modelo roda loops internos de verificação antes de emitir diffs, reduzindo erros "confiantes mas errados".
• Long-horizon autonomy: consegue sustentar tarefas autônomas por ~5 horas (contra ~1h de modelos de 2024).
• High-resolution vision: processa screenshots de IDEs, diagramas arquiteturais e UIs complexas com fidelidade muito maior.

A convergência do stack de coding com IA

Na primeira semana de abril de 2026, o ecossistema atingiu um marco simbólico: Cursor, Claude Code e Codex passaram a rodar juntos no mesmo workflow. Cursor lançou interface para orquestrar agentes paralelos; OpenAI publicou plugin oficial que roda dentro do Claude Code; early adopters começaram a combinar os três simultaneamente.

Em 2024, a habilidade mais valorizada era criar "prompts perfeitos". Em 2026, essa habilidade virou mesa: o diferencial agora é engenharia de contexto — a disciplina de estruturar, enriquecer e entregar dinamicamente o contexto certo para cada interação com o modelo.

As 4 estratégias canônicas (formalização da LangChain)

O framework mais robusto para prompts em 2026

A IBM consolidou, em pesquisa com milhares de equipes, que o framework mais confiável é Role + Context + Task + Format. Não é novidade conceitual, mas sua execução moderna incorpora context engineering em cada componente:

# ROLE
Você é um {role especializado e concreto}.
Público-alvo da sua resposta: {quem vai ler/consumir}.

# CONTEXT
{Contexto dinâmico — inclua APENAS o relevante para ESTA tarefa.
Se houver histórico longo, use a estratégia Compress: um sumário em
3-5 linhas do que importa.}

Variáveis pertinentes:
- {var_1}: {valor}
- {var_2}: {valor}

# TASK
{Ação única e concreta, com verbo forte.
Evite "pode me ajudar" — peça diretamente.}

Critérios de qualidade:
1. {critério verificável 1}
2. {critério verificável 2}

Restrições:
- NÃO {o que não fazer}
- NUNCA {o que é inaceitável}

# FORMAT
Retorne a resposta em {formato estruturado: JSON, markdown com seções nomeadas, tabela, etc}.
Exemplo de saída esperada:
{mostre um exemplo mínimo mas completo}

A organização de pesquisa METR mediu algo extraordinário: a duração máxima de tarefas que agentes autônomos conseguem completar com sucesso dobra a cada ~7 meses. Essa métrica — chamada de "task length horizon" — é a nova Lei de Moore da IA aplicada.

O terminal como interface para autonomia

Um dos achados mais inesperados da era agêntica é que o terminal emergiu como a interface universal para autonomia — pioneirada pelo Claude Code. Diferente de IDEs (que precisam de GUI), terminais são textuais, determinísticos, auditáveis e reproduzíveis. Isso os torna ideais para agentes.

O problema real: degradação após 35 minutos

Apesar da euforia, a maioria dos "agentes long-horizon" em 2026 ainda são loops frágeis que simplesmente não falharam ainda. Medições independentes mostram que todo agente sofre degradação de performance após ~35 minutos de tempo humano equivalente:

• Context pollution: histórico acumulado dilui atenção para o objetivo original.
• Error compounding: pequenos erros em etapa N se amplificam em N+1, N+2...
• Scope drift: o agente vai resolvendo "problemas relacionados" e se afasta do objetivo.
• Verificação insuficiente: sucesso local ≠ sucesso global do sistema.

O RAG tradicional que você estudou na disciplina 7 (recuperar chunks → injetar contexto → gerar resposta) é hoje considerado "RAG estático". A fronteira em 2026 é o Agentic RAG: um agente decide que perguntas fazer, quais ferramentas usar, quando parar — transformando recuperação de um passo fixo em um loop adaptativo.

A-RAG: hierarchical retrieval interfaces

O paper A-RAG: Scaling Agentic Retrieval-Augmented Generation via Hierarchical Retrieval Interfaces (arXiv 2026) propõe expor três tools de recuperação ao agente, permitindo que ele escolha a granularidade adequada:

Exemplo: Agentic RAG com OpenAI function calling

"""
Agentic RAG: o modelo decide quais ferramentas de busca chamar, quantas vezes
e em que ordem — não uma pipeline fixa.
"""
from openai import OpenAI
import json

client = OpenAI()

# ── Implementações dos "tools" de busca (stubs — você pluga seu vector store) ──
def keyword_search(query: str, k: int = 5) -> list[dict]:
    """Busca por BM25/keyword — rápida, boa para termos exatos."""
    # ... conectar ao ElasticSearch / OpenSearch / Tantivy
    return [{"doc_id": "d1", "snippet": "..."}]  # stub

def semantic_search(query: str, k: int = 5) -> list[dict]:
    """Busca vetorial — boa para sinônimos e conceitos."""
    # ... conectar ao Pinecone / Chroma / pgvector
    return [{"doc_id": "d2", "snippet": "..."}]  # stub

def chunk_read(doc_id: str, start: int, end: int) -> str:
    """Lê trecho específico de um documento já identificado."""
    # ... ler do object store
    return "conteúdo do trecho..."  # stub

# ── Schema OpenAI para os tools ──
TOOLS = [
    {"type": "function", "function": {
        "name": "keyword_search",
        "description": "Busca por termos EXATOS. Use para códigos, IDs, nomes próprios.",
        "parameters": {"type": "object", "properties": {
            "query": {"type": "string"}, "k": {"type": "integer", "default": 5}
        }, "required": ["query"]}
    }},
    {"type": "function", "function": {
        "name": "semantic_search",
        "description": "Busca semântica. Use para perguntas conceituais ou quando não sabe termos exatos.",
        "parameters": {"type": "object", "properties": {
            "query": {"type": "string"}, "k": {"type": "integer", "default": 5}
        }, "required": ["query"]}
    }},
    {"type": "function", "function": {
        "name": "chunk_read",
        "description": "Lê trecho específico de um documento. Use APÓS identificar doc_id via busca.",
        "parameters": {"type": "object", "properties": {
            "doc_id": {"type": "string"}, "start": {"type": "integer"}, "end": {"type": "integer"}
        }, "required": ["doc_id", "start", "end"]}
    }}
]

TOOL_MAP = {"keyword_search": keyword_search, "semantic_search": semantic_search, "chunk_read": chunk_read}

def agentic_rag(pergunta: str, max_iter: int = 6) -> str:
    """Loop de agentic RAG: modelo decide quando parar."""
    messages = [
        {"role": "system", "content": (
            "Você é um assistente que busca em múltiplas fontes antes de responder. "
            "Regras: (1) decida entre keyword_search, semantic_search e chunk_read com base na pergunta; "
            "(2) use chunk_read APÓS identificar docs relevantes; "
            "(3) quando tiver contexto suficiente, responda SEM chamar mais tools; "
            "(4) cite doc_ids na resposta final."
        )},
        {"role": "user", "content": pergunta}
    ]

    for i in range(max_iter):
        resp = client.chat.completions.create(
            model="gpt-4o",        # ou claude via litellm
            messages=messages,
            tools=TOOLS,
            tool_choice="auto"     # o modelo decide — não forçamos
        )
        msg = resp.choices[0].message
        messages.append(msg)

        # Se o modelo não pediu tool, é resposta final
        if not msg.tool_calls:
            return msg.content

        # Executa cada tool_call solicitado
        for call in msg.tool_calls:
            fn = TOOL_MAP[call.function.name]
            args = json.loads(call.function.arguments)
            resultado = fn(**args)
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": json.dumps(resultado, default=str)
            })
        print(f"[iter {i+1}] Tools chamados: {[c.function.name for c in msg.tool_calls]}")

    return "⚠️ Atingi limite de iterações sem resposta final."

# ── Execução ──
if __name__ == "__main__":
    print(agentic_rag("Qual foi a decisão sobre mensageria no ADR-023 e por que rejeitamos Kafka?"))

Um dos maiores deslocamentos de paradigma de 2024→2026 foi a separação de modelos de conversação (Claude Sonnet, GPT-4o) de modelos de raciocínio (o-series da OpenAI, thinking mode da Claude, Gemini "Deep Think"). Eles pensam antes de responder.

O que mudou conceitualmente

Em modelos tradicionais, o custo computacional é no treinamento; no inference time, o modelo gera uma resposta rapidamente. Em reasoning models, um orçamento de "thinking" (milhares a dezenas de milhares de tokens ocultos) é gasto antes de emitir a resposta visível — o modelo gera e descarta hipóteses internamente.

Quando usar cada um (heurística de 2026)

• Conversação: respostas rápidas, UX interativa, classificação, extração simples, RAG básico.
• Reasoning: planejamento de projetos, depuração de código complexo, provas matemáticas, estratégia de negócio, análise causal.
• Híbrido: um supervisor "conversacional" chama um reasoning como sub-agente apenas quando a tarefa precisa. Economiza custo e latência.

MCP Roadmap 2026 — do protocolo hacker ao padrão enterprise

O Model Context Protocol saiu, em 2026, da fase "protocolo para early adopters" para maturidade enterprise. As 4 frentes do roadmap 2026:

A2A: agora sob guarda da Linux Foundation

O protocolo Agent-to-Agent do Google (introduzido em abril/2025) foi doado à Linux Foundation em junho de 2025. Em 2026, os marcos-chave:

• Adoção massiva: 150+ organizações. Deployments de produção em Microsoft, AWS, Salesforce, SAP, ServiceNow.
• A2A v1.0: estável, com Signed Agent Cards — cada agent card agora tem assinatura criptográfica verificável pelo domínio emissor. Essencial para trust entre agentes de organizações distintas.
• AP2 (Agent Payment Protocol): extensão formal para transações econômicas entre agentes. Agentes pagam uns aos outros por serviços sem humano no meio.
• Modalidade-agnóstico: já suporta áudio e vídeo streaming, não apenas texto/JSON.

Em abril de 2026, o AWS DevOps Agent foi promovido de Preview para GA. É um dos primeiros agentes operacionais da AWS que investigam incidentes autonomamente, correlacionando telemetria, código e runbooks.

Capacidades reais em produção (Abr/2026)

Diferença crítica: Copilot vs Agente vs Autopilot

A OWASP Foundation publicou a atualização 2026 do Top 10 para LLM Applications. Spoiler: prompt injection permanece em #1 — apareceu em 73% dos deployments de IA em produção. A má notícia é que guardrails de vendor mitigam, mas não eliminam o risco.

Os 10 riscos (edição 2026)

Abordagem defense-in-depth (a única que funciona)

O consenso de 2026 é claro: assuma que prompt injection eventualmente vai ter sucesso. Projete para conter o impacto, não apenas prevenir a entrada:

• Least privilege: agente só acessa o que precisa para a tarefa. Prefira tokens de sessão limitados a credenciais admin.
• Output validation: sanitize tudo que sai do LLM antes de executar ou renderizar.
• Separation of instructions and data: system prompt fica em canal protegido; user input em canal "untrusted".
• Logging e auditoria: toda chamada, tool, permissão usada — com retention adequada para forensics.
• Detecção: use Rebuff (heurística + classificador LLM + vector DB de ataques conhecidos) ou NVIDIA NeMo Guardrails (linguagem Colang para regras).

Em 2026, a diferença mais evidente entre times que colocam IA em produção e times que ficam em eterno PoC é evaluations. Sistemas não-determinísticos exigem medição contínua; sem evals, você não sabe se está melhorando ou piorando.

Os 4 níveis de evaluation (maturidade)

Ferramentas essenciais em 2026

Enquanto Claude e GPT disputam o topo, um movimento paralelo está silenciosamente ganhando tração: Small Language Models (SLMs) de 1-8 bilhões de parâmetros, ajustados para tarefas específicas, rodando em CPUs/GPUs modestas, com custo 100-1000x menor.

Por que SLMs voltaram em 2026

• Economia: em aplicações com milhões de chamadas/dia, o custo de LLMs frontier vira proibitivo. SLM fine-tuned para a tarefa resolve 90% dos casos a 5% do custo.
• Latência: SLM local responde em 50-200ms. GPT-4o+thinking pode levar 10-30s. UX ruim.
• Privacidade: dados sensíveis (saúde, jurídico, defesa) não podem sair da rede. SLM on-premise é a única opção.
• Hardware acessível: roda em laptop (Llama 3.2 3B, Phi-3, Gemma 2), em edge (Jetson), e até em browser (via WebGPU).

O padrão híbrido: Router + SLMs + LLM frontier

"""
Arquitetura híbrida: router classifica a tarefa e escolhe o modelo certo.
- Tarefas simples e de alto volume → SLM local/barato
- Tarefas complexas e raras       → LLM frontier
Economia típica: 70-90% de redução de custo vs. usar só frontier.
"""
from openai import OpenAI
import ollama  # para SLMs locais via Ollama

client = OpenAI()

# ── Classificador de complexidade (um LLM pequeno e rápido) ──
def classificar(pergunta: str) -> str:
    """Retorna: 'simple', 'moderate', 'complex'."""
    resp = client.chat.completions.create(
        model="gpt-4o-mini",  # barato, classificação é fácil
        temperature=0,
        messages=[
            {"role": "system", "content": (
                "Classifique a complexidade da pergunta. Retorne APENAS uma palavra: "
                "'simple' (factual, extração), 'moderate' (explicação, resumo), "
                "'complex' (raciocínio multi-step, planejamento, código não-trivial)."
            )},
            {"role": "user", "content": pergunta}
        ]
    )
    return resp.choices[0].message.content.strip().lower()

# ── Roteamento ──
def responder(pergunta: str) -> tuple[str, str]:
    """Retorna (resposta, modelo_usado)."""
    complexidade = classificar(pergunta)

    if complexidade == "simple":
        # SLM local — Ollama rodando Llama 3.2 3B
        r = ollama.chat(model="llama3.2:3b", messages=[{"role":"user","content":pergunta}])
        return r["message"]["content"], "llama3.2-3b (local)"

    elif complexidade == "moderate":
        # Mid-tier: gpt-4o-mini ou Claude Haiku
        r = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role":"user","content":pergunta}]
        )
        return r.choices[0].message.content, "gpt-4o-mini"

    else:  # complex
        # Frontier: gpt-4o ou Claude Opus
        r = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role":"user","content":pergunta}]
        )
        return r.choices[0].message.content, "gpt-4o"

# ── Teste ──
if __name__ == "__main__":
    perguntas = [
        "Qual a capital da Austrália?",                                        # simple
        "Resuma em 3 bullets os prós e contras de microserviços.",             # moderate
        "Projete a arquitetura de um sistema de pagamentos para 10M tx/dia.",  # complex
    ]
    for p in perguntas:
        resposta, modelo = responder(p)
        print(f"\n❓ {p}\n🤖 [{modelo}]: {resposta[:200]}...")

Fine-tuning voltou à moda (mas diferente)

Em 2023, fine-tuning era a bala de prata. Em 2024, RAG matou fine-tuning ("apenas inject context"). Em 2026, a síntese: RAG para conhecimento, fine-tuning para comportamento. Use fine-tuning quando:

• Você quer consistência de formato/tom que prompts não garantem.
• Domínio tem jargão especializado que embeddings genéricos não capturam bem.
• Você precisa de um SLM que compete com LLM frontier em uma tarefa específica.
• Você tem 500-5000 exemplos de alta qualidade do output desejado.

A era da "IA sem rédeas" terminou oficialmente em 2026. O EU AI Act está em vigor para sistemas de alto risco; China tem regras estritas para IA generativa pública; EUA avançam em regulação setorial (finanças, saúde). Ignorar compliance hoje é ignorar responsabilidade legal.

Classificação de risco no EU AI Act

O que significa para desenvolvedores

• Documentação obrigatória — para sistemas de alto risco, model cards, data sheets, limitações conhecidas.
• Audit trails — logar decisões do modelo, entradas, saídas, versionamento do modelo usado.
• Human in the loop — decisões de alto impacto precisam de supervisão humana verificável.
• Transparência em conteúdo gerado — watermarking e labeling de conteúdo IA (deepfakes regulamentados).
• Direito à explicação — usuários podem exigir explicação sobre decisões que os afetam.

A disciplina 8 cobriu ADK, LangChain e conceitos gerais. Em 2026, o mercado se consolidou em três frameworks de agentes dominantes — cada um com filosofia distinta. A escolha não é religiosa: é baseada em caso de uso.

Trade-off de custo: cuidado com AutoGen em volume

Um ponto pouco discutido: o GroupChat do AutoGen consome tokens exponencialmente. Cada turno envolve uma chamada LLM completa com histórico acumulado. Um debate de 4 agentes por 5 rodadas = 20 chamadas mínimas, cada uma maior que a anterior. Para tarefas de alto volume ou tempo real, AutoGen sai caro.

Você não pode (e nem deve) estudar tudo. Baseado na conjuntura de abril/2026, priorize os seguintes temas em ordem de alavancagem para a carreira — do maior ROI para o menor.

Fontes semanais recomendadas