Última revisão: maio de 2026
Uma referência rápida dos padrões arquiteturais que o exame CCA-F avalia. Leia de cima a baixo ou pule para uma seção.
Escolher entre um agente único e um enxame multiagente para um fluxo de trabalho complexo.
Comece com um agente único + ferramentas. Divida em múltiplos agentes apenas quando os limites da tarefa forem claros, as janelas de contexto transbordarem, ou diferentes níveis de modelo forem necessários por subtarefa.
Por quê: Múltiplos agentes adicionam latência, superfície de erro e custo de orquestração. A maioria das cargas de trabalho de produção é bem-sucedida com um agente bem equipado.
O agente deve raciocinar sobre as observações antes de agir novamente.
Implemente um loop ReAct (Raciocinar + Agir): o modelo gera um pensamento, seleciona uma ferramenta, recebe o resultado e repete até que uma condição de parada seja atendida.
Por quê: ReAct torna o raciocínio intermediário visível, melhorando a capacidade de depuração e permitindo auditar a cadeia de pensamento.
O agente precisa interagir com sistemas externos (APIs, bancos de dados, sistemas de arquivos).
Defina ferramentas via API `tool_use`. O modelo emite um bloco `tool_use`; seu código o executa e retorna um `tool_result`. O modelo então continua.
O orquestrador deve despachar subtarefas heterogêneas (revisão de código, pesquisa na web, análise de dados).
Use um agente supervisor que decomponha o objetivo, delegue a subagentes especialistas e agregue os resultados. Cada subagente tem seu próprio `system prompt` e conjunto de ferramentas.
Múltiplos subagentes devem coordenar sem comunicação direta ponto a ponto.
Encaminhe todas as mensagens entre agentes através de um supervisor. O supervisor decide qual subagente executa em seguida, passa o contexto e impõe restrições de ordenamento.
Por quê: Mensagens diretas entre pares criam ciclos e tornam o estado difícil de rastrear. Um supervisor central mantém o DAG de execução explícito.
O agente deve lembrar o contexto em uma sessão de múltiplas interações.
Passe o histórico completo da conversa (`system` + interações anteriores do usuário/assistente) no array `messages`. Para sessões longas, resuma as interações mais antigas para permanecer dentro da janela de contexto.
O agente precisa de persistência entre sessões ou entre usuários.
Armazene fatos em uma camada de memória externa (banco de dados vetorial, `key-value store`, arquivo). Recupere memórias relevantes via RAG e injete no `system prompt` a cada interação.
A equipe adota a arquitetura de agentes por padrão para cada recurso de LLM.
Não use agentes quando um único `prompt` + saída estruturada for suficiente. Agentes adicionam latência, custo e modos de falha. Reserve loops de agente para tarefas que exigem iteração ou uso de ferramentas.
Uma tarefa de raciocínio complexo precisa de mais deliberação interna antes da resposta.
Habilite o `extended thinking` com um parâmetro `budget_tokens`. O modelo usa um bloco de pensamento antes de responder, melhorando a precisão em problemas de múltiplos passos.
Por quê: O `extended thinking` troca latência por qualidade. Defina `budget_tokens` proporcionalmente à complexidade da tarefa; limite-o para controlar o custo.
Uma chamada de ferramenta retorna um erro; o agente deve se recuperar graciosamente.
Retorne o erro como um `tool_result` com `is_error: true`. O modelo vê a falha e pode tentar novamente com parâmetros corrigidos, tentar uma ferramenta alternativa ou explicar a falha ao usuário.
Falhas transientes da API (429, 529) durante um loop de agente.
Implemente `exponential backoff` com `jitter`. Em 429 (limite de taxa), respeite o cabeçalho `retry-after`. Em 529 (sobrecarregado), aguarde mais tempo. Nunca tente novamente erros da classe 400 cegamente.
Medir se um sistema de agente realmente melhora ao longo do tempo.
Construa uma suíte de avaliação: defina pares de entrada-saída, execute o agente, pontue as saídas (`exact match`, LLM como juiz, revisão humana). Acompanhe a taxa de aprovação por lançamento.
Por quê: Sem avaliações, ajustes de `prompt` são suposições. A detecção de regressão requer pontuação automatizada e repetível.
O agente produz saída de baixa qualidade na primeira tentativa.
Adicione uma etapa de reflexão: após gerar uma resposta, solicite que o modelo critique sua própria saída e revise. Use uma interação de mensagem separada ou `extended thinking`.
O fluxo de trabalho de agente realiza ações irreversíveis (excluir recursos, enviar e-mails).
Insira um ponto de verificação antes de operações destrutivas. Apresente a ação planejada ao usuário, aguarde aprovação e, em seguida, execute. Registre a decisão para auditoria.
Múltiplos arquivos CLAUDE.md em um monorepo; não está claro qual tem precedência.
Três níveis: ~/.claude/CLAUDE.md (usuário), CLAUDE.md na raiz do projeto (`project-root`), CLAUDE.md filho do `workspace` (`workspace-child`). Todos são mesclados; o `workspace` substitui o `project`, que substitui o `user`.
A equipe quer `prompts` reutilizáveis invocados como /meu-comando.
Crie um arquivo .claude/commands/<nome>.md contendo o modelo de `prompt`. Invoque com /<nome>. Use $ARGUMENTS para entrada do usuário. Comandos com escopo de projeto residem no repositório.
Executar um `linter` automaticamente depois que Claude edita um arquivo.
Configure um `hook` `PostToolUse` em `settings.json` que corresponda à ferramenta Write/Edit. O script do `hook` é executado após a conclusão da ferramenta; a saída diferente de zero bloqueia a alteração.
Claude Code solicita permissão em cada comando de `shell`; atrasando a iteração.
Use padrões de `allowlist` em `settings.json` sob `permissions.allow`. Três modos: padrão (solicita para cada), `allowlist` (aprova automaticamente padrões correspondentes) e `yolo` (aprova automaticamente todos - não recomendado para produção).
O desenvolvedor quer substituições pessoais não confirmadas no repositório.
`settings.json` é confirmado (`defaults` da equipe). `settings.local.json` é ignorado pelo Git (substituições pessoais). As configurações locais são mescladas sobre as configurações do projeto.
Executando Claude Code em um pipeline de CI sem terminal interativo.
Use `claude -p "prompt" --output-format json` no modo `headless`. Passe a entrada via `stdin`, analise a saída estruturada. Defina ANTHROPIC_API_KEY como um segredo de CI.
Claude Code precisa de acesso a um servidor MCP personalizado (banco de dados, API interna).
Adicione o servidor a `mcpServers` em `settings.json` com `command` e `args`. Claude Code inicia o servidor MCP como um processo filho e descobre ferramentas na inicialização.
Claude Code trabalhando em um `feature branch` enquanto você desenvolve no `main`.
Use `git worktrees`. Claude Code opera no diretório do `worktree`; seu `checkout` principal permanece intocado. Evita conflitos de índice e malabarismos com `stash`.
Claude Code gera alterações, mas você quer `commits` atômicos limpos.
Claude Code rastreia as alterações de arquivos e pode criar `commits` com mensagens. Revise o `diff` antes de confirmar. Prefira `staging` de arquivos específicos em vez de `git add -A` para evitar vazamento de segredos.
Usando Claude Code do VS Code ou JetBrains.
Instale a extensão Claude Code. Ela incorpora o CLI como um painel dentro da IDE, compartilhando o mesmo CLAUDE.md, `hooks` e configurações. Sessões baseadas em terminal e em IDE são intercambiáveis.
Prompt longo com múltiplas seções; o modelo confunde instruções com dados.
Envolva as seções em tags XML: <instructions>, <context>, <examples>. Claude é treinado para respeitar os limites XML como delimitadores estruturais.
Definir comportamento persistente em todas as interações (tom, restrições, persona).
Coloque instruções invariantes no `system prompt`. Mantenha-o conciso: papel, restrições, formato de saída. As mensagens do usuário carregam o contexto por interação; o `system` carrega regras para toda a sessão.
Forçar o modelo a iniciar sua resposta com um prefixo específico (ex: chave de abertura JSON).
Adicione uma mensagem parcial do assistente no final do array `messages`. Claude continua de onde você parou. Útil para impor o formato de saída.
O formato de saída do modelo é inconsistente apesar das instruções detalhadas.
Adicione 2-3 exemplos `few-shot` como pares de interação usuário/assistente antes da consulta real. Exemplos fixam formato, tom e estilo de raciocínio de forma mais confiável do que instruções em prosa.
O modelo pula etapas de raciocínio em problemas lógicos de múltiplos passos.
Envie um `prompt` com "Pense passo a passo" ou use `extended thinking`. Para produção, use `extended thinking` (`budget_tokens`) em vez de solicitar uma `chain-of-thought` visível para manter a saída limpa.
Escolher entre saídas determinísticas e criativas.
`temperature=0` para tarefas determinísticas (classificação, extração). `temperature=0.5-0.7` para escrita criativa. `temperature=1.0` para máxima diversidade. Nota: `extended thinking` requer `temperature=1`.
Precisa de saída JSON válida garantida do modelo.
Defina uma ferramenta com o esquema JSON desejado como `input_schema`. Defina `tool_choice` para forçar essa ferramenta. O modelo retorna JSON estruturado no bloco `tool_use`, validado contra o esquema.
Aplicativo voltado para o usuário precisa de baixo tempo para o primeiro `token`.
Use `stream=true` na Messages API. Processe eventos enviados pelo servidor incrementalmente: `content_block_start`, `content_block_delta`, `message_stop`. Exiba os `tokens` à medida que chegam.
Processando milhares de `prompts` onde a latência não é crítica.
Use a API Message Batches. Envie até 100 mil solicitações por lote. Os resultados chegam em 24 horas com 50% de redução de custo. Faça `polling` ou use um `webhook` para conclusão.
Extraindo dados de documentos escaneados ou imagens.
Passe imagens como blocos de conteúdo base64 (tipo: `image`) ou páginas PDF (tipo: `document`) na mensagem do usuário. Claude processa até 20 MB por solicitação. Prefira PDFs nativos a capturas de tela para documentos com muito texto.
Escolher entre Opus, Sonnet e Haiku para uma carga de trabalho.
Opus: maior capacidade, raciocínio complexo, tarefas de agente. Sonnet: desempenho/custo equilibrado, uso geral em produção. Haiku: mais rápido e barato, classificação, roteamento, extração simples.
Chamadas repetidas compartilham o mesmo `system prompt` longo; quer reduzir o custo.
Marque o conteúdo armazenável em cache com `cache_control: { type: "ephemeral" }`. Prefixes em cache são reutilizados entre chamadas por até 5 minutos (auto-estendido em caso de acerto). O custo de escrita é 25% maior; o custo de leitura é 90% menor.
Definir uma ferramenta para a Claude Messages API.
Cada ferramenta tem `name`, `description` e `input_schema` (JSON Schema). A descrição informa a Claude quando usá-la; o esquema valida os parâmetros. Mantenha as descrições orientadas à ação e concisas.
Ferramenta executada com sucesso; precisa retornar o resultado para Claude.
Envie uma mensagem de usuário com `role: "user"` e um bloco de conteúdo `tool_result`. Inclua o `tool_use_id` para correlacionar. Retorne os dados como texto ou conteúdo estruturado; mantenha os `payloads` abaixo de 100k `tokens`.
O agente precisa buscar dados de três fontes independentes simultaneamente.
Claude pode emitir múltiplos blocos `tool_use` em uma única resposta. Execute-os em paralelo e, em seguida, retorne todos os blocos `tool_result` em uma única mensagem do usuário. Reduz o número de `round trips`.
Entender o modelo de componente do Protocolo de Contexto do Modelo (MCP).
Três papéis: Host (aplicativo como Claude Code), Cliente (`handler` de protocolo por servidor), Servidor (expõe ferramentas/recursos/prompts). Clientes mantêm conexões 1:1 com os servidores.
Escolher como um cliente MCP se conecta a um servidor.
stdio: processo local, configuração mais simples. SSE: baseado em HTTP, legado. Streamable HTTP: padrão atual para servidores remotos, suporta `resumability` e mensagens iniciadas pelo servidor.
Decidir qual primitiva MCP expor.
Recursos: dados somente leitura (arquivos, linhas de DB) que o cliente extrai. Ferramentas: ações que o modelo invoca (escrever, computar, consultar). Prompts: modelos de `prompt` reutilizáveis que o usuário seleciona. As ferramentas são controladas pelo modelo; os recursos são controlados pelo aplicativo.
Criar um servidor MCP customizado para expor APIs internas.
Use o SDK do MCP (TypeScript ou Python). Implemente `handlers` de ferramentas com esquemas de entrada. Registre via `server.tool()`. Transporte: `stdio` para local, `streamable HTTP` para remoto.
O agente deve interagir com um aplicativo GUI (clicar, digitar, capturas de tela).
Habilite as ferramentas de uso do computador: `computer_20250124` (captura de tela + mouse + teclado), `text_editor_20250124`, `bash_20250124`. O modelo recebe capturas de tela e emite ações baseadas em coordenadas.
O modelo deve sempre chamar uma ferramenta específica em vez de responder com texto.
Defina `tool_choice` como `{ type: "tool", name: "my_tool" }`. O modelo é forçado a chamar essa ferramenta. Use `type: "any"` para exigir alguma chamada de ferramenta, ou `type: "auto"` (padrão) para deixar o modelo decidir.
O aplicativo atinge o limite de contexto no meio da conversa.
Os modelos Claude suportam 200k `tokens`. Monitore o uso via `response.usage`. Ao se aproximar do limite, resuma as interações mais antigas ou trunque. Nunca descarte mensagens silenciosamente.
Processando um documento de 150 páginas que preenche a maior parte da janela de contexto.
Coloque o documento no início do `prompt` (após o `system`). Coloque as perguntas por último. Use `prompt caching` para evitar o reenvio em acompanhamentos. Para tarefas com múltiplos documentos, use RAG para selecionar pedaços relevantes.
A base de conhecimento é muito grande para caber no contexto; o modelo precisa de acesso no momento da consulta.
Incorpore e indexe documentos em um `vector store`. No momento da consulta, recupere os `top-k chunks`, injete na mensagem do usuário. Cite os documentos de origem na saída para rastreabilidade.
O modelo afirma fatos incorretos com confiança.
Baseie as respostas no contexto fornecido (RAG). Instrua o modelo a dizer "Não sei" quando a evidência for insuficiente. Use citações. Valide as afirmações factuais contra documentos de origem programaticamente.
O aplicativo recebe respostas 429 (`rate limited`) ou 529 (sobrecarregado).
429: você atingiu o limite de taxa do seu nível. Recue e tente novamente; respeite o `retry-after`. 529: a API Anthropic está sobrecarregada. Recue por mais tempo. Ambos são transitórios. Nunca tente novamente 400 ou 401.
Gasto mensal com API é maior do que o esperado.
Use `prompt caching` para prefixos repetidos (90% de desconto na leitura). Direcione tarefas simples para Haiku. Use a Batch API para cargas de trabalho assíncronas (50% de desconto). Monitore o uso de `tokens` por `endpoint`. Corte o contexto desnecessário.
Precisa de visibilidade sobre o consumo de `tokens` por solicitação.
Cada resposta da Messages API inclui `usage.input_tokens`, `usage.output_tokens` e (se armazenado em cache) `usage.cache_read_input_tokens`. Registre-os por chamada, agregue por `endpoint`, defina alertas de orçamento.