Apostila: Claude Fable 5 — Guia Completo para Uso Otimizado

Baseada na transcrição do keynote "Code with Claude" (Tokyo) e na documentação oficial da Anthropic (platform.claude.com), julho de 2026.

Aviso importante sobre o nome "Fable 5"

Antes de começar, um esclarecimento essencial: Fable 5 (nome completo: Claude Fable 5) não é um dispositivo físico ou hardware — é o modelo de IA de 5ª geração da Anthropic, irmão do Claude Mythos 5, lançado em 2026 como o modelo generativo mais capaz já disponibilizado publicamente pela empresa. Ele é acessado via Claude.ai, Claude Code, Claude Desktop, API e plataformas parceiras (AWS, Google Cloud, Microsoft Foundry). Esta apostila trata de como usar esse modelo/ferramenta de forma otimizada, cobrindo prompting, controle de custo/qualidade (effort), engenharia de contexto, arquitetura de agentes e casos de uso práticos apresentados no evento.

Sumário

1. O que é o Claude Fable 5 e por que ele é diferente
2. A "Curva de Capacidade": como os modelos evoluíram
3. Effort (Esforço): o principal dial de custo × qualidade
4. Como escrever prompts eficazes para o Fable 5
5. Engenharia de Contexto: mantendo o agente eficiente
6. Prompt Caching: economia de até 90%
7. Estratégia "Advisor": modelos baratos + Fable 5 como consultor
8. Claude Code: recursos avançados para desenvolvedores
9. Claude Managed Agents: infraestrutura para agentes em produção
10. Segurança e Safeguards do Fable 5
11. Casos de uso práticos (demonstrados no evento)
12. Checklist rápido de otimização
13. Glossário de termos

1. O que é o Claude Fable 5 e por que ele é diferente

Claude Fable 5 foi apresentado como o modelo mais capaz já lançado ao público geral pela Anthropic, construído sobre as mesmas fundações do Claude Mythos 5 (modelo de acesso restrito, voltado a parceiros avançados de pesquisa em segurança). Segundo a keynote:

• É o líder no benchmark SWE-Bench Pro (avaliação de tarefas reais de engenharia de software), mas o número do benchmark subestima a real diferença de capacidade — quanto mais longa e complexa a tarefa, maior a vantagem do Fable 5 sobre outros modelos.
• Correção na primeira tentativa (single-shot correctness): dado um problema complexo e bem especificado, o Fable 5 tende a acertar de primeira. Testadores relataram que um único prompt gerou trabalho que antes levava dias ou semanas de um time inteiro.
• Autonomia de longo horizonte: consegue rodar por dias em um único objetivo, mantendo coerência e lembrando especificações mesmo em tarefas que somam milhões de tokens, além de conseguir delegar e supervisionar subagentes de forma mais confiável e econômica que os modelos anteriores.
• Melhor leitor de código, não só escritor: é superior na triagem de incidentes ("outages"), na investigação do histórico de repositórios e na sugestão proativa de melhorias.
• Visão de última geração: interpreta imagens técnicas densas, aplicações web, gráficos e diagramas com precisão muito superior às versões anteriores do Claude.
• Trabalho corporativo de ponta a ponta: lida bem com tarefas "sujas" e multi-frentes (análises financeiras, documentos, planilhas, slides), seguindo instruções e permanecendo dentro do escopo, com qualidade "profissional" no resultado final.

Takeaway didático: não teste o Fable 5 apenas nas tarefas simples que você já dava para modelos antigos — isso subestima sua capacidade real. A recomendação oficial é "comece pelo topo da sua faixa de dificuldade": dê a ele o problema mais difícil que você tem, deixe-o escopar, fazer perguntas de esclarecimento e executar.

2. A "Curva de Capacidade": como os modelos evoluíram

Este é o pano de fundo estratégico apresentado na keynote, essencial para entender como pensar ao usar o Fable 5:

No benchmark interno SWE-Bench Verified, a evolução foi de ~62% (Sonnet 3.7) para 88% (Opus 4.8), e o benchmark está saturado nos modelos Fable/Mythos — ou seja, ele já não diferencia mais bem os melhores modelos, sinal de que é hora de criar avaliações (evals) mais difíceis.

Três eixos de ganho de inteligência que você deve explorar

1. Planejar antes de agir. Modelos antigos agiam como "montar móvel do IKEA sem ler o manual": pulavam direto para a execução e corrigiam depois. Os modelos atuais primeiro elaboram um plano/spec, capturam erros durante o planejamento (você verá o modelo dizer "actually" ou "never mind" no raciocínio) e executam de forma mais eficiente já na primeira tentativa. - Ação prática: dê espaço para o modelo pensar. Use adaptive thinking e um effort mais alto quando a tarefa exigir planejamento.

2. Recuperação de erros e autocorreção. O antigo "doom looping" — o modelo falha, você dá feedback, ele tenta de novo e comete o mesmo erro repetidamente — está muito reduzido. Hoje o modelo reage ao feedback do ambiente e muda de abordagem. - Ação prática: desenhe seu ambiente para dar feedback real ao modelo (testes, logs de erro, resultados de ferramentas) para que ele possa se autocorrigir.

3. Horizontes mais longos. Os modelos sustentam atenção e coerência por até ~1 milhão de tokens (às vezes mais), sem "perder o fio" da tarefa. - Ação prática: você não precisa mais fatiar tanto o contexto. Dê tarefas mais ambiciosas — entregue a base de código inteira, não apenas um arquivo.

O ciclo resultante de um agente moderno é: Planejar → Executar → Verificar → Ajustar o plano → repetir até satisfazer o critério de sucesso.

3. Effort (Esforço): o principal dial de custo × qualidade

O parâmetro effort é o controle central para equilibrar inteligência, latência e custo no Fable 5. Ele afeta todos os tokens da resposta — texto, chamadas de ferramentas e raciocínio interno (thinking).

Níveis disponíveis

Recomendações específicas para o Fable 5

• Comece em high (o padrão) para a maioria das tarefas.
• Use xhigh apenas para as cargas de trabalho mais sensíveis à capacidade.
• Reduza para medium/low em trabalho rotineiro — no Fable 5, esses níveis "mais baixos" ainda superam frequentemente o xhigh de modelos anteriores.
• Ao usar high/xhigh, configure um max_tokens grande: é um limite rígido sobre o total de saída (raciocínio + texto de resposta).
• Reduza o effort se a tarefa terminar corretamente mas demorar mais do que o necessário, ou se você quiser um estilo de trabalho mais rápido e interativo.

Dica prática: effort é um sinal de comportamento, não uma cota fixa de tokens. Em low, o modelo ainda vai "pensar" em problemas suficientemente difíceis — só pensa menos do que pensaria em high para o mesmo problema.

4. Como escrever prompts eficazes para o Fable 5

O Fable 5 segue instruções de forma muito mais robusta que gerações anteriores, o que muda a forma de escrever prompts. Segundo a documentação oficial de prompting, os padrões abaixo resolvem os ajustes mais comuns:

4.1 Evite "over-planning" em tarefas longas

Em tarefas difíceis com effort alto, uma requisição pode rodar por muitos minutos, e execuções autônomas podem se estender por horas. Para evitar que o modelo fique deliberando/planejando além do necessário:

Quando você tiver informação suficiente para agir, aja. Não re-derive fatos já
estabelecidos na conversa, não questione novamente uma decisão que o usuário já
tomou, nem narre opções que você não vai seguir em mensagens voltadas ao usuário.
Se estiver ponderando uma escolha, dê uma recomendação, não um levantamento
exaustivo. Isso não se aplica a blocos de raciocínio (thinking).

4.2 Evite refatoração/limpeza não solicitadas em effort alto

Não adicione funcionalidades, refatore ou introduza abstrações além do que a tarefa
exige. Uma correção de bug não precisa de limpeza ao redor, e uma operação pontual
geralmente não precisa de uma função auxiliar. Não projete para requisitos
hipotéticos futuros: faça a coisa mais simples que funcione bem. Evite abstração
prematura e implementações incompletas. Não adicione tratamento de erro, fallback
ou validação para cenários que não podem ocorrer. Confie nas garantias internas do
código e do framework. Valide apenas nas fronteiras do sistema (entrada do usuário,
APIs externas). Não use feature flags ou shims de retrocompatibilidade quando você
pode simplesmente mudar o código.

4.3 Instruções curtas em vez de listas exaustivas

Como o Fable 5 segue instruções muito bem, uma frase curta orienta o comportamento tão bem quanto uma lista extensa de regras. Exemplo para evitar respostas excessivamente elaboradas:

Comece pelo resultado. Sua primeira frase, ao terminar, deve responder "o que
aconteceu" ou "o que eu encontrei": a coisa que o usuário pediria se dissesse "só
me dá o resumo". Detalhes de apoio e raciocínio vêm depois. Ser legível e ser
conciso são coisas diferentes; a legibilidade importa mais.

E para controlar quando o agente deve parar e pedir ajuda:

Pare para o usuário apenas quando o trabalho realmente exigir isso: uma ação
destrutiva ou irreversível, uma mudança real de escopo, ou uma informação que só
ele pode fornecer. Se você encontrar um desses casos, pergunte e encerre o turno,
em vez de terminar com uma promessa (de que fará depois).

4.4 Combata relatórios de progresso fabricados

Em execuções longas e autônomas, é comum um modelo "inventar" que completou algo. A instrução abaixo praticamente eliminou esse problema nos testes internos da Anthropic:

Antes de relatar progresso, audite cada afirmação contra um resultado de ferramenta
desta sessão. Relate apenas trabalho que você pode apontar evidência; se algo ainda
não foi verificado, diga isso explicitamente. Relate os resultados com fidelidade:
se os testes falharem, diga isso com o output; se uma etapa foi pulada, diga isso;
quando algo estiver feito e verificado, afirme isso claramente, sem hesitação.

4.5 Defina limites explícitos de ação

O Fable 5 pode, ocasionalmente, tomar ações não solicitadas (redigir um e-mail que ninguém pediu, criar branches "de segurança" no git). Defina fronteiras claras:

Quando o usuário estiver descrevendo um problema, fazendo uma pergunta, ou
pensando em voz alta em vez de pedir uma mudança, o entregável é a sua avaliação.
Relate suas descobertas e pare. Não aplique uma correção até que peçam. Antes de
rodar um comando que muda o estado do sistema (reinícios, exclusões, edição de
config), verifique se a evidência realmente sustenta aquela ação específica. Um
sinal que parece bater com uma falha conhecida pode ter uma causa diferente.

4.6 Use subagentes paralelos com liberdade

O Fable 5 despacha subagentes com mais facilidade que modelos anteriores. Dê orientação explícita sobre quando delegar e prefira comunicação assíncrona:

Delegue subtarefas independentes a subagentes e continue trabalhando enquanto
eles rodam. Intervenha se um subagente sair dos trilhos ou estiver sem contexto
relevante.

4.7 Construa um sistema de memória

O Fable 5 tem desempenho particularmente bom quando pode registrar lições de execuções anteriores. Basta um arquivo Markdown como bloco de notas:

Registre uma lição por arquivo, com um resumo de uma linha no topo. Registre tanto
correções quanto abordagens confirmadas, incluindo por que importaram. Não salve o
que o repositório ou o histórico de chat já registram; atualize uma nota existente
em vez de duplicar; apague notas que se mostraram erradas.

Para popular esse sistema a partir do histórico:

Reflita sobre as sessões anteriores que tivemos juntos. Use subagentes para
identificar os temas centrais e as lições, e armazene-as em [X]. Garanta que você
saiba consultar [X] no futuro.

4.8 Recomendações gerais de "scaffolding" (andaime/arquitetura do prompt)

• Comece pelo topo da sua faixa de dificuldade: dê ao Fable 5 uma tarefa mais difícil do que você daria a modelos anteriores, deixando-o escopar, perguntar e executar.
• Torne a auto-verificação explícita em prompts de execução longa. Subagentes verificadores com contexto limpo tendem a superar a autocrítica simples: Estabeleça um método de verificar seu próprio trabalho a cada [X] enquanto você constrói. Rode isso a cada intervalo de [X], verificando seu trabalho com subagentes contra a especificação.
• Refatore prompts e skills antigas. Skills feitas para modelos anteriores costumam ser excessivamente prescritivas para o Fable 5 e podem piorar o resultado. Revise e remova instruções antigas quando o desempenho padrão já for melhor sem elas.
• Não peça para o Claude reproduzir o raciocínio na resposta. Instruções que pedem para "ecoar", transcrever ou explicar o raciocínio interno como texto de resposta podem disparar a categoria de recusa reasoning_extraction, causando fallback indesejado para o Opus 4.8. Se sua aplicação precisa de visibilidade do raciocínio, leia os blocos estruturados de thinking (adaptive thinking) em vez disso.
• Crie uma ferramenta "send-to-user" para agentes longos e assíncronos, que entrega mensagens ao usuário literalmente (verbatim) sem encerrar o turno — útil para atualizações de progresso ou entregas parciais.

5. Engenharia de Contexto: mantendo o agente eficiente

Context engineering é a disciplina de decidir o que entra no contexto do Claude — o suficiente para boas decisões, mas nada que distraia, encareça ou desacelere o agente. Três técnicas centrais apresentadas no evento:

5.1 Tool Search Tool

Problema: muitos agentes têm 10, 20 ou até 100+ ferramentas. Carregar todas as definições no contexto consome espaço enorme, mesmo que a maioria das execuções use apenas ~10% delas — você paga em custo e latência por ferramentas que nem usa.

Solução: carregue apenas uma ferramenta no início — a tool search tool. Quando o modelo precisa de uma ferramenta, ele primeiro pergunta à tool search tool ("você tem uma ferramenta para X?"), que busca no inventário e carrega só a ferramenta certa naquele momento.

Resultado real (cliente Lovable): redução de 10% no uso de tokens e melhora de desempenho — porque, com menos "ruído" de definições no contexto, o julgamento do modelo melhora.

5.2 Programmatic Tool Calling (Chamada Programática de Ferramentas)

Problema: você quer que as ferramentas retornem bastante dado (para o modelo ter o que precisar), mas se uma ferramenta retorna, digamos, 100 e-mails e você só precisava do cabeçalho de um deles, todo aquele volume de dado desnecessário lota o contexto.

Solução: o modelo escreve código que processa o resultado bruto da ferramenta e extrai só o trecho necessário (ex.: 2-5% do dado retornado), colocando apenas esse recorte no contexto — em vez do payload inteiro.

Resultado real (cliente Quora): ao aplicar isso para chamadas de HTML pesado, o desempenho do agente melhorou substancialmente.

5.3 Compaction (Compactação de Contexto)

Problema: mesmo com as duas técnicas acima, agentes muito ambiciosos que rodam por horas ou dias eventualmente esgotam o contexto.

Solução: você define um limiar (ex.: usar só 400-500K dos 1M de tokens de contexto). Quando o contexto se aproxima desse limiar, a execução pausa, outro modelo resume toda a transcrição (removendo resultados intermediários de ferramentas que já cumpriram seu papel), o contexto é limpo e substituído por esse resumo enxuto, e o agente retoma exatamente de onde parou, de forma transparente para o usuário.

Resultado real (cliente Hex): já tinham implementado uma versão própria e puderam remover 300 linhas de código de manutenção ao adotar a solução nativa.

Demonstração ao vivo (o "Hero Corp Dashboard")

No evento, um dashboard fictício de CEO com 4 objetivos de negócio, ao rodar sem essas técnicas, esgotou 1 milhão de tokens de contexto processando apenas 1 dos 4 objetivos. Após habilitar tool search tool + programmatic tool calling + compaction juntos, o agente conseguiu carregar todos os 4 objetivos com um contexto final muito menor.

Takeaway prático: se seu agente "esgota o contexto" antes de terminar a tarefa, comece verificando (nesta ordem): (1) quantas ferramentas você carrega de uma vez, (2) quanto dado bruto as ferramentas retornam sem filtro, (3) se você tem um mecanismo de compaction configurado.

6. Prompt Caching: economia de até 90%

Em aplicações agenticas de longa duração, há muitas chamadas de ferramenta, muitos turnos de usuário e transcrições longas — e cada requisição repete trechos longos do prompt anterior. Recomputar isso do zero a cada chamada é caro e lento.

Como funciona: a Anthropic pré-computa e armazena (server-side) os valores intermediários (KV cache) da parte compartilhada do contexto. Na requisição seguinte, você só paga pelo "delta" pequeno em relação à anterior.

Benefícios

• Desconto de 90% nos tokens cacheados (você paga só 10% do custo normal).
• Tempos de resposta mais rápidos.
• Rate limits não são afetados por tokens cacheados — eles não contam contra seu limite de taxa.

Como saber se você está aproveitando bem

• No Cloud Console / Developer Console, existe um dashboard que reporta sua taxa de acerto de cache (cache hit rate).
• Clientes como Perplexity, Cursor e Replit investiram engenharia significativa para chegar em taxas muito altas — a ponto de, sem isso, a Anthropic não conseguir sequer servir a carga de trabalho deles.
• Meta recomendada: mire em 80%+ de cache hit rate. No exemplo demonstrado ao vivo, um agente com apenas 56% de cache hit foi identificado como "com espaço claro para melhoria".

Como melhorar rapidamente

1. Verifique o dashboard de cache hit rate no console.
2. Use a Cloud API skill, instalada por padrão no Claude Code — basta abrir o projeto e pedir: "melhore minha taxa de acerto de cache". A skill sabe adicionar os cache_control headers e ajustar a estrutura do prompt automaticamente.

Na demonstração ao vivo, uma única mudança levou o cache hit rate de 0% para 58% instantaneamente.

7. Estratégia "Advisor": modelos baratos + Fable 5 como consultor

Essa é uma das técnicas de otimização de custo mais valiosas apresentadas no evento.

A analogia

Um engenheiro júnior fica muito mais produtivo quando pode consultar um engenheiro sênior de vez em quando (revisão de código, dúvidas pontuais) — e isso custa pouco tempo ao sênior. O mesmo vale para modelos: um modelo pequeno e barato (Haiku, Sonnet) fica muito mais inteligente se puder consultar um modelo maior (Opus, ou o próprio Fable 5) como "advisor" (conselheiro) em momentos-chave.

Por quê isso funciona

Modelos pequenos como Haiku/Sonnet já são muito bons em: - Escrever código - Fazer chamadas de ferramentas (tool calling)

O que eles ainda não fazem tão bem é raciocínio profundo e perspicaz. Então, deixe o modelo pequeno fazer o trabalho de rotina (mais barato) e chame o Opus/Fable apenas quando for necessária uma reflexão mais profunda — pagando o custo maior só nesses pontos pontuais.

Exemplo real demonstrado (Hero Corp / "Metropolis deal")

No demo, o agente rodando em Sonnet analisava transcrições de reuniões (via Gong) e classificara um negócio como "no caminho certo" (verde). Ao consultar o Opus como advisor, o Opus identificou, no meio da transcrição, que o prefeito de "Metropolis" havia pedido explicitamente um item específico ("cryothane") que a equipe de contas não havia providenciado — e recategorizou o item como "em risco" (vermelho). Resultado: economia de custo com Sonnet fazendo o trabalho de rotina, mas mantendo a qualidade de raciocínio de nível Opus/Fable exatamente onde importava.

Quando usar

• Aplicações de alto volume onde rodar Fable 5/Opus o tempo todo seria proibitivamente caro.
• Casos onde o custo de um erro é alto (ex.: decisões que impactam negócio, dados que vão para um CEO), então você não pode simplesmente trocar para um modelo mais barato sem rede de segurança.
• Fable 5 custa aproximadamente 2x o preço do Opus — usá-lo como advisor pontual, e não como motor principal, é uma forma de acessar seu raciocínio superior por uma fração do custo total.

8. Claude Code: recursos avançados para desenvolvedores

O Claude Code evoluiu de uma CLI simples para um ecossistema completo. Principais superfícies e recursos, na ordem em que foram introduzidos:

8.1 Superfícies de interação

A extensão de IDE e o app Desktop são construídos sobre o Claude Agent SDK, o mesmo SDK disponível para você construir suas próprias integrações.

8.2 Recursos criados a partir de feedback de usuários

8.3 Auto Mode

Um classificador que decide quais ações são seguras para o Claude tomar de forma autônoma, sem precisar de aprovação manual a cada passo — permitindo que hoje muitos desenvolvedores só revisem depois que o Claude já testou as mudanças e abriu um PR pronto para revisão. Antes, era comum revisar cada edição individual; hoje, delega-se a permissão e verifica-se o resultado final.

8.4 "Multi-Claudeing"

Termo carinhoso dado pelos próprios usuários ao hábito de rodar múltiplas instâncias do Claude Code em paralelo. As novas interfaces (Desktop e Agents View) foram criadas justamente para facilitar esse padrão de uso.

8.5 Caso de uso demonstrado: localização de site (Dynamic Workflows)

Cenário fictício: a empresa "Kaizen Operations" tem um site de marketing só em inglês e precisa lançar em 13 mercados adicionais (13 idiomas).

• Abordagem sequencial (um agente por vez): cada tradução levou ~3 minutos; fazer as 13 sequencialmente levaria quase 1 hora, com muito prompting manual.
• Abordagem com Dynamic Workflows: um único prompt pede ao Claude para criar um workflow repetível e rodar as 13 traduções em paralelo. Resultado: 12 (depois 13) agentes de tradução rodando simultaneamente, seguidos por mais 12 agentes de verificação automática da qualidade de cada tradução — tudo disparado por um único prompt, e o workflow pode ser salvo como código JavaScript para reuso futuro.

Aplicabilidade geral: este padrão (workflow paralelo e determinístico) serve para migrações em larga escala, auditorias de base de código inteira, ou otimizações de performance — qualquer trabalho grande que exija rodar muitos agentes ao mesmo tempo.

8.6 Resultados corporativos citados

• Spotify: migrou milhares de repositórios usando um agente de background sobre o Claude Agent SDK, que lê um plano de migração em linguagem natural e dispara uma frota de agentes que abre PRs. Resultado: mais de 1.000 PRs mesclados por mês em produção, com redução de 90% no tempo de migração.
• Mercari (marketplace japonês): todo o time de engenharia roda sobre o Claude Code, com aumento de 90% na produção de engenharia ano a ano.
• Internamente na Anthropic: engenheiros produzem, em média, 8x mais código do que anos atrás, mesmo com o time de engenharia tendo crescido substancialmente. Mais de 80% do código interno é mesclado (merged) pelo próprio Claude.

9. Claude Managed Agents: infraestrutura para agentes em produção

Enquanto o Claude Code foca em "agentes que escrevem código para você", o Claude Managed Agents é a plataforma para construir e operar agentes que você entrega aos seus próprios clientes/usuários finais, com infraestrutura, primitivas agenticas e observabilidade prontas de fábrica.

9.1 Por que essa plataforma existe (dores identificadas em pesquisa)

1. Gerenciamento de contexto é difícil de ajustar — contexto na hora errada distrai o agente.
2. Infraestrutura é citada por metade dos desenvolvedores como o principal bloqueador de produção: cargas de trabalho "em rajada" (bursty), padrões de computação imprevisíveis, dificuldade em escalar com segurança e atingir metas de latência.
3. Observabilidade é genuinamente difícil: como saber se seu agente está produzindo outputs de qualidade, dado que são modelos não-determinísticos gerando grandes volumes de dado não estruturado?

9.2 Blocos de construção fundamentais

9.3 Tipos de eventos

• User events: o que você envia para guiar o agente.
• Agent events: o que o agente está fazendo — mensagens, execução de ferramentas, compactação de contexto, delegação a outros agentes.
• Session events: ciclo de vida geral, transições de status, erros, processo de conclusão.
• Span events: agrupam eventos relacionados para visão agregada/instrumentada.

9.4 Recursos avançados

• Multi-agent orchestration: o Claude delega tarefas a outros agentes com janelas de contexto independentes, paralelizando trabalho complexo.
• Outcomes: o Claude itera sobre um critério de saída (rubric) pré-definido até satisfazer o objetivo — você define a meta, o Claude cuida de completá-la.
• Memory: o Claude lê e escreve em armazenamentos de memória. Sem memória, cada sessão começa do zero; com ela, o agente tem consciência de execuções anteriores e melhora ao longo do tempo.
• Dreaming: construído sobre a memória — o Claude reflete e "codifica" aprendizados em novas memórias, garantindo que ele sempre comece com um conjunto mais enxuto e otimizado de memórias.
• Self-hosted sandboxes: rode o loop do agente e a execução de ferramentas diretamente na sua infraestrutura — arquivos e pacotes nunca saem do seu perímetro.
• MCP tunneling: o Claude acessa servidores MCP privados que você não quer expor à internet aberta.
• Scheduled deployments: configure uma agenda recorrente para disparar novas sessões automaticamente (trabalho recorrente sem intervenção manual).
• Environment variables em Vaults: forneça credenciais seguras para APIs/CLIs que o Claude precisa chamar, sem que o Claude jamais veja o token real — um placeholder opaco é colocado no container, e o Claude o usa como faria com qualquer variável de ambiente comum.

9.5 Estudo de caso demonstrado: "Pascal" (agente de analytics)

Um agente que analisa dados hipotéticos de um serviço de entrega de mercado (grocery delivery), usando um dataset pré-carregado e scripts Python instalados no container. Produz analytics em minutos, e todos os eventos são visíveis no Cloud Console, com a possibilidade de conversar com um "agente de debug" para otimizar ainda mais a integração.

Insights que o agente Pascal encontrou automaticamente: - Bananas são o produto mais popular. - Domingo à tarde é o horário de pico de pedidos online (considerar reagendar campanhas/promoções para esse período). - Um simulador de previsão foi montado para estimar a probabilidade de recompra de um cliente.

Ao rodar uma análise da própria sessão, o Claude identificou que alguns scripts fornecidos eram lentos, sugerindo otimização do código Python.

9.6 Como começar a interagir com o Claude Managed Agents

1. Cloud API skill (instalada por padrão no Claude Code): basta pedir "quero começar a usar o Claude Managed Agents" e ele conduz o onboarding na sua base de código existente.
2. NCLI (recém-lançada): facilita interagir com as APIs via scripts, pipelines de CI/CD.
3. Documentação e cookbooks: exemplos práticos e prontos para copiar/colar dos padrões mais comuns.

10. Segurança e Safeguards do Fable 5

Um modelo desse nível de capacidade traz riscos proporcionais. A Anthropic implementou classificadores de segurança específicos:

• Domínios monitorados: cibersegurança ofensiva (construção de exploits, malware, ferramentas de ataque), biologia e ciências da vida (métodos de laboratório, mecanismos moleculares) e tentativas de extração do raciocínio resumido do modelo.
• Como funciona o fallback: quando uma requisição toca esses temas, o Fable 5 reencaminha automaticamente para o próximo modelo mais capaz, o Claude Opus 4.8. A resposta é claramente identificada como vinda do Opus, e você é cobrado no preço do Opus (não do Fable).
• Trabalho legítimo pode ser bloqueado por engano: a Anthropic reconhece que pesquisadores fazendo trabalho legítimo nessas áreas às vezes serão redirecionados sem necessidade — é uma troca (trade-off) aceita para permitir que o modelo seja liberado a todos imediatamente, em vez de meses depois.
• Configuração de fallback: via API, você pode configurar fallback client-side ou server-side, listando modelos alternativos — se o classificador disparar no Fable 5, a requisição cai automaticamente para outro modelo, mantendo a experiência confiável.
• stop_reason: "refusal": requisições nesses domínios podem retornar esse motivo de parada — não escreva prompts/skills que peçam para o modelo "ecoar" seu raciocínio interno na resposta, pois isso pode disparar recusas por extração de raciocínio (reasoning_extraction).
• Retenção de dados: usar o Fable exige retenção de dados por 30 dias, para fins de monitoramento de segurança.

11. Casos de uso práticos (demonstrados no evento)

Um resumo consolidado de todos os exemplos concretos citados na keynote, organizados por categoria:

11.1 Engenharia de software

• Reconstrução de aplicações em um único prompt ("one-shot"), incluindo fidelidade visual (cores, layout, funcionalidade real) — comparado lado a lado entre um modelo antigo (que produzia algo "parecido, mas não funcional") e um modelo atual (que planeja antes de agir e entrega a UI funcionando de fato).
• Migração de código em massa: Spotify usando um agente de background que lê um plano de migração em linguagem natural e abre centenas de PRs automaticamente.
• Localização/tradução de site em 13 idiomas simultaneamente via Dynamic Workflows, incluindo agentes de verificação automática da qualidade da tradução.
• Revisão de código automatizada com um time de agentes capturando bugs críticos em PRs antes da revisão humana.
• Varredura noturna de segurança de toda a base de código, com priorização de vulnerabilidades e disparo de sessões corretivas.
• Refatorações/migrações em larga escala com dezenas a centenas de agentes rodando em paralelo, de forma determinística.

11.2 Análise de dados e inteligência de negócio

• Agente "Pascal": análise de dados de e-commerce (pedidos de supermercado), gerando insights de produto (produto mais popular), de comportamento do cliente (horário de pico de pedidos) e um simulador preditivo de recompra — tudo em minutos, com auditoria automática indicando gargalos de performance nos próprios scripts.
• Dashboard executivo ("Hero Corp"): um agente varre e-mails (Outlook), transcrições de reuniões (Gong) e outras fontes de dados corporativos para reportar o status de objetivos estratégicos de negócio para um CEO — inclusive capturando um detalhe crítico enterrado no meio de uma transcrição longa (um pedido específico de um cliente importante) que havia passado despercebido pela equipe humana, e que mudou o status de "verde" para "vermelho" em um negócio importante.

11.3 Uso de subagentes/consultoria (Advisor)

• Modelo pequeno (Sonnet) executa o trabalho de rotina de tool calling a baixo custo, mas consulta periodicamente um modelo maior (Opus/Fable) como "advisor" apenas quando precisa de raciocínio mais profundo — economia de custo sem abrir mão da qualidade de decisão em pontos críticos.

11.4 Operações do dia a dia do desenvolvedor

• Trabalho remoto/mobile: Claude Code no iOS/Android permite continuar tarefas de codificação fora do computador.
• Routines: rodar Claude Code automaticamente disparado por agenda, webhook ou API — por exemplo, atacar automaticamente novos tickets de suporte/bugs assim que são abertos.
• Multi-Claudeing: rodar várias sessões/instâncias em paralelo, monitoradas por um painel único (Claude Desktop ou Agents View na CLI).

11.5 Padrão genérico recomendado para qualquer caso de uso novo

1. Escreva/atualize um eval (teste automatizado) que capture o comportamento desejado, focando em tarefas que os modelos atuais ainda não saturam — não apenas o que já funcionava há 12 meses.
2. Reduza o scaffolding: remova instruções antigas escritas para compensar falhas de modelos anteriores; escreva prompts pela intenção, não pelo histórico de falhas passadas.
3. Dê espaço para o modelo trabalhar: habilite adaptive thinking, ajuste o effort, dê mais acesso controlado ao ambiente (ex.: Auto Mode) e feche o loop do agente com uma forma de verificação (ex.: uma ferramenta de computer use para o agente checar visualmente se o front-end que ele construiu realmente funciona).

12. Checklist rápido de otimização

Use esta lista como referência de bolso ao configurar ou revisar um agente baseado em Fable 5:

• [ ] Effort correto? Comecei em high; testei se xhigh traz ganho real antes de usar; reduzi para medium/low onde o ganho de qualidade não compensa o custo/latência extra.
• [ ] max_tokens grande o suficiente para tarefas em high/xhigh (pense em raciocínio + resposta juntos)?
• [ ] Prompt enxuto? Removi instruções/regras que existiam só para compensar falhas de modelos antigos?
• [ ] Instruções de "parar de planejar demais" presentes quando a tarefa é longa/ambígua?
• [ ] Instruções contra refatoração/limpeza indesejada presentes em tarefas de effort alto?
• [ ] Auditoria de progresso configurada (o agente relata só o que pode comprovar com resultado de ferramenta)?
• [ ] Limites de ação explícitos (quando só avaliar vs. quando agir; quando pausar para o usuário)?
• [ ] Cache hit rate verificado no console — está em 80%+? Se não, rodei a Cloud API skill para melhorar?
• [ ] Tool Search Tool habilitada se há muitas ferramentas (10+)?
• [ ] Programmatic Tool Calling habilitado se ferramentas retornam payloads grandes (HTML, e-mails, JSON extenso)?
• [ ] Compaction configurada com um limiar sensato (ex.: 400-500K de um contexto de 1M) para tarefas de longa duração?
• [ ] Estratégia advisor avaliada: dá para usar um modelo menor com o Fable/Opus como consultor pontual, em vez de rodar o modelo caro o tempo todo?
• [ ] Sistema de memória configurado para tarefas recorrentes (arquivo de lições, uma por nota, sem duplicar)?
• [ ] Fallback configurado para o caso de o classificador de segurança bloquear uma requisição legítima (cibersegurança/biologia)?
• [ ] Subagentes usados com liberdade para paralelizar trabalho independente, com comunicação assíncrona (não bloqueante)?

13. Glossário de termos

Fontes

• Transcrição integral do vídeo enviado pelo usuário (evento "Code with Claude", Tóquio) — gerada localmente via whisper.cpp (modelo large-v3-turbo).
• Documentação oficial: Prompting Claude Fable 5 — platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5
• Documentação oficial: Effort — platform.claude.com/docs/en/build-with-claude/effort
• Página oficial do produto: anthropic.com/claude/fable