Performance do OpenClaw — Guia de Otimização

Introdução

Velocidade importa mais do que as pessoas reconhecem. Um assistente que demora 15 segundos para responder uma pergunta simples cria fricção suficiente para fazer as pessoas pararem de usá-lo. Por outro lado, respostas em 1-2 segundos criam uma experiência fluida que incentiva o uso frequente e a adoção de novos casos de uso.

Performance em sistemas de IA é multidimensional: envolve a escolha do modelo, o tamanho do contexto, a infraestrutura do servidor, a latência de rede até as APIs, e otimizações específicas do OpenClaw como streaming e cache. Cada um desses fatores contribui para a latência total que o usuário experimenta.

Este guia vai guiá-lo por cada dimensão de performance, com medições práticas, configurações específicas e estratégias de otimização. Ao final, você vai entender onde estão os gargalos do seu setup e como eliminá-los.

Pré-requisitos

Para aproveitar este guia:

• OpenClaw instalado e funcionando
• Familiaridade com config.yaml
• Acesso ao terminal para comandos de diagnóstico
• Noção básica dos modelos disponíveis (guia de modelos)

Entendendo a Latência Total

A latência que o usuário sente é a soma de várias etapas:

Usuário envia mensagem
    ↓ [A] Latência do canal (WhatsApp, Telegram...)
OpenClaw recebe mensagem
    ↓ [B] Processamento local (montar contexto, aplicar SOUL.md)
    ↓ [C] Latência de rede até a API de IA
API processa e gera resposta
    ↓ [D] Tempo de inferência (o modelo pensando)
    ↓ [C] Latência de rede de volta
OpenClaw processa resposta
    ↓ [B] Processamento local (aplicar tools, executar ações)
    ↓ [A] Latência do canal (enviar resposta)
Usuário recebe resposta

Onde cada fator impacta mais:

• [A] Canal: geralmente 100-500ms, pouco controlável
• [B] Processamento local: 50-500ms, otimizável com hardware
• [C] Rede: 100-800ms, dependente da localização
• [D] Inferência: 1-20+ segundos, o maior fator — controlável via modelo e contexto

Diagnóstico de Performance

Antes de otimizar, meça onde está o problema:

# Diagnóstico completo de performance
openclaw perf diagnose

# Saída esperada:
# Canal (WhatsApp): 180ms avg
# Processamento local: 120ms avg
# Latência até API (Anthropic São Paulo): 245ms avg
# Inferência (Claude Sonnet, 15k tokens context): 3.2s avg
# Total end-to-end: 3.7s avg

# Benchmark de latência da API
openclaw ping --model claude-sonnet-4 --iterations 10
# Média: 287ms | Min: 198ms | Max: 445ms

# Benchmark completo (envia mensagem real)
openclaw bench --message "Olá, que horas são?" --iterations 5
# Latência total avg: 2.8s

# Monitoramento contínuo de performance
openclaw perf monitor --interval 30

# Ver relatório das últimas horas
openclaw perf report --period 6h

# Ver histograma de latências
openclaw perf histogram --period 24h

Otimização por Componente

1. Escolha do Modelo — Maior Impacto

A escolha do modelo é o fator mais impactante na latência:

agents:
  defaults:
    model:
      primary: "claude-sonnet-4"   # 2-5s — padrão recomendado

# Para tarefas que precisam de velocidade máxima:
  profiles:
    fast:
      model:
        primary: "claude-haiku-3-5"  # 0.5-2s

Benchmarks de latência por modelo:

O salto de Sonnet para Haiku (ou GPT-4o-mini) frequentemente resulta em resposta 2-4x mais rápida para o mesmo tipo de pergunta simples.

2. Tamanho do Contexto — Segundo Maior Impacto

Cada token no contexto adiciona tempo de processamento:

agents:
  defaults:
    contextTokens: 30000    # Reduzir de 200k para 30k melhora latência ~3-5x

    compaction:
      mode: "auto"
      threshold: 0.7        # Compacta antes de ficar pesado
      summaryLength: "short"

Impacto do tamanho do contexto na latência (Claude Sonnet 4):

Para uso diário onde conversas raramente precisam de mais de 30.000 tokens de histórico, configurar contextTokens: 30000 dá excelente performance.

3. Streaming — Melhora a Percepção de Velocidade

Com streaming ativado, o usuário começa a ver a resposta enquanto ela é gerada, não apenas no final:

agents:
  defaults:
    streaming: true    # Ativar streaming de respostas
    streamingChannel:
      whatsapp: true   # Disponível no WhatsApp
      telegram: true   # Disponível no Telegram
      discord: true    # Disponível no Discord

Diferença na experiência com streaming:

• Sem streaming: usuário espera 4 segundos, então recebe a resposta completa
• Com streaming: usuário vê as primeiras palavras em 0.5s, resposta completa chega progressivamente

Mesmo quando a latência total é igual, streaming faz o sistema parecer muito mais responsivo.

4. Cache de Respostas

Configure cache para perguntas frequentes:

cache:
  enabled: true
  ttlSeconds: 300         # Cache por 5 minutos
  maxEntries: 500

  # O que cachear
  strategies:
    - pattern: "qual.*temperatura|previsão.*tempo|clima"
      ttl: 1800           # Clima: cache por 30 minutos

    - pattern: "como instalar|tutorial|guia"
      ttl: 86400          # Tutoriais: cache por 24 horas

    - pattern: ".*atual.*|.*agora.*|.*hoje.*"
      ttl: 0              # Não cachear perguntas sobre estado atual

Para heartbeats que repetem as mesmas verificações, cache pode eliminar 60-80% das requisições à API.

5. Cache de Prompt (Prompt Caching)

Diferente do cache de respostas, o prompt caching reutiliza partes estáticas do contexto dentro da mesma sessão:

agents:
  defaults:
    promptCaching:
      enabled: true
      ttl: 600            # Reutiliza contexto por 10 minutos
      cacheSystemPrompt: true  # SOUL.md + USER.md cacheados

Com prompt caching, o SOUL.md (geralmente 1.000-5.000 tokens) é processado apenas uma vez por sessão, não a cada mensagem. Em conversas longas, isso pode reduzir o custo em 20-40% e melhorar latência ligeiramente.

6. Hardware do Servidor

O servidor onde o OpenClaw roda impacta o processamento local:

Requisitos mínimos:

• CPU: 1 core
• RAM: 512MB
• Rede: 10 Mbps

Configuração recomendada para uso intenso:

• CPU: 2+ cores
• RAM: 2-4GB
• Rede: 100+ Mbps
• SSD para armazenamento de logs/memória

# Verificar recursos do servidor
openclaw status --resources

# Saída:
# CPU: 8% (1 core)
# RAM: 412MB / 1024MB (40%)
# Disco: 2.1GB usado / 40GB total
# Rede: TX 2.1KB/s | RX 8.4KB/s

Se a RAM está constantemente acima de 80%, considere:

1. Reduzir contextTokens
2. Limitar número de sessões abertas simultâneas
3. Aumentar a RAM do servidor

7. Localização do Servidor

A latência de rede entre seu servidor e os datacenters da Anthropic/OpenAI impacta diretamente a velocidade:

# Medir latência de rede para APIs
openclaw ping --endpoint anthropic --count 10
# Médias esperadas:
# Brasil → Anthropic (Virginia/Oregon): 150-250ms
# Europa → Anthropic: 80-150ms

# Se a latência estiver acima de 500ms, considere trocar de servidor

Recomendações de localização:

• Para menor latência: servidor na América do Norte (us-east-1, us-west-2)
• Para usuários no Brasil: tradeoff entre latência de API vs. latência para o usuário
• VPS no Brasil com boa conexão internacional geralmente funciona bem

Otimizações Avançadas

Connection Pooling

Reutilize conexões HTTPS para as APIs em vez de criar novas a cada requisição:

network:
  keepAlive: true
  maxConnections: 10
  connectionTimeout: 30000
  requestTimeout: 60000

Rate Limiting Inteligente

Evite erros de rate limit que causam delays:

rateLimit:
  anthropic:
    requestsPerMinute: 50      # Abaixo do limite da API
    tokensPerMinute: 90000     # Abaixo do limite de tokens
    retryOnLimit: true
    retryDelay: 5000           # Aguardar 5s antes de retry

  strategy: "smooth"          # smooth, burst, strict
  # "smooth" distribui requisições uniformemente
  # "burst" permite picos mas throttle depois

Processamento em Background

Para tarefas não urgentes, processe em background sem bloquear respostas:

background:
  enabled: true
  maxConcurrent: 5

  tasks:
    - pattern: "salve no memory|anote"
      async: true              # Não espera conclusão para responder
    - pattern: "relatório|análise detalhada"
      async: false             # Espera conclusão (tarefa crítica)

Compactação Proativa

Em vez de esperar a compactação automática (que acontece quando o contexto está quase cheio), programe compactações preventivas:

compaction:
  proactive:
    enabled: true
    triggerAfterMessages: 20   # Compacta a cada 20 mensagens
    triggerAfterHours: 2       # Ou a cada 2 horas

Monitoramento de Performance em Produção

Dashboard de Métricas

# Abrir dashboard de performance
openclaw perf dashboard

# Mostra em tempo real:
# - Latência média das últimas 1h, 6h, 24h
# - Distribuição de latências (histograma)
# - Tokens processados por hora
# - Taxa de cache hits
# - Erros e timeouts

Alertas de Performance

monitoring:
  alerts:
    - metric: p95_latency
      threshold: 10000         # 10 segundos
      action: notify
      channel: telegram

    - metric: error_rate
      threshold: 0.05          # 5% de erros
      action: notify_and_log

    - metric: cache_hit_rate
      threshold: 0.2           # Abaixo de 20% de hits
      action: log_warning

Logs de Performance

# Ativar logging detalhado de performance
openclaw config set logging.performance true

# Ver logs de performance
openclaw perf logs --last 100

# Identificar as mensagens mais lentas
openclaw perf slow --threshold 10000 --last 24h
# Mostra todas as mensagens que demoraram mais de 10s nas últimas 24h

Configuração de Referência: Setup Otimizado

Aqui está uma configuração de referência balanceando performance e qualidade:

# config.yaml — Configuração otimizada para performance

agents:
  defaults:
    model:
      primary: "claude-sonnet-4"
      fallback: "claude-haiku-3-5"

    contextTokens: 30000
    streaming: true

    compaction:
      mode: "auto"
      threshold: 0.65
      summaryLength: "short"

    promptCaching:
      enabled: true
      ttl: 600
      cacheSystemPrompt: true

cache:
  enabled: true
  ttlSeconds: 300
  maxEntries: 1000

rateLimit:
  strategy: "smooth"
  requestsPerMinute: 40

network:
  keepAlive: true
  maxConnections: 10

logging:
  performance: true
  level: "warn"              # Menos logging = menos I/O = mais rápido

Erros Comuns e Soluções

Boas Práticas

• Meça antes de otimizar: Use openclaw perf diagnose para entender onde está o gargalo. Otimizar o componente errado desperdiça tempo.

• Streaming é quase sempre vantajoso: Habilite streaming para todos os canais que suportam. A experiência percebida melhora drasticamente mesmo sem mudança na latência total.

• Contexto menor, resposta mais rápida: Para 90% das conversas, 20.000-30.000 tokens de contexto é mais que suficiente e significativamente mais rápido que 200.000.

• Perfis de modelo para perfis de uso: Configure Haiku para heartbeats e triagem, Sonnet para uso geral, Opus apenas para tarefas críticas. Esse roteamento inteligente melhora tanto performance quanto custo.

• Monitor antes de ter problemas: Configure alertas de performance e revise o dashboard semanalmente. Degradação gradual de performance é difícil de notar sem monitoramento.

• Compactação preventiva é melhor que reativa: Configure compactação para acontecer antes do contexto ficar cheio. Compactação de emergência quando o contexto está 95% cheio pode causar delay perceptível.

Perguntas Frequentes

Qual a latência mínima realista para o OpenClaw? Com Claude Haiku, contexto de 5.000 tokens e streaming ativado, o usuário vê a primeira palavra em 300-500ms e a resposta completa em 1-2 segundos. Com Sonnet e contexto moderado (20.000 tokens), latência total típica é 2-4 segundos.

Vale a pena hospedar o OpenClaw nos EUA para reduzir latência da API? Depende de onde estão seus usuários. Se os usuários são no Brasil e o servidor está nos EUA, você elimina a latência Brasil → Anthropic mas adiciona latência para a entrega da resposta ao usuário. Geralmente é mais eficaz manter servidor no Brasil com boa conexão internacional.

O streaming funciona no WhatsApp? Sim, o OpenClaw implementa streaming no WhatsApp editando a mensagem progressivamente (mostrando “…” e depois o texto completo). A experiência é boa, mas diferente do streaming em interfaces como o ChatGPT onde as palavras aparecem uma a uma.

Como o cache afeta a precisão das respostas? Não afeta, desde que você configure os padrões de cache corretamente. Perguntas sobre estado atual (hora, data, eventos recentes) não devem ser cacheadas. Para informações estáticas (como usar uma feature, documentação, etc.), cache é totalmente seguro.

Posso usar CDN para melhorar performance? Para webhooks e a interface web de admin, sim, um CDN pode reduzir latência. Para o processamento principal (gateway), CDN não ajuda — é comunicação bidirecional em tempo real. A otimização mais impactante ainda é a escolha de modelo e tamanho de contexto.

Próximos Passos

• Guia de Modelos — Escolha o modelo certo para cada tarefa
• Context Window — Gerencie contexto para melhor performance
• Custos — Performance e custo andam juntos
• Debugging — Diagnose problemas de performance com logs
• Automação Avançada — Otimize pipelines automatizados