Arnês de Agente Autônomo

O que Arnês de Agente Autônomo faz?

Combine as ferramentas de sessão do Claude Code com integrações configuradas separadamente para agendamento, memória e uso de computador. Este é um padrão de configuração, não um runtime sempre ativo empacotado.

Limites de Consentimento e Segurança

A operação autônoma deve ser explicitamente solicitada e escopada pelo usuário. Não crie agendamentos, despache agentes remotos, escreva memória persistente, use controle de computador, publique externamente, modifique recursos de terceiros ou aja em comunicações privadas a menos que o usuário tenha aprovado essa capacidade e o workspace alvo para a configuração atual.

Prefira planos de execução simulada (dry-run) e arquivos de fila locais antes de habilitar ações recorrentes ou orientadas a eventos. Mantenha credenciais, exportações de workspaces privados, conjuntos de dados pessoais e automações específicas de conta fora de artefatos ECC reutilizáveis.

Quando Ativar

• O usuário quer um agente que funcione continuamente ou em um cronograma
• Configurando fluxos de trabalho automatizados que são acionados periodicamente
• Construindo um assistente de IA pessoal que lembra o contexto entre sessões
• O usuário diz "execute isso todos os dias", "verifique isso regularmente", "continue monitorando"
• Deseja replicar funcionalidades do Hermes, AutoGPT ou frameworks de agente autônomo similares
• Precisa de uso de computador combinado com execução agendada

Arquitetura

┌──────────────────────────────────────────────────────────────┐
│                    Claude Code Runtime                        │
│                                                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────────┐ │
│  │  Crons   │  │ Dispatch │  │ Memory   │  │ Computer    │ │
│  │ Schedule │  │ Remote   │  │ Store    │  │ Use         │ │
│  │ Tasks    │  │ Agents   │  │          │  │             │ │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └──────┬──────┘ │
│       │              │             │                │        │
│       ▼              ▼             ▼                ▼        │
│  ┌──────────────────────────────────────────────────────┐    │
│  │              ECC Skill + Agent Layer                  │    │
│  │                                                      │    │
│  │  skills/     agents/     commands/     hooks/        │    │
│  └──────────────────────────────────────────────────────┘    │
│       │              │             │                │        │
│       ▼              ▼             ▼                ▼        │
│  ┌──────────────────────────────────────────────────────┐    │
│  │              MCP Server Layer                        │    │
│  │                                                      │    │
│  │  memory    github    exa    supabase    browser-use  │    │
│  └──────────────────────────────────────────────────────┘    │
└──────────────────────────────────────────────────────────────┘

Componentes Principais

1. Memória Persistente

Use o sistema de memória integrado do Claude Code aprimorado com o servidor de memória MCP para dados estruturados.

Memória integrada (~/.claude/projects/*/memory/):

• Preferências do usuário, feedback, contexto do projeto
• Armazenada como arquivos markdown com frontmatter
• Carregada automaticamente no início da sessão

Servidor de memória MCP (grafo de conhecimento estruturado):

• Entidades, relações, observações
• Estrutura de grafo consultável
• Persistência entre sessões

Padrões de memória:

# Curto prazo: contexto da sessão atual
Use TodoWrite para rastreamento de tarefas na sessão

# Médio prazo: arquivos de memória do projeto
Escreva em ~/.claude/projects/*/memory/ para recall entre sessões

# Longo prazo: grafo de conhecimento MCP
Use mcp__memory__create_entities para dados estruturados permanentes
Use mcp__memory__create_relations para mapeamento de relacionamentos
Use mcp__memory__add_observations para novos fatos sobre entidades conhecidas

2. Operações Agendadas (Crons)

Use as tarefas agendadas nativas do Claude Code para prompts recorrentes dentro de uma sessão interativa. Essas tarefas têm escopo de sessão; um agendador externo é necessário para trabalhos que precisam ser executados independentemente de uma sessão aberta. Nenhum servidor MCP de agendamento é necessário para /loop.

Configurando um cron:

# Em uma sessão interativa do Claude Code
/loop 30m Revise PRs abertos neste repositório e resuma falhas de CI.

Para uma execução única a partir de um shell, defina o diretório de trabalho antes de invocar a CLI:

cd "/caminho/para/repo" && claude -p "Revise PRs abertos e resuma"

Use um agendador do sistema operacional ou cronograma de CI para invocar esse comando repetidamente quando nenhuma sessão interativa estiver em execução. Configure a autenticação e as permissões de ferramentas do executor separadamente.

Padrões de cron úteis:

Padrão	Agendamento	Caso de Uso
Daily standup	0 9 * * 1-5	Revisar PRs, issues, status de deploy
Weekly review	0 10 * * 1	Métricas de qualidade de código, cobertura de testes
Hourly monitor	0 * * * *	Saúde da produção, verificação de taxas de erro
Nightly build	0 2 * * *	Executar suite completa de testes, varredura de segurança
Pre-meeting	*/30 * * * *	Preparar contexto para reuniões futuras

3. Despacho / Agentes Remotos

Tenha um job de CI autenticado ou um receptor de webhook invocando o Claude Code em um workspace que ele possui. O ponto de entrada suportado é o modo CLI programático, não um endpoint de despacho público da Anthropic.

Padrões de despacho:

# Execute dentro do workspace de CI
cd "/caminho/para/repo" && claude -p "O build falhou no main. Diagnostique a falha."

# Acione a partir de webhook
# GitHub webhook -> runner de CI autenticado -> claude -p -> resultado revisável

# Acione a partir de outro agente
claude -p "Analise a saída da varredura de segurança e crie issues para as descobertas"

4. Uso de Computador

O controle de computador precisa de uma integração configurada separadamente. A ferramenta de uso de computador e ambiente de referência da Anthropic requer um aplicativo para executar chamadas de ferramenta em um ambiente de desktop isolado. Adicionar um nome de pacote MCP não fornece esse ambiente.

Capacidades:

• Automação de navegador (navegar, clicar, preencher formulários, capturar tela)
• Controle de desktop (abrir aplicativos, digitar, controle de mouse)
• Operações de sistema de arquivos além da CLI

Casos de uso dentro do arnês:

• Testes automatizados de interfaces web
• Preenchimento de formulários e entrada de dados
• Monitoramento baseado em captura de tela
• Fluxos de trabalho com múltiplos aplicativos

5. Fila de Tarefas

Gerencie uma fila persistente de tarefas que sobrevivem aos limites da sessão.

Implementação:

# Persistência de tarefas via memória
Escreva a fila de tarefas em ~/.claude/projects/*/memory/task-queue.md

# Formato da tarefa
---
name: task-queue
type: project
description: Fila de tarefas persistente para operação autônoma
---

## Tarefas Ativas
- [ ] PR #123: Revisar e aprovar se CI estiver verde
- [ ] Monitorar deploy: verificar /health a cada 30 min por 2 horas
- [ ] Pesquisar: Encontre 5 leads no espaço de ferramentas de IA

## Concluídas
- [x] Daily standup: revisou 3 PRs, 2 issues

Substituindo Hermes

Componente Hermes	Equivalente ECC	Como
Gateway/Router	CLI + agendador externo	Um executor autenticado inicia sessões de agente
Sistema de Memória	Memória Claude + servidor de memória MCP	Persistência integrada + grafo de conhecimento
Registro de Ferramentas	Servidores MCP	Provedores de ferramentas carregados dinamicamente
Orquestração	Skills + agentes ECC	Definições de skill direcionam o comportamento do agente
Uso de Computador	Integração configurada separadamente	Controle de navegador ou desktop em ambiente isolado
Gerenciador de Contexto	Gerenciamento de sessão + memória	Ciclo de vida da sessão ECC 2.0
Fila de Tarefas	Lista de tarefas persistida em memória	TodoWrite + arquivos de memória

Guia de Configuração

Passo 1: Configure os Servidores MCP

O servidor de memória MCP é opcional. O servidor de memória de referência MCP é publicado como @modelcontextprotocol/server-memory; a versão 2026.8.31 foi verificada no registro público npm em 2026-09-07. É uma implementação de referência, não um serviço empacotado ECC.

Após revisar esse pacote e aprovar seu uso, mescle esta entrada na configuração MCP com escopo de usuário em ~/.claude.json, preservando as configurações existentes. Substitua MEMORY_FILE_PATH por um caminho absoluto em um diretório privado que você possui. Consulte Configuração MCP do Claude Code para registro via CLI e configuração cmd /c npx no Windows.

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/[email protected]"],
      "env": {
        "MEMORY_FILE_PATH": "/caminho/absoluto/para/privado/memory.jsonl"
      }
    }
  }
}

Não registre pacotes npm adivinhados ou não publicados: npx -y executaria qualquer coisa que fosse posteriormente publicada sob esse nome. Verifique o pacote exato, editor e versão antes de adicionar outro servidor. Agendamento e uso de computador não requerem os três nomes de pacote não publicados listados anteriormente aqui.

Passo 2: Crie Crons Base

Para sondagem durante uma sessão interativa, digite:

/loop 30m Revise PRs abertos neste repositório e resuma falhas de CI.

Para trabalho diário ou semanal que deve sobreviver a uma sessão fechada, configure um agendador externo, como um cron do sistema operacional ou GitHub Actions, para executar o comando único do Passo 2 dos Componentes Principais. Chamar claude -p para solicitar um agendamento não provisiona um agendador sempre ativo. Escolha o agendamento, workspace e ações permitidas explicitamente antes de habilitá-lo.

Passo 3: Inicialize o Grafo de Memória

# Inicialize sua identidade e contexto
claude -p "Crie entidades de memória para: eu (perfil do usuário), meus projetos, meus contatos principais. Adicione observações sobre prioridades atuais."

Passo 4: Habilite o Uso de Computador (Opcional)

Siga o ambiente de referência de uso de computador vinculado acima, ou a documentação para uma integração específica de navegador que você revisou. Conceda apenas as permissões necessárias e verifique uma ação inofensiva no ambiente isolado antes de adicioná-la a fluxos de trabalho agendados.

Exemplos de Fluxos de Trabalho

Revisor Autônomo de PR

Cron: a cada 30 min durante o horário de trabalho
1. Verifique novos PRs em repositórios monitorados
2. Para cada novo PR:
   - Faça pull da branch localmente
   - Execute testes
   - Revise alterações com o agente code-reviewer
   - Publique comentários de revisão via GitHub MCP
3. Atualize a memória com o status da revisão

Agente de Pesquisa Pessoal

Cron: diariamente às 6h
1. Verifique consultas de pesquisa salvas na memória
2. Execute pesquisas Exa para cada consulta
3. Resuma novas descobertas
4. Compare com resultados de ontem
5. Escreva resumo na memória
6. Sinalize itens de alta prioridade para revisão matinal

Agente de Preparação para Reuniões

Acionamento: 30 min antes de cada evento de calendário
1. Leia detalhes do evento de calendário
2. Pesquise na memória contexto sobre participantes
3. Puxe threads recentes de e-mail/Slack com participantes
4. Prepare pontos de discussão e sugestões de pauta
5. Escreva documento de preparação na memória

Restrições

• Prompts agendados nativos compartilham sua sessão interativa. Invocações de agendador externo iniciam sessões separadas, a menos que explicitamente retomadas.
• Uso de computador requer concessões explícitas de permissão. Não assuma acesso.
• Automação via CLI ainda consome uso de modelo e está sujeita aos limites do provedor configurado. Escolha intervalos de agendador apropriados.
• Arquivos de memória devem ser mantidos concisos. Arquive dados antigos em vez de deixar os arquivos crescerem indefinidamente.
• Sempre verifique se as tarefas agendadas foram concluídas com sucesso. Adicione tratamento de erros aos prompts de cron.