harness-de-agente-autonomo

Harness de Agente Autônomo

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 agrupado.

Limites de Consentimento e Segurança

A operação autônoma deve ser explicitamente solicitada e delimitada pelo usuário. Não crie agendamentos, despache agentes remotos, grave 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 simulação e arquivos de fila locais antes de ativar 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 execute continuamente ou em um agendamento
• Configurando fluxos de trabalho automatizados que disparam periodicamente
• Construindo um assistente de IA pessoal que lembra contexto entre sessões
• O usuário diz "execute isso todos os dias", "verifique isso regularmente", "continue monitorando"
• Quer replicar funcionalidade de Hermes, AutoGPT ou frameworks de agente autônomo similares
• Precisa de uso de computador combinado com execução agendada

Arquitetura

┌──────────────────────────────────────────────────────────────┐
│                    Claude Code Runtime                        │
│                                                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────────┐ │
│  │  Crons   │  │ Despacho │  │ Memória  │  │ Uso de      │ │
│  │ Agendar  │  │ Remoto   │  │ Armazenar│  │ Computador  │ │
│  │ Tarefas  │  │ Agentes  │  │          │  │             │ │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘  └──────┬──────┘ │
│       │              │             │                │        │
│       ▼              ▼             ▼                ▼        │
│  ┌──────────────────────────────────────────────────────┐    │
│  │              Camada de Skill + Agente ECC             │    │
│  │                                                      │    │
│  │  skills/     agents/     commands/     hooks/        │    │
│  └──────────────────────────────────────────────────────┘    │
│       │              │             │                │        │
│       ▼              ▼             ▼                ▼        │
│  ┌──────────────────────────────────────────────────────┐    │
│  │              Camada de Servidor MCP                   │    │
│  │                                                      │    │
│  │  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 MCP de memória para dados estruturados.

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

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

Servidor MCP de memória (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 devem 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 os PRs abertos neste repositório e resuma as 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 os PRs abertos e resuma"

Use um agendador do SO ou um 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 úteis de cron:

Padrão	Agendamento	Caso de Uso
Daily standup	0 9 * * 1-5	Revisar PRs, issues, status de deploy
Revisão semanal	0 10 * * 1	Métricas de qualidade de código, cobertura de teste
Monitoramento por hora	0 * * * *	Saúde da produção, verificação de taxa de erro
Build noturno	0 2 * * *	Executar suite de testes completa, varredura de segurança
Pré-reunião	*/30 * * * *	Preparar contexto para reuniões futuras

3. Despacho / Agentes Remotos

Faça com que um job de CI autenticado ou receptor de webhook invoque o Claude Code em um workspace que ele possui. O ponto de entrada suportado é o modo CLI programático, não um ponto de extremidade 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 na main. Diagnostique a falha."

# Disparar de webhook
# GitHub webhook -> runner de CI autenticado -> claude -p -> resultado revisável

# Disparar de outro agente
claude -p "Analise a saída da varredura de segurança e crie issues para os achados"

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 harness:

• Teste automatizado de UIs web
• Preenchimento de formulários e entrada de dados
• Monitoramento baseado em captura de tela
• Fluxos de trabalho multi-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 fila de tarefas em ~/.claude/projects/*/memory/task-queue.md

# Formato da tarefa
---
name: fila-de-tarefas
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: Encontrar 5 leads no espaço de ferramentas de IA

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

Substituindo Hermes

Componente Hermes	Equivalente ECC	Como
Gateway/Roteador	CLI + agendador externo	Um runner autenticado inicia sessões de agente
Sistema de Memória	Memória Claude + servidor MCP de memória	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 de 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: Configurar Servidores MCP

O MCP de memória é 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 npm público em 2026-09-07. É uma implementação de referência, não um serviço agrupado no 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 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 pacotes não publicados listados anteriormente aqui.

Passo 2: Criar Crons Básicos

Para polling durante uma sessão interativa, digite:

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

Para trabalhos diários ou semanais que devem sobreviver a uma sessão fechada, configure um agendador externo, como um cron job do SO 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 ativá-lo.

Passo 3: Inicializar Grafo de Memória

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

Passo 4: Ativar Uso de Computador (Opcional)

Siga o ambiente de referência de uso de computador vinculado acima, ou a documentação de uma integração de navegador específica que você tenha revisado. 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.

Fluxos de Trabalho de Exemplo

Revisor de PR Autônomo

Cron: a cada 30 min durante o horário de trabalho
1. Verificar novos PRs em repositórios monitorados
2. Para cada novo PR:
   - Fazer pull do branch localmente
   - Executar testes
   - Revisar alterações com agente revisor-de-código
   - Postar comentários de revisão via GitHub MCP
3. Atualizar memória com status da revisão

Agente de Pesquisa Pessoal

Cron: diariamente às 6 AM
1. Verificar consultas de pesquisa salvas na memória
2. Executar pesquisas Exa para cada consulta
3. Resumir novas descobertas
4. Comparar com resultados de ontem
5. Escrever resumo na memória
6. Sinalizar itens de alta prioridade para revisão matinal

Agente de Preparação de Reunião

Disparar: 30 min antes de cada evento de calendário
1. Ler detalhes do evento de calendário
2. Pesquisar memória para contexto sobre participantes
3. Puxar threads recentes de email/Slack com participantes
4. Preparar pontos de discussão e sugestões de pauta
5. Escrever 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 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 arquivos crescerem sem limites.
• Sempre verifique se as tarefas agendadas foram concluídas com sucesso. Adicione tratamento de erros a prompts cron.