Você fala em português, ele pensa, escreve, executa e prova.
Recon, exploração, auditoria de código, relatório, tudo na linha de comando,
com as suas chaves, sem login e sem limite de uso.
Instalar · Primeiro contato · Como usar · Multi-agente · Comandos
| Começar | O que é o clawfast · Instalar · Primeiro contato · Como usar |
| A tela | Mouse, rolagem e ações · O start/stop · Comandos de barra |
| O que ele faz | Auditar um projeto · Rede, alvos e escopo · Avaliação multi-agente · Google Dorks · Conectar APIs · O ghostcyber e a sua memória |
| Estender | Gateways de IA (/api) · /conect: cérebro externo · Skills · Modelos e fallback |
| Manutenção | Atualizar · Por que larguei o npm · Sobre o código · Referência rápida |
Abre o terminal, digita um pedido em português e vê um operador de segurança trabalhando de verdade na sua frente. Ele roda comando, faz requisição HTTP, mapeia alvo, acha vulnerabilidade e escreve o laudo. Não é autocomplete, é um agente com ferramentas reais na mão.
Fiz o clawfast porque as ferramentas de pentest vivem espalhadas. Um scanner aqui, um script ali, o relatório lá no fim, cada coisa num canto. A ideia foi juntar tudo num lugar só, guiado por conversa, rodando na sua máquina, com as suas próprias chaves de modelo, sem login e sem ninguém contando quantas vezes você usou.
Você comanda, ele executa. O terminal vira sua arma.
Um comando e acabou. Não instala Node, não usa npm, não baixa código-fonte. O clawfast vem como um executável único, com o runtime já embutido dentro dele.
Windows (PowerShell)
$s = Join-Path $env:TEMP 'clawfast-install.ps1'; Invoke-WebRequest -UseBasicParsing 'https://github.com/devadeiltonlima/ClawFast-/releases/latest/download/install.ps1' -OutFile $s; & ([scriptblock]::Create((Get-Content -Raw $s)))Linux e macOS
curl -fsSL https://github.com/devadeiltonlima/ClawFast-/releases/latest/download/install.sh | sh
export PATH="$HOME/.clawfast-runtime/bin:$PATH"No Linux e no macOS, joga a linha do export PATH no seu ~/.bashrc ou ~/.zshrc para o comando continuar existindo nos próximos terminais.
Tem para Windows x64, Linux x64, macOS Intel e macOS Apple Silicon.
O instalador baixa o executável da release oficial no GitHub e confere o SHA-256 antes de instalar, então você sabe que o binário chegou inteiro e não foi trocado no caminho. Ele coloca tudo em ~/.clawfast-runtime/ e cria o comando clawfast, num canto isolado que não suja o resto do sistema e ainda guarda cada versão para rollback. E o principal: nada de Node nem npm, porque o runtime de JavaScript já mora dentro do executável.
Depois confere:
clawfast versionDepois de instalado, atualizar é um comando só. Se quer saber por que o npm saiu de cena, é aqui.
Abre o terminal e digita:
clawfastNa primeira vez ele pede uma chave de modelo, só isso. Recomendo a NVIDIA build, que dá modelos de ponta de graça:
- Cria a chave em https://build.nvidia.com/
- Cola quando o clawfast pedir.
A chave fica salva em ~/.clawfast/.env, na sua máquina. Sem servidor no meio, sem login, sem ninguém do outro lado vendo o que você faz. É a sua chave e o seu terminal.
Prefere outro provedor? O /api conecta 25 gateways (OpenAI, Claude, Groq, DeepSeek, Ollama…). Dá pra trocar a chave depois, a qualquer momento, com ele. Os modelos disponíveis estão em modelos e fallback.
Depois que o banner sobe, você só conversa. Escreve o que quer, em português, e deixa ele trabalhar:
❯ faça um recon completo de example.com
❯ teste essa API por IDOR e me mostre a prova
❯ crie um script python que valida esse XSS e rode
❯ analise o meu projeto e me diga onde estão as falhas
❯ gere um relatório do que encontramos até agora
Ele escolhe as ferramentas, executa comando por comando, mostra a saída ao vivo e entrega o resultado. A graça é essa: você não precisa decorar a sintaxe de dez ferramentas diferentes, só descreve a intenção e acompanha na tela, podendo interromper, redirecionar ou aprofundar na hora que quiser.
Para o pedido inteiro de uma vez em avaliação multi-agente. Para auditar código em vez de atacar, veja o modo só leitura.
O terminal continua sendo um terminal, mas a tela do clawfast responde ao mouse do jeito que você espera, sem atalho nenhum antes.
| O que você faz | O que acontece |
|---|---|
roda do mouse, PgUp e PgDn |
rola a conversa pra trás e pra frente |
| arrastar o mouse por cima do texto | seleciona, sem segurar Shift. Quando você solta, já está copiado |
Ctrl+C com algo selecionado |
copia e avisa no canto da tela |
| clicar numa mensagem que você mandou | abre as ações dela |
As ações da mensagem são três:
| Ação | O que faz |
|---|---|
| Copiar | manda o texto daquela mensagem pra área de transferência |
| Reverter | desfaz daqui pra frente e devolve o texto pra caixa de input, pra você reescrever e tentar de novo |
| Bifurcar | leva aquela mensagem pra uma sessão nova, sem mexer na atual |
Sobre o Reverter, uma coisa precisa ficar clara: ele devolve arquivo. Os arquivos que o agente escreveu ou alterou naquele trecho voltam como estavam, a conversa some da tela e o histórico volta atrás. O que ele não faz é desfazer requisição que já saiu pela rede nem comando que já rodou no alvo. Isso não tem volta em lugar nenhum, e o clawfast avisa em vez de fingir que limpou.
Se quiser voltar pra uma conversa antiga depois de fechar o programa, o /session guarda as suas sessões e o encerramento te mostra o comando pronto:
clawfast -s ses_0f7d409d7be8c064Ele pode estar no meio de qualquer coisa. Um scan, um exploit, dez processos abertos. Você manda parar e para tudo, na hora.
| Tecla | O que faz |
|---|---|
Esc |
interrompe o que está rodando. Só isso, não fecha nada |
F4 |
INICIAR e PARAR, o botão que fica na caixa de input. O PARAR mata tudo de uma vez: o turno do modelo, a fila de mensagens, as ferramentas rodando, as sessões vivas (msfconsole, sqlmap, ssh, banco) e a árvore inteira de processos |
clicar em [ PARAR ] |
a mesma coisa do F4, direto na tela, sem apertar nada antes |
Ctrl+C |
com texto selecionado, copia. Sem nada selecionado, fecha o clawfast |
↑ e ↓ |
navega pelo histórico de comandos |
| digitar durante a execução | manda texto direto pro programa em andamento (REPLs, prompts, sudo) |
Botei o start/stop porque um agente autônomo com ferramentas reais na mão pode disparar um comando pesado, um scan longo ou um processo que abre outros processos. Você precisa de um freio de emergência que freia de verdade, não de um "cancelar" bonitinho que deixa coisa rodando por baixo dos panos. O PARAR aborta o modelo, esvazia a fila, encerra as sessões e derruba a árvore inteira de processos (no Windows via taskkill /T), então nada fica órfão comendo a sua máquina ou cutucando o alvo.
Depois de instalado, atualizar é isso:
clawfast upgradeO clawfast update faz a mesma coisa. Por dentro ele age assim, e com cuidado: primeiro consulta a última release no GitHub, e se você já está na mais nova, avisa e não faz nada. Se tiver versão nova, ele baixa o executável novo, confere o SHA-256 e troca o binário em ~/.clawfast-runtime/, guardando o anterior numa pasta por versão. Se algo der errado no download ou na conferência, o executável antigo continua no lugar, então você nunca fica sem o clawfast. E ele nunca baixa código-fonte, só o executável, o instalador e os checksums. O código continua fechado.
Ainda tem o aviso automático. No boot ele checa o GitHub no máximo uma vez por dia, em segundo plano, e na próxima vez que você abrir aparece sozinho um "nova versão disponível, rode clawfast update". Depois de atualizar, fecha e abre o clawfast pra rodar a versão nova.
clawfast --versionAntes o clawfast era npm install -g clawfast. Parei com isso, e o motivo é bem direto.
A verificação automática de segurança do npm começou a barrar as publicações do clawfast. As versões 2.11.1, 2.11.2 e 2.11.3 foram bloqueadas, e enquanto isso a tag latest no npm ficava travada numa versão velha. Resultado: quem rodava update continuava baixando a versão antiga, sem novidade nenhuma.
A saída foi cortar o npm de vez. Agora o clawfast sai como executável verificado por SHA-256 direto do GitHub Releases. Instala uma vez pelo comando lá de cima e, daí em diante, clawfast upgrade puxa as próximas versões do GitHub, sem npm no meio, sem nada travando a entrega. Foi isso que empurrou o projeto pro ciclo 3.x. O número mudou porque o canal de distribuição mudou, não porque teve reescrita ou quebra de compatibilidade.
Digita / a qualquer momento pra abrir o menu ao vivo:
| Comando | O que faz |
|---|---|
/model |
troca o modelo da sessão num seletor com setas, ou com o mouse — veja modelos |
/variant |
nível de esforço de raciocínio (baixo, médio, alto) do modelo ativo, onde o provedor aceita |
/session |
abre uma sessão nova levando um resumo da anterior, ou volta pra uma guardada. Lá dentro, o /delete apaga uma sessão do disco |
/api |
conecta um dos 25 gateways de IA: busca o provedor, cola a chave, escolhe o modelo — veja gateways |
/preferencias |
mostra o que o clawfast lembra de você (sempre, nunca, estilo) e apaga o que não quiser mais |
/skills |
lista as skills instaladas |
/skillcreator |
cria uma skill nova (ensina o clawfast a fazer algo do seu jeito) |
/conect |
conecta uma IA externa (Claude Code, Codex, Gemini) pra dirigir o clawfast via MCP — veja /conect |
/system |
salva o cérebro do agente (system prompt) num visualizador HTML |
/nov |
mostra as novidades da versão |
/exit |
fecha o clawfast |
Entra na pasta do seu projeto e roda clawfast ali mesmo. Pede uma auditoria e ele vira um auditor dedicado, só leitura, sozinho, sem precisar de comando especial:
❯ analise o meu projeto e procure vulnerabilidades e segredos
A partir daí ele mapeia o projeto inteiro, montando o grafo de imports nos dois sentidos pra achar import quebrado, ciclo e arquivo órfão. Vai atrás de vulnerabilidade de verdade: SQLi, injeção de comando e de código, XSS, TLS desligado, cripto fraca, CORS aberto, chave e token embutidos (que aparecem mascarados no laudo). Ele combina análise determinística com o raciocínio do modelo pra rastrear o fluxo de dados de ponta a ponta, e só aceita o que consegue provar, jogando fora todo achado sem caminho confirmado no código real.
Fiz o modo assim porque auditar não é editar. Aqui ele nunca cria, altera ou apaga nada no seu projeto. A única coisa que ele escreve é um relatório ANALISE_PROJETO_<data>.md na raiz. Seu código fica intocado, e você confia no laudo sabendo que ele não pôs a mão em nada. Quer voltar pro modo de ataque? Só falar "modo normal".
Esse mesmo olhar de código vira o agente Source quando você pede uma avaliação multi-agente.
O clawfast não é teórico, ele fala com a rede. Faz requisição HTTP nativa (GET, POST, headers, cookies, payloads, ele bate no alvo e lê a resposta), roda recon de superfície completo (descoberta de subdomínio, varredura de porta, coleta de conteúdo e inteligência sobre o alvo), executa de verdade os scanners e ferramentas que você tem instalados (e te ajuda a instalar os que faltam) e faz verificação de exploit, porque "parece vulnerável" não basta, ele monta a prova e roda pra confirmar.
E o escopo é sagrado. Poder de execução real pede uma fronteira real. Você define o alvo, e se qualquer parte do agente for tocar em algo fora do escopo, um formulário que manda dado pra outro host, um probe num alvo não autorizado, a operação para na hora e te mostra exatamente o quê e onde, sem tocar. Você autoriza (ou não) e manda seguir. Ele nunca sai do escopo sozinho.
Use o clawfast só em sistemas que você tem autorização explícita pra testar.
Pede uma avaliação completa e o clawfast para de rodar uma ferramenta por vez. Um Orquestrador sobe quatro agentes especialistas que trabalham juntos no mesmo alvo, conversando entre si e dividindo um mapa vivo do sistema:
❯ faça uma avaliação completa de https://example.com
❯ pentesta meu sistema: o site é https://app.exemplo.com e o código está em ./
| Agente | O que faz |
|---|---|
| 🔎 Discovery | mapeia a superfície: links, formulários, tecnologias, endpoints |
| 🌐 Web | testa o comportamento em runtime, de forma segura: status, headers, CORS, reflexão |
| 🧬 Source | audita o seu código (só leitura), achando rotas e fluxos de dados perigosos |
| 🧪 Validator | confirma cada achado com prova, e é honesto quando não dá pra provar |
O pulo do gato não é ter quatro agentes, é a correlação. Quando o Source acha um parâmetro do código que cai num ponto perigoso (um fetch, um exec, uma query) e esse mesmo parâmetro aparece exposto num endpoint que o Discovery mapeou, o clawfast junta os dois num achado de alta confiança. É o tipo de falha, tipo SSRF ou injeção, que scanner isolado não enxerga, porque olha código e superfície separados.
Tudo que os agentes descobrem vira nó num grafo do alvo que persiste, e o clawfast te diz o próximo passo com base nele. E você acompanha ao vivo:
Tudo isso respeita o escopo, e uma IA externa conectada pelo /conect também alcança a avaliação multi-agente.
Recon por operador de busca, de graça e sem chave, em cima do DuckDuckGo e do Bing. Você diz a intenção e o clawfast monta a sintaxe, ou dispara um pacote pronto contra um domínio:
❯ roda os dorks de segredos e backups em example.com
❯ procura painéis de admin e diretórios abertos em example.com
São pacotes no estilo Google Hacking Database pra segredo e chave, backup, arquivo de config, .git exposto, painel de admin, listagem de diretório e dado vazado no GitHub, Pastebin ou S3. É sem chave de propósito, porque recon inicial não devia custar nem depender de API paga. Ele usa os buscadores públicos e ainda abre os melhores resultados pra você já ir lendo.
Cole a chave no chat e peça o que quer. O clawfast registra a conexão uma vez, guarda local (só você lê) e reusa nas próximas sessões. O segredo aparece sempre mascarado.
❯ minha chave do shodan é 1a2b3c… — puxa tudo de example.com
❯ conecta essa chave sk-or-… e lista os modelos
| Como ele reconhece | Serviços |
|---|---|
| Pelo prefixo da chave | OpenRouter, Groq, NVIDIA, xAI, Perplexity, GitLab, OpenAI, Anthropic, GitHub, Stripe, Slack, Hugging Face, Replicate, SendGrid, Google, Telegram, Apify |
| Pelo nome (OSINT sem prefixo) | Shodan, SecurityTrails, VirusTotal, Hunter, AbuseIPDB, urlscan, HIBP, ipinfo, GreyNoise, Censys, LeakIX, DeepSeek, Mistral |
| Qualquer outra | Você passa a URL base e o tipo de auth |
Colou com aspas, quebra de linha ou do jeito NOME=valor de um .env? Ele limpa antes de salvar. O tráfego sai pelo Tor por padrão. Se o provedor bloquear o Tor (403, 429, página do Cloudflare), o próprio erro avisa e você liga direct: true na conexão. Ele nunca sai direto sem você pedir.
O clawfast não é um assistente. É um ghostcyber: direto, frio, sem "Olá, como posso ajudar?". Ele trabalha como um operador de red team sênior, sempre no mesmo ciclo:
recon → hipótese → exploração → prova → encadeamento → registro
Mapeia antes de tocar, ataca primeiro o que tem mais chance e impacto, começa pela técnica mais silenciosa e só reporta o que conseguiu provar. O que não provou, ele diz que não está confirmado. Depois de cada vitória pergunta "isso destrava o quê?", pra transformar achado pequeno em caminho de alto impacto.
E ele aprende o seu jeito. Fala no chat e ele grava pra sempre, em qualquer projeto e com qualquer modelo:
❯ lembra que sempre quero o relatório em tópicos
❯ nunca rode sqlmap com --risk 3 sem me avisar
❯ a partir de agora fala comigo mais curto
| Tipo | Pra quê |
|---|---|
| fazer | o que ele deve sempre fazer |
| evitar | o que ele nunca deve fazer |
| estilo | tom, idioma e formato das respostas |
Pra ver tudo que ele sabe de você, ou apagar uma regra: /preferencias. Fica em ~/.clawfast/preferencias.json, na sua máquina.
Digita /api e abre uma lista com busca. Escolhe o provedor, cola a chave e escolhe o modelo, tudo em janelas flutuantes:
╔══[ NOVA CHAVE OPENROUTER ]═════════════════════════ esc ═╗
║ ║
║ Cole a chave OpenRouter (formato sk-or-…). ║
║ Crie em https://openrouter.ai/keys ║
║ ║
║ ┌────────────────────────────────────────────────────┐ ║
║ │ ❯ •••••••••••••••••••••••••••••••••• (73)▌ │ ║
║ └────────────────────────────────────────────────────┘ ║
║ ║
╟──────────────────────────────────────────────────────────╢
║ [Enter] confirma [Ctrl+V] cola [Esc] cancela ║
╚══════════════════════════════════════════════════════════╝
A chave nunca aparece na tela e é testada antes de salvar: se o provedor recusar, nada é gravado e a anterior continua. Escolheu um modelo que raciocina? Ele já pergunta o esforço: baixo, médio ou alto.
| Grupo | Provedores |
|---|---|
| Nativos | NVIDIA, OpenRouter, Google Gemini |
| Nuvem | OpenAI, Anthropic (Claude), Groq, DeepSeek, xAI (Grok), Mistral, Together, Fireworks, Cerebras, DeepInfra, SambaNova, Perplexity, Moonshot (Kimi), Z.ai (GLM), Qwen, Hugging Face, Cohere, Novita, Vercel AI Gateway |
| Seu próprio | LiteLLM (proxy), Ollama e LM Studio (locais, sem chave), ou Outro: qualquer API compatível com OpenAI |
Quer um modelo de fronteira dirigindo o clawfast? Digita /conect e aponta o Claude Code, Codex, Gemini ou Qwen pra ele. A IA externa vira o cérebro e o clawfast continua sendo as mãos e os olhos. Ela chama as ferramentas, você vê tudo acontecer no seu terminal.
Não é uma IA conversando com a outra. Aqui a IA conectada usa o clawfast como ferramenta, com todo o arsenal na mão, inclusive a avaliação multi-agente. E fica tudo preso em 127.0.0.1, protegido por token, então nada disso sai da sua máquina. Configura uma vez e esquece.
Com /skillcreator você cola ou escreve uma skill, que é uma técnica, um checklist, um playbook do seu jeito, de qualquer tamanho:
❯ /skillcreator
nome da skill? ❯ xss-recon
descrição curta? ❯ rotina de caça a XSS refletido e armazenado
palavras-gatilho? ❯ xss, cross-site scripting
cole a skill agora ❯ (cole o conteúdo... termine com /fim)
A skill vira conhecimento disponível pra todos os modelos, mas o conteúdo completo só carrega quando o seu pedido casa com ela. Fiz assim pra manter o contexto leve e barato: o playbook pesado só entra quando é útil, em vez de ficar ocupando espaço em toda conversa. Lista com /skills e remove com /skill delete <nome>.
O clawfast tem uma cadeia de fallback automática. Se um modelo falha ou bate no limite, ele passa pro próximo sozinho. Isso importa porque modelo grátis bate em rate limit (429) o tempo todo, e sem fallback você travaria no meio de um pentest. Com ele, a sessão segue e você nem percebe.
O provedor primário é a NVIDIA build (gratuita), com modelos de função de verdade, aqueles em que as ferramentas disparam mesmo:
nvidia/nemotron-3-ultra-550bmistralai/mistral-large-4-1tdeepseek-ai/deepseek-v4.1-flashz-ai/glm-5.3-flash
A lista do /model vem do catálogo oficial da NVIDIA ao vivo: modelo aposentado some sozinho, modelo novo aparece com a marca novo, e o que está pra sair mostra a data.
Quer fixar um modelo? Abre o /model e escolhe com as setas. Quer voltar pro automático? /model auto.
Sendo honesto com você sobre o que é o executável:
O binário não tem o código-fonte do projeto dentro. Ele carrega o JavaScript empacotado e minificado junto com o runtime. Você não recebe os arquivos-fonte, nem o repositório, nem o build.
Mas, pra não te vender ilusão: um executável compilado ainda pode ser analisado por alguém habilidoso, dá pra extrair o bundle minificado de dentro dele. Contra usuário comum, é fechado. Contra engenharia reversa determinada, não é segredo absoluto. Os checksums protegem contra corrupção, não substituem a confiança na conta do GitHub.
E as ferramentas externas que o clawfast usa durante uma sessão podem pedir dependências próprias. Só o runtime do CLI está incluído no executável.
O de sempre, que vale repetir: use o clawfast só em sistemas que você tem autorização explícita pra testar.
Instalar
Windows (PowerShell):
$s = Join-Path $env:TEMP 'clawfast-install.ps1'; Invoke-WebRequest -UseBasicParsing 'https://github.com/devadeiltonlima/ClawFast-/releases/latest/download/install.ps1' -OutFile $s; & ([scriptblock]::Create((Get-Content -Raw $s)))Linux ou macOS:
curl -fsSL https://github.com/devadeiltonlima/ClawFast-/releases/latest/download/install.sh | sh
export PATH="$HOME/.clawfast-runtime/bin:$PATH"No dia a dia
clawfast # abre o agente
clawfast upgrade # atualiza pela última versão (pelo GitHub, sem npm)
clawfast --version # mostra a versão instaladaDentro do agente
/model /variant /api /preferencias /session /skills /skillcreator /conect /system /nov /exit