--- title: Squad de Agentes com Paperclip + OpenClaw: Tutorial Prático para Gerar Leads em Autopilot description: Tutorial executável: monte uma squad de 3 agentes de IA usando Paperclip para governança e OpenClaw para execução. Geração de leads automatizada rodando em menos de 1 dia. date: 2026-04-02 url: https://caminhosolo.com.br/2026/04/squad-agentes-paperclip-openclaw-guia-pratico/ tags: [agentes-ia, paperclip, openclaw, automacao, geração-de-leads, solopreneur, ia] --- ## TL;DR Você não precisa de equipe de SDR para gerar leads. Você precisa de uma squad de agentes de IA coordenada. Este tutorial mostra, passo a passo, como montar uma operação de geração de leads com 3 agentes: um que pesquisa e define alvos, um que executa scraping e enriquecimento via OpenClaw, e um que valida e formata dados. Tudo coordenado pelo Paperclip — com orçamento travado, auditoria e zero chance de gastar mais do que você definiu. Leitura de 20 minutos, operação rodando em menos de 1 dia. --- Um solo builder que precisa de leads hoje tem três opções: gastar 4 horas por dia prospectando manualmente, pagar R$ 3.000+ por mês em uma ferramenta SaaS de prospecção, ou montar uma squad de agentes que faz o trabalho enquanto você dorme. A terceira opção parecia ficção até poucos meses atrás. Hoje é código rodando no seu servidor. A combinação de dois projetos open-source mudou o jogo: o [Paperclip — que cruza 42.000 estrelas no GitHub em menos de um mês — dá estrutura de governança, orçamento e coordenação](/2026/04/paperclip-governar-agentes-ia-controle-custo/) para equipes de agentes de IA. O [OpenClaw — com 339.000+ estrelas — executa tarefas reais](/2026/03/openclaw-agente-ia-pessoal-solopreneur/): scraping, navegação web, envio de dados, integração com APIs. Juntos, formam algo parecido com uma empresa operada por uma pessoa só — exatamente o que o [solopreneur moderno](/2026/03/solopreneur-moderno) defende. Este artigo não é sobre o que essas ferramentas prometem. É sobre como conectá-las e rodar uma operação real de geração de leads automatizada. --- ## O que você vai construir Um sistema com 3 agentes trabalhando juntos, coordenados por uma instância local do Paperclip: ``` ┌─────────────────────────────────────────────┐ │ PAPERCLIP (Governança) │ │ │ │ ┌──────────────┐ │ │ │ Agente 1 │ ← Define ICP, quebra │ │ │ Researcher │ tarefas de pesquisa │ │ └──────┬───────┘ │ │ │ POST /issues │ │ ▼ │ │ ┌──────────────┐ │ │ │ Agente 2 │ ← Executa scraping, │ │ │ Executor │ enriquecimento via │ │ │ (OpenClaw) │ OpenClaw │ │ └──────┬───────┘ │ │ │ PATCH /issues │ │ ▼ │ │ ┌──────────────┐ │ │ │ Agente 3 │ ← Valida dados, │ │ │ Validator │ remove duplicatas, │ │ │ │ formata saída │ │ └──────────────┘ │ │ │ │ Budget: $50/mês por agente │ │ Heartbeat: a cada 15 minutos │ │ Audit log: tudo registrado │ └─────────────────────────────────────────────┘ ``` O resultado final: uma planilha CSV ou JSON com leads enriquecidos (nome, empresa, cargo, email, LinkedIn, tecnologias usadas), gerada automaticamente a partir de um ICP que você definiu. ### Caso de uso específico Você é um dev solo que vende um micro-SaaS de monitoramento de uptime. Seu ICP são CTOs e DevOps leads de empresas SaaS com 10-200 funcionários. A squad pesquisa empresas no nicho, extrai dados de contato dos decisores e entrega uma lista pronta para outreach. --- ## Stack mínima necessária Antes de começar, verifique o que você precisa: | Componente | O que é | Onde pegar | |---|---|---| | Node.js 20+ | Runtime do Paperclip | nodejs.org | | pnpm 9.15+ | Gerenciador de pacotes | `npm install -g pnpm` | | Paperclip | Orquestrador da squad | `npx paperclipai onboard --yes` | | OpenClaw | Agente executor | github.com/openclaw/openclaw | | LLM API key | Claude, GPT-4o ou similar | provedor da sua escolha | | Servidor Linux (opcional) | Para rodar 24/7 | Qualquer VPS, $5/mês | **Custo estimado para rodar:** $30-80/mês em APIs de LLM + $5/mês de servidor. Compare com $3.000+ de uma ferramenta SaaS equivalente. --- ## Arquitetura da squad de agentes ### Papéis de cada agente **Agente 1 — Researcher (Estratégia)** - Recebe o goal da company ("gerar 200 leads qualificados por semana no nicho SaaS") - Quebra em subtarefas: "pesquisar empresas SaaS B2B com 10-200 funcionários nos EUA" - Cria issues no Paperclip com contexto e critérios - Não executa scraping — apenas planeja e delega - Runtime: Claude Code ou qualquer adapter que suporte raciocínio complexo **Agente 2 — Executor (OpenClaw)** - Recebe issues atribuídas via heartbeat - Executa scraping real usando browser automation do OpenClaw - Consulta LinkedIn, Crunchbase, sites de empresas - Enriquece dados: busca emails com Hunter.io, verifica tecnologias com BuiltWith/Wappalyzer - Retorna dados brutos como comentário na issue - Runtime: OpenClaw gateway **Agente 3 — Validator (Qualidade)** - Recebe issues com dados brutos do Executor - Valida formato de email (regex + MX lookup) - Remove duplicatas - Verifica campos obrigatórios preenchidos - Formata saída final (CSV/JSON) - Marca issue como "done" ou devolve para o Executor com correções - Runtime: Claude Code (modo light, menor custo) --- ## Fluxo completo (como o trabalho acontece) 1. Você define o goal no Paperclip: "Gerar 200 leads qualificados de CTOs em empresas SaaS B2B" 2. O Researcher acorda no heartbeat, lê o goal, cria 10 issues de pesquisa (20 leads cada) 3. O Executor acorda, pega uma issue via `POST /issues/{id}/checkout`, abre o browser do OpenClaw, faz scraping, comenta os dados brutos na issue 4. O Validator acorda, lê os dados brutos, valida, formata, salva no workspace compartilhado 5. O Researcher monitora progresso, ajusta alvos se necessário, cria novas issues 6. Tudo roda em ciclo de 15 minutos, com orçamento travado por agente Cada ciclo do heartbeat gasta tokens. O Paperclip garante que nenhum agente estoure o orçamento mensal. --- ## Implementação passo a passo ### Passo 1: Instalar o Paperclip ```bash # Instalar dependências npm install -g pnpm # Clonar e configurar git clone https://github.com/paperclipai/paperclip.git cd paperclip pnpm install # Iniciar (abre o dashboard no navegador) pnpm dev ``` Alternativamente, a forma mais rápida: ```bash npx paperclipai onboard --yes ``` Isso abre `http://localhost:3100` com o wizard de onboarding. O banco PostgreSQL é criado automaticamente — sem configuração externa. ### Passo 2: Criar a company No dashboard do Paperclip, clique em "Create Company" e preencha: ``` Nome: LeadGen Squad Missão: Identificar e extrair dados de contato de decisores em empresas SaaS B2B, gerando listas qualificadas para outreach automatizado. ``` A missão é importante — cada agente usa ela como contexto para tomar decisões autônomas. Seja específico sobre o resultado esperado. ### Passo 3: Definir o goal Crie o goal principal da company: ``` Goal: Geração semanal de leads Descrição: Gerar 200 leads qualificados por semana. Cada lead deve conter: nome, cargo, empresa, email, LinkedIn URL, tecnologias usadas. Focar em CTOs e DevOps leads de empresas SaaS B2B com 10-200 funcionários nos EUA. KPI: leads_validos / semana >= 200 ``` ### Passo 4: Contratar o CEO e os agentes O Paperclip começa com um CEO por padrão. No nosso caso, o CEO é o **Researcher**. **Configurar o CEO/Researcher:** ``` Nome: Researcher Título: Lead Research Strategist Adapter: claude_local Budget mensal: $50 Heartbeat: a cada 30 minutos ``` No campo de instruções do agente (SOUL.md), adicione: ```markdown Você é um estrategista de pesquisa de leads. Sua função: 1. Analisar o goal da company e quebrar em tarefas executáveis 2. Criar issues específicas para o Executor 3. Monitorar qualidade dos leads gerados pelo Validator 4. Ajustar critérios de busca com base nos resultados Regras: - Nunca execute scraping você mesmo — delegue para o Executor - Cada issue deve ter critérios claros e mensuráveis - Se um lead vier inválido 3 vezes, mude a fonte de dados ``` **Contratar o Executor:** No dashboard, clique em "Hire Agent": ``` Nome: Executor Título: Lead Data Extractor Adapter: openclaw_gateway Budget mensal: $50 Heartbeat: a cada 15 minutos Reports to: Researcher ``` Instruções do Executor: ```markdown Você é um executor de scraping e coleta de dados. Suas ferramentas: browser, curl, APIs. Quando receber uma issue de pesquisa: 1. Abra o browser e navegue até a fonte indicada 2. Extraia os dados conforme os critérios da issue 3. Enriqueça com email e LinkedIn quando possível 4. Comente os dados brutos na issue em formato JSON 5. Mude o status para in_review Formato de saída: [ { "nome": "João Silva", "cargo": "CTO", "empresa": "Acme SaaS", "email": "joao@acme.com", "linkedin": "https://linkedin.com/in/joaosilva", "tecnologias": ["AWS", "Kubernetes", "Datadog"] } ] ``` **Contratar o Validator:** ``` Nome: Validator Título: Lead Quality Assurance Adapter: claude_local Budget mensal: $30 Heartbeat: a cada 20 minutos Reports to: Researcher ``` Instruções do Validator: ```markdown Você é um validador de qualidade de leads. Quando uma issue chegar com status in_review: 1. Verifique se todos os campos obrigatórios estão preenchidos 2. Valide formato de email (deve conter @ e domínio válido) 3. Remova leads duplicados (mesmo email ou mesmo LinkedIn) 4. Verifique se o cargo é realmente de decisor 5. Se mais de 20% dos leads estiverem inválidos, devolva para o Executor 6. Se aprovado, formate como CSV e salve no workspace 7. Mude o status para done Critérios de rejeição: - Email genérico (info@, contact@, hello@) - Cargo não é de decisor (intern, assistant, coordinator) - Empresa com menos de 10 funcionários - Dados incompletos (faltando 2+ campos) ``` ### Passo 5: Configurar budgets e proteções No dashboard do Paperclip, vá em Settings → Budget: ``` Budget global da company: $150/mês Por agente: - Researcher: $50/mês (soft warning em 80% = $40) - Executor: $50/mês (soft warning em 80% = $40) - Validator: $30/mês (soft warning em 80% = $24) Hard stop: 100% — agente é pausado automaticamente Circuit breaker: pausar se 3 falhas consecutivas ``` Isso garante que você nunca acorde com uma conta surpresa de API. --- ## Como conectar o OpenClaw como executor Esta é a parte que nenhum outro tutorial mostra. O OpenClaw funciona como o "músculo" da operação — ele executa o trabalho pesado enquanto o Paperclip gerencia a coordenação. ### Setup do OpenClaw ```bash # Instalar OpenClaw no mesmo servidor git clone https://github.com/openclaw/openclaw.git cd openclaw npm install # Configurar variáveis de ambiente cp .env.example .env ``` No `.env`, configure: ```env OPENCLAW_LLM_PROVIDER=anthropic OPENCLAW_MODEL=claude-sonnet-4-20250514 OPENCLAW_API_KEY=sua-api-key OPENCLAW_TOOLS=browser,shell,http,file OPENCLAW_BROWSER_HEADLESS=true ``` ### Conectar ao Paperclip via gateway O Paperclip tem um adapter nativo para OpenClaw: `openclaw_gateway`. A conexão usa SSE (Server-Sent Events) para streaming e device-key pairing para autenticação. No Paperclip, quando você cria o agente Executor com adapter `openclaw_gateway`, o sistema gera um token de conexão. Copie esse token e configure no OpenClaw: ```bash # No servidor do OpenClaw openclaw connect --paperclip-url http://localhost:3100 \ --token SEU_TOKEN_DE_CONEXAO \ --agent-id id-do-executor ``` Após a conexão, o OpenClaw fica em standby e responde aos heartbeats do Paperclip. --- ## Como o agente responde ao heartbeat Este é o ciclo central. A cada intervalo configurado (15 minutos para o Executor), o Paperclip "acorda" o agente e ele segue um fluxo de 9 passos: ### Passo a passo do heartbeat **1. Confirmação de identidade** O agente chama o endpoint para saber quem é: ```http GET /api/agents/me Headers: Authorization: Bearer {token} ``` Resposta: ```json { "id": "agent-executor-001", "name": "Executor", "title": "Lead Data Extractor", "budget": { "monthly": 50, "spent": 12.30 }, "reportsTo": "agent-researcher-001" } ``` **2. Buscar tarefas** ```http GET /api/companies/{companyId}/issues?assigneeAgentId=agent-executor-001&status=todo,in_progress ``` Resposta: ```json { "issues": [ { "id": "issue-042", "title": "Extrair 20 leads de empresas de monitoring SaaS", "status": "todo", "priority": "high", "description": "Buscar CTOs em Datadog, New Relic, Grafana Labs...", "goalId": "goal-leads-semanal" } ] } ``` **3. Checkout da tarefa** O agente "pega" a tarefa atomicamente — nenhum outro agente pode pegar a mesma: ```http POST /api/issues/issue-042/checkout Headers: X-Paperclip-Run-Id: run-abc123 Authorization: Bearer {token} ``` Se retornar `409 Conflict`, outro agente já está trabalhando nela. O agente NÃO deve tentar novamente — apenas pula para a próxima. **4. Executar o trabalho** Aqui o OpenClaw faz o que faz de melhor — abre o browser, navega, extrai dados: ```javascript // Pseudocódigo da execução do OpenClaw async function extractLeads(issue) { const targets = parseTargets(issue.description); const leads = []; for (const target of targets) { // Navegar até o site da empresa await browser.navigate(target.url); // Extrair informações do time/pessoas const team = await browser.scrape({ selector: '.team-member, [class*="person"]', extract: ['name', 'title', 'linkedin_url'] }); // Enriquecer com email for (const person of team) { if (isDecisionMaker(person.title)) { person.email = await hunterAPI.findEmail( person.name, target.domain ); person.technologies = await builtWithAPI .lookup(target.domain); leads.push(person); } } } return leads; } ``` **5. Atualizar status** ```http PATCH /api/issues/issue-042 Headers: X-Paperclip-Run-Id: run-abc123 Authorization: Bearer {token} Content-Type: application/json { "status": "in_review", "comment": "Extraídos 18 leads de 3 empresas. 2 empresas bloquearam scraping (Cloudflare). Leads em anexo no workspace como leads_batch_042.json." } ``` **6. Criar subtasks se necessário** ```http POST /api/companies/{companyId}/issues Content-Type: application/json { "title": "Retry scraping para empresas bloqueadas", "status": "todo", "assigneeAgentId": "agent-executor-001", "parentId": "issue-042", "goalId": "goal-leads-semanal", "description": "Usar método alternativo: buscar via Google cache ou API pública" } ``` ### O ciclo completo visualizado ``` [Heartbeat: 15min] │ ▼ GET /api/agents/me ← Quem sou eu? │ ▼ GET /api/issues?status=todo ← O que tem pra fazer? │ ├── Nada ──→ Dormir até próximo heartbeat │ ▼ (Tem tarefa) POST /issues/{id}/checkout ← Pegar a tarefa │ ├── 409 ──→ Outro agente já pegou, pular │ ▼ (Checkout OK) Executar scraping ← OpenClaw faz o trabalho │ ▼ PATCH /issues/{id} ← Reportar resultado │ ▼ Dormir até próximo heartbeat ``` --- ## Simulação de execução real Vamos simular um ciclo completo de geração de leads rodando. **Cenário:** O Researcher definiu como alvo empresas de monitoring SaaS. Criou 5 issues, cada uma com 4 empresas para extrair leads. **Ciclo 1 — Executor acorda (minuto 0)** ``` → GET /api/agents/me Agent: Executor, Budget restante: $47.20 → GET /api/issues?status=todo 5 issues encontradas → POST /issues/issue-001/checkout Status: 200 OK — tarefa adquirida → Executando scraping... - Navegou até datadog.com/team - Extraiu 6 pessoas, 2 são decisores - Enriqueceu com Hunter.io: 2 emails encontrados - Enriqueceu com BuiltWith: AWS, Kubernetes, Terraform → PATCH /issues/issue-001 Status: in_review Comentário: 2 leads extraídos da Datadog. Dados em workspace/leads_001.json ``` **Ciclo 2 — Validator acorda (minuto 0)** ``` → GET /api/agents/me Agent: Validator, Budget restante: $28.50 → GET /api/issues?status=in_review 1 issue encontrada (issue-001) → Validando leads... - Lead 1: email válido (mx check OK), cargo OK (VP Engineering) - Lead 2: email válido, cargo OK (Director of SRE) - 0 duplicatas encontradas → PATCH /issues/issue-001 Status: done Comentário: 2/2 leads aprovados. CSV salvo em workspace/leads_001_validated.csv → Arquivo gerado: nome,cargo,empresa,email,linkedin,tecnologias "Sarah Chen","VP Engineering","Datadog","sarah.c@datadoghq.com","linkedin.com/in/sarahchen","AWS,Kubernetes,Terraform" "Marcus Rivera","Director of SRE","Datadog","m.rivera@datadoghq.com","linkedin.com/in/marcusrivera","AWS,Datadog,Grafana" ``` **Ciclo 3 — Executor pega próxima issue** Mesmo fluxo, mas para New Relic. E assim por diante. **Resultado ao final do dia:** 40-60 leads validados, dependendo da velocidade de scraping e bloqueios encontrados. --- ## Como monitorar (audit log + budget) ### Audit log Toda ação fica registrada no audit log do Paperclip. Acesse pelo dashboard em: ``` http://localhost:3100 → Company → Audit Log ``` Você vê: - Quem executou o quê - Quando foi executado - Tokens gastos por operação - Decisões tomadas e por quê Isso é fundamental para debug. Se um agente gerar leads errados, você volta no log e vê exatamente o que aconteceu. ### Monitoramento de budget No dashboard, a aba de Budget mostra: ``` Company Budget: $150/mês ├── Researcher: $12.40 / $50.00 (24.8%) ✅ ├── Executor: $31.20 / $50.00 (62.4%) ⚠️ próximo do soft warning └── Validator: $5.80 / $30.00 (19.3%) ✅ Total gasto: $49.40 / $150.00 Projeção mensal: $98.80 (baseado nos últimos 7 dias) ``` ### Alertas configuráveis - **80% do budget:** Notificação no dashboard (soft warning) - **100% do budget:** Agente pausado automaticamente (hard stop) - **3 falhas consecutivas:** Circuit breaker pausa o agente - **5 heartbeats sem progresso:** Alerta de agente travado --- ## O que dá pra monetizar com isso A squad de leads não é só uma ferramenta interna — é um produto ou serviço que você pode vender. ### 1. Leads como serviço Configure a squad para gerar leads no nicho de um cliente. Cobrar R$ 5-15 por lead validado. Com 200 leads/semana, são R$ 1.000-3.000/semana de receita recorrente. Seu custo: ~$50/mês em APIs. ### 2. Venda listas prontas Crie listas de leads enriquecidos por nicho e venda como produto digital no Gumroad ou Hotmart. Listas de "CTOs de SaaS B2B nos EUA" ou "Head of Engineering em fintechs brasileiras" vendem entre R$ 97-497. ### 3. Outreach automatizado como serviço Leads + email automatizado = agência de prospecção. Monte o pacote completo: geração de leads + sequência de emails + follow-up. Cobrar R$ 2.000-5.000/mês por cliente. ### 4. Dados como produto Agregue dados coletados e venda acesso via API ou dashboard. Informações sobre tecnologias usadas por empresas, tamanho de equipe de engenharia, stack de infraestrutura — tudo isso tem valor para recrutadoras, VCs e empresas de vendas B2B. --- ## Versão 1 simples (rodando em 1 dia) Se tudo acima parece muito, aqui está o mínimo viável: **Manhã (2 horas):** - Instalar Paperclip: `npx paperclipai onboard --yes` - Criar a company com missão simples - Contratar apenas o Researcher e o Executor **Tarde (2 horas):** - Instalar OpenClaw no mesmo servidor - Conectar ao Paperclip via gateway adapter - Criar 3 issues de teste com alvos simples **Noite (1 hora):** - Monitorar os primeiros heartbeats - Ajustar instruções dos agentes baseado nos resultados - Validar os primeiros leads manualmente **No dia seguinte:** - Adicionar o Validator - Ajustar budgets - Deixar rodando em ciclos de 15 minutos Não espere perfeição no primeiro dia. O objetivo é ter 10-20 leads gerados automaticamente para validar que o fluxo funciona. --- ## Como evoluir para algo mais robusto Depois que a V1 estiver rodando, o caminho de evolução: ### Semana 2: Múltiplas fontes - Adicionar mais sources de scraping (Crunchbase, AngelList, Product Hunt) - Cada fonte vira uma subtask específica - O Executor aprende a lidar com bloqueios — técnica similar ao que mostramos no [guia de agentes autônomos](/2026/03/agentes-ia-autonomos-guia-pratico/) ### Semana 3: Enriquecimento avançado - Integrar Clearbit ou Apollo.io para enriquecimento em massa - Adicionar scoring de lead (cargo sênior = score maior) - Filtrar leads com score baixo automaticamente ### Semana 4: Pipeline completo - Conectar com [ferramenta de outreach via n8n](/2026/03/automacao-n8n-solopreneur/) (Instantly, Smartlead) - Automatizar sequência de emails após validação - Adicionar tracking de respostas e conversões ### Mês 2+: Escalar - Adicionar agentes para diferentes nichos - Rodar squads paralelas (uma por vertical) - Criar dashboard interno para clientes (se vendendo como serviço) --- ## Erros comuns (e como evitar) ### 1. Budget sem proteção **Erro:** Configurar agentes sem hard stop. **Consequência:** Loop infinito pode gerar centenas de dólares em tokens em horas. **Solução:** Sempre configurar hard stop em 100%. Nunca pule essa etapa. ### 2. Instruções vagas **Erro:** Dar instruções genéricas como "encontre leads bons". **Consequência:** Agentes geram leads irrelevantes ou com dados incompletos. **Solução:** Escrever critérios específicos e mensuráveis. "Lead = nome + cargo + empresa + email verificado + LinkedIn URL". Sem esses campos, não é lead. ### 3. Pular o Validator **Erro:** Usar dados do Executor direto, sem passar pelo Validator. **Consequência:** 30-50% dos leads terão emails inválidos, dados incompletos ou duplicatas. **Solução:** Nunca pule a etapa de validação. O Validator paga o custo de ter qualidade. ### 4. Muitos agentes no dia 1 **Erro:** Contratar 5+ agentes antes de entender o fluxo. **Consequência:** Impossível debugar quando algo dá errado. **Solução:** Começar com 2 agentes (Researcher + Executor). Adicionar o Validator depois. Só escalar quando os 3 estiverem estáveis. ### 5. Ignorar o audit log **Erro:** Configurar e esquecer. **Consequência:** Problemas se acumulam silenciosamente. Leads ruins chegam até clientes. **Solução:** Revisar o audit log diariamente nos primeiros 2 semanas. Depois, semanalmente. ### 6. Não configurar o relatório do agente **Erro:** Agentes sem hierarchy definida. **Consequência:** Agentes trabalham sem supervisão, criam tarefas duplicadas. **Solução:** Sempre definir `reportsTo`. O Researcher gerencia o fluxo, os outros reportam para ele. --- ## Limitações reais hoje Sendo honesto sobre o que ainda não funciona perfeito: **Scraping com proteção anti-bot.** Sites com Cloudflare, reCAPTCHA ou autenticação exigem workarounds. O OpenClaw consegue navegar sites dinâmicos (JavaScript rendering), mas sites com proteção avançada podem bloquear. Solução: usar APIs públicas quando disponíveis, ou Google Cache como fallback. **Custo de tokens.** Cada heartbeat gasta tokens, mesmo quando não há tarefas. Com 3 agentes rodando a cada 15 minutos, o custo de "idle" é real. Solução: usar rotinas (cron) em vez de heartbeat para agentes que não precisam de verificação constante. **Memória entre sessões.** Agentes do Paperclip não lembram de execuções anteriores por padrão. Se o Executor descobre que um site bloqueia scraping, essa informação se perde no próximo heartbeat. Solução: usar o sistema de memória do Paperclip (arquivos SKILL.md e MEMORY.md) ou salvar descobertas no workspace. **Conexão OpenClaw pode cair.** O gateway SSE entre Paperclip e OpenClaw pode perder conexão. Não há retry automático robusto ainda. Solução: monitorar o status da conexão e reiniciar quando necessário. **Paperclip ainda é v0.3.x.** O projeto é jovem. Há 440 issues abertas e a API pode mudar entre versões. Não coloque em produção crítica sem testar bem. --- ## Próximos passos 1. Instale o Paperclip agora: `npx paperclipai onboard --yes` 2. Crie a company com a missão de geração de leads 3. Configure 2 agentes (Researcher + Executor) e teste por 1 semana 4. Adicione o Validator na segunda semana 5. Quando estiver estável, comece a vender o serviço ou usar internamente A combinação Paperclip + OpenClaw não é só uma ferramenta — é uma arquitetura para operar como uma empresa de uma pessoa só. Governança de um lado, execução do outro. Você no comando. Você não precisa de equipe. Você precisa construir sistemas. --- **Leia também:** - [Paperclip: Como Governar Agentes de IA Sem Quebrar a Banca](/2026/04/paperclip-governar-agentes-ia-controle-custo/) - [OpenClaw: Guia Completo — Agente de IA Pessoal Self-Hosted via WhatsApp](/2026/03/openclaw-agente-ia-pessoal-solopreneur/) - [Squad de Funcionários Virtuais: Como Multiplicar sua Capacidade com Agentes Orquestrados](/2026/03/squad-funcionarios-virtuais-agentes-orquestrados/) - [Múltiplos Agentes de IA Trabalhando em Paralelo](/2026/03/agent-orchestrator-agentes-paralelos/)