Quatro superfícies de uma mesma arquitetura agêntica

Três caminhos coexistem e sincronizam o histórico quando o login é o mesmo:

• Web — claude.ai. Acesso imediato; recomendado para o primeiro contato.
• App de desktop — recomendado para uso recorrente, pois agrega Cowork, Code e desktop extensions; baixe em claude.com/download.
• App móvel — iOS e Android. Útil para perguntas curtas, voz e para enviar tarefas ao Cowork e ao Code remotamente quando pareado com o desktop.

Conversas, projetos, memória e preferências sincronizam em todos os dispositivos quando o login é mantido (Anthropic, 2026d). Sessões locais do Cowork, contudo, permanecem no dispositivo onde rodam.

Em claude.ai, cadastre-se com e-mail. A escolha do plano segue a estrutura abaixo, válida em maio de 2026:

O plano Free não habilita Claude Code nem Cowork (Anthropic, 2026e). Para quem produz pesquisa e consultoria, o Pro tende a ser o ponto de partida racional pelo conjunto Code + Cowork incluso.

Em Settings → General → Profile defina nome, função e preferências pessoais para respostas. As preferências aplicam-se a todas as conversas novas. O campo aceita instruções extensas: estilo de escrita, vocabulário a evitar, exigências de citação, idioma padrão. Para um pesquisador, é o local onde fixar exigências como APA 7, ceticismo acadêmico e proibição de fabricar referências.

Ainda em Settings, ative:

• Memory — permite que o modelo retenha fatos relevantes sobre o usuário entre conversas. A memória é editável e excluível pelo próprio usuário.
• Web search — habilita consultas em tempo real. Crítico para pesquisa empírica recente.
• Search and reference past chats — permite que o modelo recupere conversas antigas por similaridade semântica.
• Code Execution and File Creation — habilita o sandbox que cria .docx, .xlsx, .pptx, .pdf e roda scripts.

Em Settings → Connectors, autorize integrações. O catálogo inclui Google Drive, Gmail, Google Calendar, Notion, Slack, Asana, Linear, Jira, Spotify, Booking, Tripadvisor, Canva, Gamma, Miro e centenas de outros. Cada conector solicita autorização OAuth dedicada; a Anthropic não armazena senhas.

Um Project é uma conversa-pasta com instruções fixas, base de conhecimento (arquivos anexados) e histórico próprio. Use um projeto por linha de trabalho, não um projeto por tarefa: pesquisa de doutorado, consultoria X, blog pessoal. Cada projeto pode ter:

• Custom instructions — comportamento e formato esperados.
• Project knowledge — PDFs, planilhas, transcrições anexados que o modelo consulta.
• Memory escopada — separada da memória global da conta.

Em planos Team e Enterprise, projetos podem ser compartilhados com colaboradores e mantêm controle de acesso por seat.

A Anthropic distribui um readiness check — um pequeno executável que valida CPU, RAM, sistema operacional e permissões antes da instalação completa. O link aparece em support.claude.com na página “Get started with Claude Cowork”. Rodar primeiro o checador evita o ciclo de instalar, falhar, desinstalar.

Baixe o instalador em claude.com/download. O pacote inclui Chat, Cowork e Claude Code em uma única aplicação — não é necessário instalar Node.js nem o CLI separadamente para começar. Após executar o instalador:

• macOS: arraste para Applications;
• Windows: o instalador .msi coloca o app no menu Iniciar.

Faça login com a mesma conta usada em claude.ai. Caso o app peça upgrade ao clicar em Cowork, isso indica que o plano vigente não inclui a feature.

No topo da janela, três abas: Chat, Cowork, Code. Clique em Cowork. A primeira execução solicita autorização para uma ou mais pastas locais. O modelo só lê, edita ou cria arquivos dentro dos diretórios autorizados — escopo idêntico ao de um colega humano com acesso a uma pasta compartilhada.

Recomenda-se começar com uma pasta de teste isolada antes de apontar Cowork para diretórios críticos.

Cowork oferece dois modos, alternáveis a qualquer momento na sessão:

Plugins agregam skills (instruções e ferramentas para um domínio), conectores e slash commands em pacotes instaláveis. A Anthropic publicou em código aberto onze plugins iniciais para funções comuns: vendas, finanças, jurídico, marketing, RH, engenharia, design e operações. Em Settings → Plugins → Browse:

• Selecione um plugin pré-pronto e personalize na instalação;
• Crie um plugin do zero via Plugin Create descrevendo o que precisa em uma frase;
• Importe um plugin distribuído pela equipe via repositório Git interno.

Skills isoladas, no formato SKILL.md com frontmatter YAML, podem ser adicionadas sem encapsular num plugin. Para distribuir skills entre desenvolvedores, mantenha-as em repositório versionado e oriente cada usuário a copiá-las para ~/.claude/skills/.

Para tarefas que demandam navegação web — preencher formulários, clicar em botões, ler páginas com login —, ative Claude in Chrome como conector. A extensão é instalada uma vez no navegador e fica disponível dentro do Cowork. Quando o modelo precisa do navegador, abre uma sessão controlada e narra cada ação. O usuário pode interromper a qualquer momento.

Em Settings → General → Computer use, ative o toggle. Em macOS, conceda permissões de Acessibilidade e Gravação de Tela. Em Windows x64, o Cowork baixa uma máquina virtual Linux (~2 GB) na primeira execução e solicita autorização por aplicação dentro da própria interface, sem o ritual macOS.

Computer Use é o último recurso da hierarquia: o modelo prefere conectores diretos (mais precisos), depois navegador, e só recorre a clicar na tela quando nada mais funciona. Cada interação com aplicação local pede autorização específica.

Para enviar tarefas ao Cowork pelo celular, mantenha as duas versões dos apps atualizadas e faça login com a mesma conta. O computador precisa estar ligado, acordado e com o app aberto — Claude executa na máquina e devolve o resultado pelo app móvel. Pareamento não é obrigatório; o Cowork roda 100% local sem o mobile.

Antes de delegar trabalho real, valide a configuração com uma tarefa não-destrutiva. Sugestão:

# Prompt sugerido para a primeira sessão Cowork
Leia todos os PDFs na pasta autorizada,
extraia título e ano, e gere um arquivo
inventario.csv com colunas: arquivo, titulo, ano.
Não modifique os PDFs originais.

Avalie três aspectos: (i) o modelo respeita o escopo da pasta; (ii) o modo de aprovação responde como esperado; (iii) o output é o que foi pedido. Só após essa validação amplie o escopo.

Existe um caminho mais simples antes do CLI: o Claude Desktop app embute o Code como aba e dispensa instalação separada de Node.js ou do CLI. Para quem nunca usou linha de comando, é o caminho recomendado pela própria Anthropic. Quem pretende usar o CLI puro, em CI/CD ou em contêineres, segue para o passo 2.

O instalador nativo dispensa Node.js, instala o binário em ~/.local/bin/claude e configura atualizações automáticas em background. Os comandos diferem por sistema:

# macOS, Linux e WSL
curl -fsSL https://claude.ai/install.sh | bash

# Windows PowerShell
irm https://claude.ai/install.ps1 | iex

# Windows CMD
curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

Alternativas equivalentes:

# Homebrew (macOS / Linux)
brew install --cask claude-code

# WinGet (Windows)
winget install Anthropic.ClaudeCode

# apt (Debian / Ubuntu) — após adicionar a chave de assinatura
sudo apt update && sudo apt install claude-code

# Confirmar versão
claude --version

# Diagnóstico completo: ambiente, PATH, dependências, MCP
claude doctor

O comando claude doctor reporta marcadores verdes para PATH, ripgrep, conexão de rede e configurações de MCP. Qualquer falha aqui se manifesta em comportamento errático mais tarde — vale resolver antes de prosseguir.

Rode claude sem argumentos pela primeira vez. Um navegador abre para autenticação OAuth. Use a mesma conta do Claude.ai. Em ambiente headless (CI/CD), defina a variável ANTHROPIC_API_KEY com uma chave gerada no Console:

# bash / zsh
export ANTHROPIC_API_KEY="sk-ant-..."

# PowerShell
$env:ANTHROPIC_API_KEY = "sk-ant-..."

Para deploy em provedores alternativos:

• AWS Bedrock — defina CLAUDE_CODE_USE_BEDROCK=1;
• Google Vertex AI — defina CLAUDE_CODE_USE_VERTEX=1;
• Microsoft Foundry — defina CLAUDE_CODE_USE_FOUNDRY=1.

Dentro do diretório do projeto, crie um CLAUDE.md. É a única fonte de verdade que o Claude lê automaticamente em toda sessão dentro daquela pasta. Documente:

• O que o projeto faz (em duas frases);
• Comandos de build, lint, test;
• Convenções de commit e branching;
• Diretórios sensíveis a evitar;
• Padrão de estilo (Black, Prettier, Ruff, etc.).

# exemplo mínimo de CLAUDE.md
## Projeto
API REST em FastAPI para tracking de safra cafeeira.

## Comandos
- make test     # roda pytest
- make lint     # ruff + mypy
- make migrate  # alembic upgrade head

## Convenções
- Conventional Commits (feat:, fix:, chore:)
- Type hints obrigatórios em src/
- Não editar /infra/secrets/

Três níveis de configuração coexistem, com precedência crescente:

Exemplo de pré-aprovação de comandos seguros, evitando prompts repetidos:

{
  "permissions": {
    "allow": [
      "Bash(npm test)",
      "Bash(make lint)",
      "Read", "Glob", "Grep"
    ],
    "deny": [
      "Bash(git push origin main)",
      "Write(./infra/secrets/**)"
    ]
  },
  "autoUpdatesChannel": "stable"
}

Model Context Protocol (MCP) é o padrão aberto que permite ao Claude conversar com ferramentas externas. Adicione servidores em ./.mcp.json:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "ghp_..." }
    },
    "postgres": {
      "command": "uvx",
      "args": ["mcp-server-postgres", "--connection-string", "postgres://..."]
    }
  }
}

Em uma sessão Claude Code, ative Plan Mode com Shift+Tab antes de tarefas complexas. O modelo apresenta um plano em texto e aguarda aprovação antes de executar. Comandos úteis durante uma sessão:

• /agents — gerenciar subagentes (Library, Running);
• /context — visualizar consumo da janela de contexto;
• /insights — relatório de uso e custo da sessão;
• /effort high — elevar o esforço de raciocínio em Opus 4.7;
• /desktop — migrar a sessão para o app desktop;
• /doctor — diagnosticar problemas em meio à sessão;
• /bug — reportar problema diretamente para Anthropic.

O que era Claude Code SDK foi renomeado para Claude Agent SDK em janeiro de 2026. A justificativa pública: a equipe da Anthropic passou a usar o mesmo motor para deep research, criação de vídeo e tarefas administrativas — não apenas para código (Anthropic, 2026f). O SDK expõe o agent loop, ferramentas built-in (Read, Write, Bash, Grep, Glob, Agent), gestão de contexto e protocolo de permissões.

Há dois caminhos para definir agentes, frequentemente combinados:

Em Python:

pip install claude-agent-sdk

Em TypeScript:

npm install @anthropic-ai/claude-agent-sdk

O SDK requer o Claude Code CLI instalado, pois usa o mesmo binário como runtime. Confirme com claude --version.

# Anthropic direto
export ANTHROPIC_API_KEY="sk-ant-..."

# Bedrock
export CLAUDE_CODE_USE_BEDROCK="1"
export AWS_REGION="us-east-1"

# Vertex AI
export CLAUDE_CODE_USE_VERTEX="1"
export CLOUD_ML_REGION="us-east5"

# Azure Foundry
export CLAUDE_CODE_USE_FOUNDRY="1"

Exemplo mínimo em Python que lista arquivos do diretório:

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions

async def main():
    async for message in query(
        prompt="Quais arquivos existem neste diretório?",
        options=ClaudeAgentOptions(
            allowed_tools=["Bash", "Glob"]
        ),
    ):
        if hasattr(message, "result"):
            print(message.result)

asyncio.run(main())

O loop interno faz: (i) o modelo decide qual ferramenta usar; (ii) o SDK executa; (iii) o resultado retorna para o modelo; (iv) o ciclo continua até a tarefa concluir ou atingir maxTurns.

Subagentes resolvem dois problemas: (i) preservam contexto, pois operam em janela isolada; (ii) habilitam paralelismo, pois múltiplos subagentes podem rodar simultaneamente. Exemplo programático em TypeScript de um revisor de código somente-leitura:

import { query } from "@anthropic-ai/claude-agent-sdk";

const result = query({
  prompt: "Revise o módulo de autenticação",
  options: {
    agents: {
      "code-reviewer": {
        description: "Especialista em revisão de código focado em segurança",
        prompt: `Você é um revisor sênior de código.
Foque em: SQL injection, XSS, gestão de segredos,
controle de acesso. Não modifique arquivos.`,
        tools: ["Read", "Grep", "Glob", "Bash"],
        model: "opus"
      }
    }
  }
});

Versão equivalente em arquivo .claude/agents/code-reviewer.md:

---
name: code-reviewer
description: Especialista em revisão de código. Use proativamente após qualquer modificação.
tools: Read, Grep, Glob, Bash
model: inherit
---

Você é um revisor sênior de código.
Foque em: SQL injection, XSS, gestão de segredos, controle de acesso.
Não modifique arquivos.

O campo description é o que Claude lê para decidir quando delegar — escreva-o como uma instrução de roteamento, não como um currículo.

Quatro modos pré-configurados existem; em produção, geralmente combina-se um modo padrão com a função canUseTool para controle granular:

options: {
  permissionMode: "default",  // pede aprovação
  // "acceptEdits"     — auto-aprova edição de arquivos
  // "bypassPermissions" — sem prompt (apenas em sandbox)

  canUseTool: async (toolName, input) => {
    // permitir leitura sempre
    if (["Read", "Glob", "Grep"].includes(toolName))
      return { behavior: "allow", updatedInput: input };

    // bloquear escrita em .env
    if (toolName === "Write" && input.file_path?.includes(".env"))
      return { behavior: "deny", message: "Não modificar .env" };

    return { behavior: "allow", updatedInput: input };
  }
}

Subagentes simples não se comunicam entre si. Agent Teams, recurso experimental introduzido em 2026, permite que múltiplos agentes em sessões separadas troquem mensagens reais, sob coordenação de um agente líder. Habilite via variável de ambiente:

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

Use quando a tarefa beneficia de paralelismo real e debate (revisão arquitetural, análise multi-perspectiva). Use subagentes simples quando a coordenação é hierárquica (líder pede, helper devolve resumo).