Coloque o Claude Fable 5.1 e o Gemini 3.8 Flash na mesma equipe

Um amigo me fez uma pergunta irrelevante no trabalho e eu usei um agente para pesquisar meus chats e documentos recentes. Ele encontrou a resposta certa, mas custou US$ 38!!!. Foi um péssimo ROI. Claro que meu tempo é valioso, mas eu não teria gasto esse tempo de verdade, e essa tarefa não precisava realmente de capacidades caras de planejamento.

Podemos fazer melhor.

A Plataforma de Agentes Empresariais Gemini do Google Cloud oferece o Model Garden, com acesso conveniente via API a muitos dos principais modelos, incluindo os da Google, da Anthropic e até da xAI. Na verdade, todos os modelos do Hugging Face estão disponíveis para você implantar por conta própria, mas neste artigo vamos focar no novo Claude Fable 5.1 da Anthropic e no novo Gemini 3.8 Flash da Google. Agora, os desenvolvedores têm dois modelos de fronteira com formatos diferentes operando atrás da mesma superfície de API empresarial.

O Fable 5.1 traz planejamento autônomo de classe Mythos, uma janela de contexto de 1 milhão de tokens e diligência profunda em múltiplas etapas. O Gemini 3.8 Flash traz raciocínio quase na fronteira e velocidade incrível de tokens com a economia do Flash (US$ 0,75 por milhão de tokens de entrada, US$ 3,75 por milhão de tokens de saída) com controles de pensamento ajustáveis.

Pode ser fácil escolher um modelo e roteirizar tudo através dele. Isso é um erro.

Se você passar tarefas rotineiras de desenvolvimento por um planejador profundo, estará pagando taxas de tokens de fronteira para analisar diffs do git. Se você forçar um modelo rápido a lidar com uma migração de banco de dados irreversível sem um plano formal, ele vai avançar às cegas e quebrar o estado antes que você termine seu café.

Podemos obter uma "tokenômica" muito melhor de forma simples, usando 2 modelos e roteando as tarefas.

Por Alan Blount (@zeroasterisk

Aqui está o guia completo para chegar lá:

1. Configure ambos os modelos atrás de um único plano de governança unificado.
2. Faça benchmarks de tarefas rotineiras antes de escolher um padrão.
3. Use o modelo rápido como seu coordenador de linha de frente e use o planejador profundo sempre que souber que precisa de mais poder ou quando o modelo rápido precisar escalar.
4. Forme um modelo mental sobre o ROI da Tarefa e o valor (não apenas o custo) dos seus tokens.

1. Configure ambos os modelos atrás de um único plano de governança unificado

Escolher sua plataforma de inferência LLM requer consideração em muitas escolhas de design. Custo, capacidade, segurança, escolha do modelo, recursos de serviço, atrito para desenvolvedores, ainda mais segurança (chaves de API são arriscadas). A Plataforma de Agentes Empresariais Gemini (anteriormente Vertex AI) é uma opção abrangente com capacidades únicas, e como ela expõe tanto os modelos Gemini quanto os da Anthropic como APIs gerenciadas, uma única autenticação segura cobre ambas as cargas de trabalho.

Mas sejamos honestos, algumas jornadas têm mais atrito do que eu gostaria. Eu gosto de brincar que "coisas impossíveis são fáceis, mas coisas fáceis são difíceis". Essa é parte da razão pela qual estou escrevendo este post.

Antes de lidar com os modelos, faça login no gcloud, leia a documentação para variações.

1gcloud auth application-default login

Para ter acesso ao Claude Fable 5.1, você precisa habilitar a API e então habilitar o Claude Fable 5.1 e preencher um formulário bem rápido sobre seu caso de uso. Mas você ainda não terminou.

Agora, o Fable se enquadra no Adendo de Segurança Avançada de IA do Google Cloud. Antes de enviar um único prompt para aiplatform.googleapis.com, você deve configurar explicitamente o compartilhamento de respostas de prompts e aceitar os termos do editor no nível do projeto.

Aqui estão as instruções exatas que funcionam para o endpoint global, leia a documentação para variações.

Primeiro, vamos configurar algumas variáveis que nos ajudarão. Note que o nome do modelo no caminho da URL é claude-fable-5-1 com hífens, não pontos, e certifique-se de inserir seu ID de projeto e localização, depois possivelmente altere seu endpoint dependendo da sua região:

1export PROJECT_ID="YOUR_PROJECT_ID"
2export LOCATION="global"
3export MODEL="claude-fable-5-1"
4
5# Endpoint Global: aiplatform.googleapis.com (recomendado)
6# Endpoints Multi-Regionais: aiplatform.eu.rep.googleapis.com
7# Endpoints Regionais: us-central1-aiplatform.googleapis.com
8export ENDPOINT="https://aiplatform.googleapis.com"

Em seguida, chame a API setPublisherModelConfig definindo dataSharingEnabledProvider como ANTHROPIC - note que isso está em maiúsculas:

1curl -X POST \
2  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
3  -H "Content-Type: application/json; charset=utf-8" \
4  -d '{ "publisherModelConfig": { "dataSharingEnabledProvider": "ANTHROPIC" } }' \
5"${ENDPOINT}/v1beta1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/anthropic/models/${MODEL}:setPublisherModelConfig"

A chamada inicial retorna um objeto de operação concluído confirmando que o compartilhamento de dados está ativo:

1{
2  "name": "projects/YOUR_PROJECT_NUMBER/locations/global/operations/1234567",
3  "metadata": {
4    "@type": "type.googleapis.com/google.cloud.aiplatform.v1beta1.SetPublisherModelConfigOperationMetadata",
5    "genericMetadata": {
6      "createTime": "...",
7      "updateTime": "..."
8    }
9  },
10  "done": true,
11  "response": {
12    "@type": "type.googleapis.com/google.cloud.aiplatform.v1beta1.PublisherModelConfig",
13    "loggingConfig": {},
14    "dataSharingEnabledProvider": "ANTHROPIC"
15  }
16}

Se você já fez isso, receberá um erro HTTP 409 dizendo que essa configuração já existe:

1409 ALREADY_EXISTS: The same PublisherModelConfig already exists.

Este erro 409 não é problema nenhum.

Teste seu acesso ao modelo e você deve obter uma resposta:

1curl -X POST \
2  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
3  -H "Content-Type: application/json; charset=utf-8" \
4  -d '{"anthropic_version": "vertex-2023-10-16","messages": [{"role": "user", "content": "Hello world."}], "max_tokens": 1024, "stream": true}' \
5"${ENDPOINT}/v1beta1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/anthropic/models/${MODEL}:streamRawPredict"

Se você não fez isso corretamente, receberá um erro HTTP 403 que se parece com isto:

1403 PERMISSION_DENIED: Access to this model requires data sharing to be enabled for publisher 'anthropic'. Please set `PublisherModelConfig.data_sharing_enabled_provider`
2to 'anthropic' via the setPublisherModelConfig API to use this model.

Para ter acesso ao Gemini 3.8 Flash, certifique-se de vê-lo como modelo habilitado no cartão do modelo e ele deve funcionar imediatamente:

1curl -X POST \
2  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
3  -H "Content-Type: application/json; charset=utf-8" \
4  -d '{"contents": [{"role": "user", "parts": [{"text": "Hello world"}]}],"generationConfig": {"thinkingConfig": {"thinkingLevel": "LOW"}}}' \
5"${ENDPOINT}/v1beta1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/gemini-3.8-flash:streamGenerateContent"

… ufa. Conseguimos 🎉!

Precisa de mais cota? Você pode gerenciar cotas para qualquer modelo e pagar por throughput provisionado para alguns modelos.

2. Não Confie em Benchmarks, Rode os Seus Próprios

Se você perguntar a cinco engenheiros qual modelo usar para uma configuração de agente, obterá mais de cinco opiniões conflitantes baseadas em vibes do Twitter e leaderboards sintéticos.

Benchmarks públicos fornecem um recurso fantástico, mas testam prompts isolados ou cada vez mais tarefas em vácuo. Casos de uso de produção, ou seus agentes locais de SDLC agêntico, nunca correspondem perfeitamente aos benchmarks públicos. Seu trabalho tem um formato diferente de qualquer benchmark hoje.

Então você poderia construir seus próprios benchmarks (Agent Ops e Evals FTW!) e automatizar isso em escala, ou você pode simplesmente fazer suas próprias tarefas simples lado a lado. Desde que você não mude os arquivos na sua tarefa, você ficará bem e, com quase nenhum esforço, terá uma sensação das tarefas.

Aqui está um exemplo usando promptfoo para dirigir o opencode a fazer as mesmas 2 tarefas com cada modelo. Você precisaria mudar a descrição da tarefa e configurar seu ambiente para que isso funcione, mas não deveria ser muito difícil.

GIF

1# opencode.json
2{
3  "$schema": "https://opencode.ai/config.json",
4  "provider": {
5    "google-vertex": {
6      "options": { "project": "alanblount-demo", "location": "global" },
7      "models": {
8        "gemini-3.8-flash": { "id": "gemini-3.8-flash", "name": "Gemini 3.8 Flash" }
9      }
10    },
11    "google-vertex-anthropic": {
12      "options": { "project": "alanblount-demo", "location": "global" },
13      "models": {
14        "claude-fable-5-1": { "id": "claude-fable-5-1", "name": "Claude Fable 5.1" }
15      }
16    }
17  },
18...

Configure o Promptfoo para comparar execuções de tarefas agênticas do opencode, não apenas prompts únicos e modelos.

1# promptfooconfig.yaml
2description: "Benchmarking OpenCode Agent Harness: Gemini 3.8 Flash vs. Claude Fable 5.1"
3
4prompts:
5  - "Summarize git branch status in one sentence."
6  - "Design a zero-downtime database migration strategy from Postgres to Spanner."
7
8providers:
9  - id: "exec:opencode run --auto -m google-vertex/gemini-3.8-flash"
10    label: "Gemini 3.8 Flash (OpenCode Agent)"
11  - id: "exec:opencode run --auto -m google-vertex-anthropic/claude-fable-5-1"
12    label: "Claude Fable 5.1 (OpenCode Agent)"
13
14defaultTest:
15  options:
16    timeoutMs: 60000

Rode sua própria comparação lado a lado usando o Promptfoo:

promptfoo eval -c promptfooconfig.yaml --no-cache

Aqui estão meus resultados de rodar esta avaliação em um contêiner de desenvolvimento cleanroom:

Ao verificar um branch de PR, o Claude Fable 5.1 conduziu múltiplos turnos de meta-reflexão, re-inspecionando hashes de árvore que não mudaram. Levou quase 6 segundos e custou 23 vezes mais. O Gemini 3.8 Flash reconheceu a intenção instantaneamente, disparou as ferramentas do git e respondeu em 1,1 segundos por menos de um décimo de centavo.

Na complexa migração de banco de dados, o cenário se inverteu. O Gemini 3.8 Flash produziu uma sequência linear sólida e limpa em 3 segundos. Mas o Fable 5.1 gastou 12 segundos gerando um grafo acíclico direcionado (DAG) completo e formal. Ele identificou riscos de skew de relógio em escritas duplas, gerou requisitos de chave de idempotência e definiu um portão de rollback reversível.

Isso é apenas um exemplo ilustrativo, você deve comparar com suas próprias tarefas.

3. Uso prático no dia a dia e em produção

Seja usando ferramentas de codificação prontas ou construindo serviços de agentes personalizados, o padrão vencedor é coordenação assimétrica: velocidade barata para execução de linha de frente, combinada com profundidade deliberada para checkpoints arquiteturais. Gaste tokens caros em problemas complicados ou trabalhos de planejamento, mas padronize para tokens mais baratos para tarefas mais simples.

Arneses de Agentes de Codificação (OpenCode, Aider, etc.)

Não force um único modelo a ser seu padrão universal. Configure subagentes especializados mapeados para modelos distintos. Usar o mesmo provedor unificado vem com benefícios de segurança e custo. Usar famílias de modelos diferentes pode beneficiar tendo eles verificando uns aos outros.

Use o agente pensador profundo para identificar a causa raiz e planejar uma solução para este problema, e então use o agente trabalhador para lidar com cada uma das tarefas e reportar o status. O planejador profundo verifica o trabalho deles e confirma o sucesso ou redistribui.

1# opencode.json
2{
3  "$schema": "https://opencode.ai/config.json",
4  "model": "google-vertex/gemini-flash-latest",
5  "agent": {
6    "plan": {
7      "model": "google-vertex/gemini-flash-latest"
8    },
9    "build": {
10      "model": "google-vertex/gemini-flash-latest"
11    },
12    "worker": {
13      "model": "google-vertex/gemini-3.8-flash",
14      "mode": "primary",
15      "description": "General worker agent using gemini-3.8-flash"
16    },
17    "deep-thinker": {
18      "model": "google-vertex-anthropic/claude-fable-5-1@default",
19      "mode": "primary",
20      "description": "Deep thinking agent using Claude Fable 5.1"
21    }
22  },
23...

Agentes Personalizados "como Serviço" (Google ADK, LangGraph, código personalizado, etc.)

Ao construir seus próprios arneses de agentes e seus próprios serviços de agentes, você tem liberdade arquitetural completa

• Remodelar o arnês para o modelo: Dê ao Gemini 3.8 Flash 3 a 5 ferramentas focadas (read_file, write_file, run_tests) com schemas JSON estritos. Modelos rápidos se destacam em execução focada, mas um catálogo de 50 ferramentas causa confusão de parâmetros e desperdício de contexto. Dê ao Claude Fable 5.1 docs de arquitetura, schemas e diretrizes, mas remova as permissões diretas de escrita de arquivo.
• Fundamentar em Evals: Não chute qual modelo se encaixa em qual nó. Execute suítes de avaliação automatizadas com verificações de asserção determinísticas nas tarefas do seu repo para encontrar onde um modelo menor entrega 95% de qualidade a 10% do custo. É fácil dizer, mas difícil de fazer, difícil saber quais cenários você quer avaliar. Confira nossos cursos de 5 dias no Kaggle (agents, videcoding) para mais.
• Use o Padrão de Escalonamento "Peça Ajuda": Comece toda solicitação recebida no trabalhador rápido. Dê ao trabalhador uma ferramenta explícita: ask_for_help(reason, failed_attempts, context). O trabalhador lida com 85% a 90% das solicitações diretamente. Ele escala apenas em ambiguidade, ações irreversíveis ou duas falhas consecutivas de ferramenta.

A Realidade sobre Roteadores de Modelo "Inteligentes" Automatizados

Roteadores inteligentes têm uma longa história em ML preditivo (ad tech, detecção de fraude). Bandits multi-braço e roteadores de custo-qualidade são maduros porque as features são tabulares, as entradas são limitadas e o feedback (cliques, chargebacks) é tanto imediato quanto mensurável em um horizonte de tempo longo.

Em IA generativa, agentes multi-turno são outra história. Roteadores dinâmicos podem lutar com três realidades de produção:

• O contexto de turno único pode não conter sinal suficiente sobre a tarefa para escolher
• Métricas de sucesso não são claramente extrapoladas para features, então o roteador não consegue "aprender" rapidamente
• Escolhas erradas são re-executadas no outro caminho, comendo quaisquer economias potenciais e adicionando latência

O Veredito: Mantenha simples. Componha seus agentes explicitamente e roteie pelo limite da tarefa. Defina papéis claros e deixe asserções de código concretas ou a intenção humana controlarem as transferências.

4. A Equação de ROI de Tokens: Pelo Que Você Está Realmente Pagando?

Planilhas de preços brutos ($/1M tokens) não são um bom mapa do valor de produção. Calcular custos é apenas parte da equação. É impossível te dar um cálculo que sempre vai funcionar, através de codificação, produto, manufatura e todo outro job-to-be-done por aí.

Um ponto de partida pode ser pensar no valor de negócio que você está obtendo.

• O custo do tempo humano economizado, funcionários completando mais trabalho e gastando menos tempo em toil e tarefas automatizadas.
• O valor de lançar features para produção mais rápido, enquanto melhora a satisfação e retenção de clientes por causa dessas features.
• Os erros mitigados e as quedas de produção evitadas devido a salvaguardas e práticas de engenharia melhoradas.

Subtraia o custo de tokens, e o custo de upskilling da sua equipe para construir e gerenciar seus agentes e você tem um cálculo aproximado de ROI.

Você pode influenciar esses cálculos usando menos e tokens mais baratos, mas provavelmente você os influencia mais fazendo mais trabalho, mais rápido. Escolha tarefas de alto alavancagem. Escolha tarefas que resultem em overhead economizado ou receita aumentada, que possam ser verificadas, e que valham a pena automatizar. E conforme você decompõe essas tarefas, talvez você queira pensar super profundamente e planejar e esteja disposto a pagar mais e esperar, ou talvez você queira executar rápido e confiavelmente. Você precisará de ambos.

Tokenômica é um tópico quente agora, e há muitas mais opções para reduzir custos e maximizar valor. O ponto principal deste artigo é que é realmente simples configurar alguns agentes diferentes em 2 modelos com perfis diferentes e rotear tarefas você mesmo. Esse é o lugar mais fácil para começar.

Se você achou este detalhamento útil, confira nossa peça anterior sobre 5 coisas que todo engenheiro de IA deve saber sobre sandboxes de agentes. Siga @GoogleCloudTech e @zeroasterisk para mais mergulhos profundos das trincheiras dos builders.