Como executar openClaw (Moltbot/ Clawdbot ) em LLMs locais sem API

CometAPI
AnnaFeb 1, 2026
Como executar openClaw (Moltbot/ Clawdbot ) em LLMs locais sem API

OpenClaw (anteriormente Clawdbot, brevemente Moltbot) explodiu mais rápido do que quase qualquer projeto de agente que já vi.

Em menos de três semanas, ultrapassou 100.000 estrelas no GitHub. As pessoas o chamam de “estagiário de IA 24/7” e, honestamente, essa descrição não está muito longe. Ele pode ler mensagens, executar comandos de shell, gerenciar arquivos e viver silenciosamente em segundo plano enquanto você segue seu dia.

Mas, após a empolgação inicial, uma pergunta muito prática começou a aparecer em todos os lugares:

“Isso é legal… mas como eu executo isso sem queimar dinheiro em APIs?”

Essa pergunta é exatamente o motivo pelo qual escrevi o guia.

Qual é o burburinho por trás do OpenClaw (antigamente Clawdbot)?

Para entender a mudança técnica em direção à execução local, é preciso primeiro compreender o que OpenClaw realmente é. Em sua essência, openClaw ( Moltbot / Clawdbot) é um agente autônomo "conversation-first". Diferente dos chatbots tradicionais que vivem em uma aba do navegador e esperam por prompts, o OpenClaw roda como um daemon em segundo plano no seu computador. Ele se integra diretamente a plataformas de mensagens como WhatsApp, Telegram, Discord e Signal, transformando efetivamente seu app de chat em uma linha de comando para sua vida.

A evolução de Clawdbot para OpenClaw

A história do projeto é tão volátil quanto fascinante.

Clawdbot (Final de 2025): Criado por Peter Steinberger, foi lançado como um wrapper para o Claude da Anthropic, projetado para executar tarefas em vez de apenas gerar texto. Foi apelidado de “Claude com mãos.”

Moltbot (jan de 2026): Após uma disputa de marca com a Anthropic sobre o nome "Clawd", o projeto foi renomeado para "Moltbot", adotando um mascote de lagosta chamado "Molty" (referência à troca de carapaça).

OpenClaw (30 de jan de 2026): Para enfatizar sua natureza open-source e distanciar-se ainda mais de identidades corporativas específicas, mantendo a herança "Claw", a comunidade adotou OpenClaw.

O que diferencia OpenClaw é seu sistema de permissões. Ele pode ler seus e-mails, verificar seu calendário, executar comandos de shell e até gerenciar sua própria memória em arquivos Markdown armazenados localmente. No entanto, sua configuração padrão depende de enviar todo esse contexto para APIs de nuvem (principalmente Anthropic ou OpenAI), o que levanta duas questões críticas: Custo e Privacidade.

Por que você deve migrar para LLMs locais?

A experiência "pronta para uso" do openClaw ( Moltbot / Clawdbot) é alimentada por Claude 3.5 Sonnet ou Opus. Embora esses modelos sejam altamente inteligentes, sua cobrança é por token. Um agente autônomo que roda 24/7 — verificando e-mails, monitorando logs de servidores e resumindo chats — pode gerar milhões de tokens por dia.

O custo da autonomia

Agentes autônomos não se comportam como sessões de chat. Eles entram em loop. Releem o contexto. Resumem logs. Checam a caixa de entrada repetidas vezes.

Já vi usuários relatarem coisas como:

“Deixei o Clawdbot rodando durante a noite para reorganizar meu Obsidian vault e acordei com uma conta de US$ 40.”

Isso não é mau uso — é simplesmente como a autonomia funciona.

Com um modelo local, o custo marginal cai para zero (além da eletricidade). Você para de pensar “devo deixar isso rodar?” e começa a pensar “o que mais posso automatizar?”

Privacidade não é um benefício secundário — é o principal

openClaw ( Moltbot / Clawdbot) pode ler:

  • E-mails
  • Históricos de chat
  • Código-fonte
  • Documentos pessoais

OpenClaw foi projetado para ter acesso profundo ao seu sistema. Ele lê suas mensagens pessoais e sistemas de arquivos. Ao usar uma API, cada arquivo que o bot lê é enviado para um servidor de terceiros para processamento. Ao usar um LLM local, nenhum dado sai da sua rede local. Seus documentos financeiros, chats privados e bases de código permanecem isolados da Big Tech.

Executando OpenClaw com Ollama (minha recomendação padrão)

Se você se sente confortável com o terminal, Ollama é a maneira mais fácil de executar LLMs locais hoje.

openClaw ( Moltbot / Clawdbot) fala APIs compatíveis com OpenAI. O Ollama expõe uma por padrão. Esse é todo o truque.

Checklist mínimo de sistema e software

  • Uma máquina com um sistema operacional recente (Linux/macOS/Windows + WSL2). Aceleração local por GPU recomendada para modelos maiores; apenas CPU funciona para modelos pequenos ou tarefas leves.
  • Node.js ≥ 22 (o CLI e o Gateway do OpenClaw exigem Node).
  • Ollama (ou outro runtime de LLM local) instalado localmente se você planeja executar modelos locais. Ollama expõe uma API local compatível com OpenAI por padrão (geralmente em http://localhost:11434).
  • Se usar um proxy como Lynkr, instale-o (npm ou clone do repositório). Lynkr pode apresentar um endpoint no estilo Anthropic/OpenAI ao OpenClaw enquanto roteia para modelos locais.

Etapa 1: Instalar o OpenClaw (comandos rápidos)

OpenClaw recomenda instalar via npm/pnpm. Execute:

# install OpenClaw CLI globally (Node >= 22)
npm install -g openclaw@latest
# or using pnpm
pnpm add -g openclaw@latest

# run first-time onboarding (installs Gateway daemon)
openclaw onboard --install-daemon

O assistente de onboarding instala um daemon de serviço do usuário (systemd/launchd) para que o Gateway fique em execução em segundo plano. Após o onboarding você pode executar o Gateway manualmente para depuração:

openclaw gateway --port 18789 --verbose

Etapa 2: Instalar o Ollama e baixar um modelo

O Ollama é simples de instalar e executar. No macOS/Linux:

# install Ollama (one-line installer)
curl -fsSL https://ollama.com/install.sh | sh

# pull a recommended assistant model (example)
ollama pull kimi-k2.5

# verify Ollama is running (default API on port 11434)
ollama list
# or check HTTP
curl http://localhost:11434/v1/models

O Ollama expõe uma API compatível com muitos clientes no estilo OpenAI; a integração de provedor do OpenClaw suporta Ollama e detecta automaticamente uma instância local do Ollama, a menos que você sobrescreva a configuração.

Etapa 3: Configuração mínima de modelo do OpenClaw

implantar uma camada de compatibilidade (Lynkr) ou configurar o OpenClaw para apontar para o endpoint local

Como openClaw ( Moltbot / Clawdbot) historicamente fala com certos formatos de API (por exemplo, endpoints no estilo Anthropic), o caminho mais fácil é executar um pequeno proxy que traduza as chamadas do OpenClaw para a API do seu servidor local.

  • Lynkr: instale e configure o Lynkr para escutar na porta que o OpenClaw espera; configure-o para encaminhar para sua instância Ollama/text-generation-webui. Tutoriais da comunidade mostram arquivos de etapas e exemplos de entradas config.json. Depois que o Lynkr estiver em execução, o OpenClaw pode permanecer configurado para o provedor original, mas, na prática, falará com seu modelo local.

Se você preferir alterar a configuração do OpenClaw diretamente, aponte a URL do backend do modelo na configuração .openclaw para o endpoint do seu servidor local:

openClaw ( Moltbot / Clawdbot) armazena a configuração em ~/.openclaw/openclaw.json. Um arquivo mínimo para preferir um modelo local é assim:

{
  "agent": {
    "model": "ollama/kimi-k2.5"
  },
  "models": {
    "providers": {
      "ollama": {
        "name": "Ollama (local)",
        "options": {
          "baseURL": "http://127.0.0.1:11434/v1"
        }
      }
    }
  }
}

Se você omitir o bloco models.providers.ollama, openClaw ( Moltbot / Clawdbot) muitas vezes detectará automaticamente uma instância local do Ollama se disponível. Use openclaw models list e openclaw models set para gerenciar interativamente as configurações de modelo sem editar o arquivo diretamente.

Etapa 4: Iniciar o OpenClaw e testar uma mensagem

Com o Ollama em execução e o Gateway ativo:

# start the gateway (if not running as a daemon)
openclaw gateway --port 18789 --verbose

# send a test message to the agent
openclaw agent --message "Hello from local OpenClaw" --thinking low

Se o Gateway e os modelos estiverem corretamente configurados, você verá o assistente responder e a mensagem ser roteada via o modelo local do Ollama.

Posso tentar evitar modificar o OpenClaw via proxy?

Sim — é exatamente isso que ferramentas de proxy como Lynkr fazem: elas apresentam um endpoint no estilo Anthropic/OpenAI ao openClaw ( Moltbot / Clawdbot) enquanto escutam na porta que o OpenClaw espera e encaminham o conteúdo para uma instância local do Ollama ou text-generation-webui. Isso é valioso porque é sem chave de API, sem cobrança na nuvem e execução de modelo local, evita mudar os internos do OpenClaw enquanto lhe dá controle local.

Visão geral da arquitetura (quais componentes conversam com quais)

  • OpenClaw (agent/app) — o assistente principal, que emite chamadas para o modelo e orquestra ferramentas e integração de mensagens.
  • Proxy de LLM (por exemplo, Lynkr) — recebe solicitações no estilo da API do OpenClaw e encaminha para servidores de modelos locais (ou fallback em nuvem). O proxy também pode implementar cache, redução de tokens e compressão de memória para reduzir custos.
  • Servidor de LLM local (por exemplo, Ollama, runtime ggml standalone, Llama.cpp, modelo local em contêiner) — serve inferência de modelo na máquina. Ollama é amplamente usado porque fornece um servidor local fácil e um fluxo de empacotamento de modelos; outros runtimes são possíveis.
  • Fallback opcional na nuvem — o proxy pode rotear solicitações complexas para modelos na nuvem quando necessário (modo híbrido).

Por que usar um proxy em vez de modificar o openClaw diretamente?

Privacidade & TCO: Inferência local mantém os dados na sua máquina e evita contas de API.

Compatibilidade: openClaw ( Moltbot / Clawdbot) espera uma superfície de API específica (Anthropic/estilo “Copilot”). Um proxy preserva essa superfície para que o OpenClaw exija mudanças mínimas.

Segurança & flexibilidade: O proxy pode implementar regras de roteamento de requisição (local primeiro, fallback na nuvem), rate limiting, truncamento de requisições e outras salvaguardas.

Exemplo: configurar o Lynkr para rotear para o Ollama local

  1. Instalar o Lynkr:
npm install -g lynkr
# or: git clone https://github.com/Fast-Editor/Lynkr.git && npm install
  1. Criar um .env (exemplo):
cp .env.example .env

Edite o .env com:

# primary provider: local Ollama
MODEL_PROVIDER=ollama
OLLAMA_MODEL=kimi-k2.5
OLLAMA_ENDPOINT=http://localhost:11434

# optional hybrid fallback
PREFER_OLLAMA=true
FALLBACK_ENABLED=true
FALLBACK_PROVIDER=openrouter
OPENROUTER_API_KEY=sk-...
  1. Iniciar o Lynkr:
# if installed globally
lynkr

# if cloned
npm start

Por padrão, o Lynkr anunciará um proxy local (por exemplo: http://localhost:8081) e um endpoint /v1 compatível com OpenAI/Anthropic para o qual o OpenClaw pode apontar. Em seguida, configure o provedor de modelo do OpenClaw para usar a URL base do Lynkr (veja o próximo snippet).

Apontar o OpenClaw para o endpoint do Lynkr

Edite ~/.openclaw/openclaw.json ou use o CLI para definir a URL base do seu provedor:

{
  "models": {
    "providers": {
      "copilot": {
        "options": {
          "baseURL": "http://localhost:8081/v1"
        }
      }
    }
  },
  "agent": {
    "model": "kimi-k2.5"
  }
}

Agora openClaw ( Moltbot / Clawdbot) chamará http://localhost:8081/v1 (Lynkr), que roteia para ollama://kimi-k2.5 localmente. Você obtém a experiência contínua de um provedor externo sem sair da sua máquina.

Para usuários que preferem uma Interface Gráfica (GUI) para gerenciar seus modelos, ou que desejam usar modelos quantizados específicos (formato GGUF) do Hugging Face, LM Studio é a escolha preferida.

É seguro executar agentes autônomos localmente?

Essa é talvez a questão mais crítica. Quando você executa openClaw ( Moltbot / Clawdbot), está essencialmente dando acesso de shell a uma IA no seu computador.

O problema do “sudo”

Se você pedir a um Claude baseado na nuvem para "apagar todos os arquivos dos meus documentos", ele pode recusar devido a filtros de segurança. Um modelo local Llama 3 sem censura não tem tais inibições. Se openClaw ( Moltbot / Clawdbot) interpretar mal um comando, teoricamente poderia executar comandos destrutivos.

Boas práticas de segurança

Execute em Docker: Não execute openClaw ( Moltbot / Clawdbot) diretamente no "bare metal" da sua máquina, a menos que você tenha absoluta certeza dos riscos. Use a imagem oficial do Docker, que coloca o ambiente em sandbox.

O exemplo abaixo é um docker-compose.yml mínimo que demonstra três serviços: Ollama (runtime de modelo local), Lynkr (proxy) e OpenClaw Gateway (CLI executado em contêiner). Observação: adapte volumes e passagem de dispositivo para acesso à GPU.

version: "3.8"
services:
  ollama:
    image: ollama/ollama:latest
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ./ollama-data:/var/lib/ollama

  lynkr:
    build: ./lynkr
    restart: unless-stopped
    ports:
      - "8081:8081"
    environment:
      - MODEL_PROVIDER=ollama
      - OLLAMA_ENDPOINT=http://ollama:11434

  openclaw:
    image: node:22
    working_dir: /workspace
    volumes:
      - ~/.openclaw:/root/.openclaw
      - ./workspace:/workspace
    command: sh -c "npm install -g openclaw && openclaw gateway --host 0.0.0.0 --port 18789"
    depends_on:
      - lynkr

Esta é uma stack ilustrativa; implantações em produção devem adicionar isolamento de rede, limites de recursos e mapeamento de dispositivo de GPU quando apropriado.

Etapas comuns de solução de problemas e limitações

Se o openClaw ( Moltbot / Clawdbot) não detectar o Ollama

  • Certifique-se de que o Ollama está em execução e que a URL base é acessível (http://127.0.0.1:11434/v1).
  • Use openclaw models list e openclaw doctor para revelar problemas de configuração.

Se o roteamento do Lynkr falhar

  • Confirme que o Lynkr está escutando (geralmente http://localhost:8081).
  • Verifique .env para correção de OLLAMA_ENDPOINT e MODEL_PROVIDER.
  • Valide se o Lynkr mapeia os caminhos /v1 que openClaw ( Moltbot / Clawdbot) chama — algumas implementações de provedor esperam caminhos ligeiramente diferentes; ajuste os caminhos base se necessário.

Lacunas de capacidade dos modelos

Os modelos locais variam: alguns se destacam em programação, outros em chat. Estratégias híbridas (local primeiro, fallback na nuvem) podem ajudar: roteie tarefas rotineiras localmente e escale raciocínios complexos para um modelo na nuvem com cache para reduzir custo. Lynkr e proxies similares implementam exatamente essa lógica.

Conclusão

O design do OpenClaw e o ecossistema ativo ao seu redor tornam viável hoje uma implantação local, sem API. Com ferramentas como Ollama para hospedagem local, Lynkr para tradução de API e documentação comunitária robusta, você pode executar agentes capazes em máquinas que você controla — de uma GPU de desktop a um dispositivo portátil — sem enviar seus dados para um provedor de LLM de terceiros.

No entanto, se você pesar prós e contras, por exemplo, se ainda quiser usar openClaw ( Moltbot / Clawdbot) via API sem o equipamento necessário, então eu recomendaria CometAPI. Ele fornece endpoints Anthropic e OpenAI e frequentemente oferece descontos — geralmente 20% abaixo do preço oficial.

Desenvolvedores podem acessar e Claude Sonnet/ Opus 4.5 e GPT-5.2 via CometAPI, os últimos modelos listados são na data de publicação do artigo. Para começar, explore as capacidades do modelo no Playground e consulte o API guide para instruções detalhadas. Antes de acessar, certifique-se de que fez login na CometAPI e obteve a chave de API. CometAPI oferece um preço muito inferior ao oficial para ajudar na sua integração.

Pronto para começar?→ Sign up for Gemini 3 today !

Se você quiser saber mais dicas, guias e novidades sobre IA, siga-nos no VK, X e Discord!

Leia Mais

500+ Modelos em Uma API

Até 20% de Desconto