CheetahClaws

July 9, 2026 · View on GitHub

CheetahClaws : une infrastructure de harnais d'agent rapide et facile à utiliser pour les systèmes d'IA à horizon long, multi-modèles et utilisant des outils

Site web · Scaling the Harness · Signaler un problème ·

Installation rapide

pip install cheetahclaws

Puis lancez simplement :

cheetahclaws        # start chatting!

Autres méthodes d'installation : script d'installation en une ligne | installation depuis les sources | installation avec uv | exécution directe depuis les sources | détails complets d'installation

🖥️ Vous préférez une application native ? Une version desktop (Electron) englobe toute l'interface de chat dans une fenêtre — sans terminal. Voir desktop/.

🔥🔥🔥 Actualités (heure du Pacifique)

9 juillet 2026 : Image Docker officielle + publication en une commande. Image pré-compilée sur Docker Hub (docker pull chauncygu/cheetahclaws) pour exécuter l'interface Web sans cloner le dépôt ; corrige une PermissionError au premier lancement en pré-créant les répertoires .cheetahclaws/workspace appartenant à l'utilisateur non-root, rend l'image de compose surchargeable via CHEETAH_IMAGE, et ajoute scripts/docker-publish.sh (lecture automatique de la version, multi/mono-architecture). Nouvelles sections de docs : Pull from Docker Hub et Interactive setup / CLI mode. Détails
8 juillet 2026 : la nouvelle commande /workspace gère des répertoires de travail isolés sous ~/.cheetahclaws/workspaces (list/switch/default/create/delete) (PR #162) ; le basculement automatique au démarrage est optionnel via workspace_auto (désactivé par défaut, donc le lancement dans un répertoire de projet reste inchangé), et default est désormais une clé persistante distincte du dernier utilisé. Détails
6 juillet 2026 (v3.5.84) : /image enrichit désormais le prompt avec du texte OCR local afin que même les modèles sans vision puissent traiter les captures d'écran du presse-papiers (dumps d'erreurs, code, tableaux) ; ne s'exécute que si pytesseract/tesseract sont installés et se désactive entièrement via CHEETAHCLAWS_IMAGE_OCR=0. Détails
28 juin 2026 : nouveau mode de permission accept-edits (exécution automatique des modifications de fichiers, tout en demandant confirmation avant tout Bash non autorisé) — le juste milieu entre auto et accept-all ; expose également le mode plan existant dans /permissions et corrige la description trompeuse du mode auto dans le prompt. Détails
28 juin 2026 : l'obsolescence de la mémoire s'ancre désormais sur une date last_verified plutôt que sur le mtime du fichier, de sorte que lire une mémoire ne peut plus faussement rafraîchir une mémoire obsolète (PR #150) ; le nouvel outil MemoryVerify est la seule chose qui réinitialise l'horloge, le prompt demande à l'agent de l'appeler après re-vérification, et le manifeste de mémoire injecté est classé par ancienneté de vérification. Détails
23 juin 2026 (v3.5.83) : documentation allégée (actualités du README → une ligne chacune, liste des 59 modèles Atlas → usage.md, FAQ élaguée) et ajout d'une application desktop native (coquille Electron englobant l'interface web) sous desktop/ ; format de chaîne de version unifié en v3.5.x. Détails
16 juin 2026 : tous les modules internes vivent désormais sous un unique paquet cheetahclaws (from cheetahclaws import kernel), supprimant les plantages de collision de noms sys.path au démarrage — ne casse que si vous importez directement les composants internes ; suite complète au vert (2449 réussis). Détails
6 juin 2026 (v3.5.82) : l'installation sur macOS place désormais de manière fiable cheetahclaws dans le PATH, et les modèles Ollama locaux qui émettent des appels d'outils sous forme de texte les exécutent désormais réellement (deux corrections issues de #131). Détails
5 juin 2026 : budgets de tokens/coûts contrôlables par l'utilisateur — /budget \$5 / /budget daily \$20 plafonnent les dépenses par session ou par jour, appliqués avant chaque appel de modèle. Détails
5 juin 2026 : le streaming Markdown adaptatif maintient la sortie en direct correcte sur tous les appareils en sélectionnant automatiquement un niveau par appareil ; ajoute également une grille visuelle /context et un contexte de 1M pour deepseek-v4-flash. Détails

Pour plus d'actualités, voir ici.

CheetahClaws

CheetahClaws : une infrastructure de harnais d'agent native Python rapide et facile à utiliser, prenant en charge n'importe quel modèle, tels que Claude, GPT, Gemini, Kimi, Qwen, Zhipu, DeepSeek, MiniMax, et des modèles open-source locaux via Ollama ou tout point de terminaison compatible OpenAI.

Sommaire

Pourquoi CheetahClaws
CheetahClaws vs OpenClaw
Fonctionnalités
Modèles pris en charge
Installation
Utilisation : modèles API propriétaires
Utilisation : modèles open-source (locaux)
Format du nom de modèle
Agent de trading
Interface Web
Documentation (guides pour toutes les fonctionnalités)
Contribuer · FAQ · Citation

Démos

_{Exécution d'une tâche dans le terminal}

_{Interface Web : chat dans le navigateur — barre latérale, cartes d'outils, invites d'approbation, streaming Markdown}

_{Agent de trading autonome}

D'autres démos animées (revue de code, /research, /brainstorm, /lab, passerelles Telegram/WeChat/Slack) sont disponibles dans docs/media/.

Pourquoi CheetahClaws

Claude Code est un assistant de codage IA puissant et de qualité production — mais son code source est un bundle TypeScript/Node compilé d'environ 12 Mo (~1 300 fichiers, ~283K lignes), étroitement couplé à l'API Anthropic, difficile à modifier et impossible à exécuter avec un modèle local ou alternatif.

CheetahClaws réimplémente la même boucle centrale en ~90K lignes de Python lisible — en gardant ce dont vous avez besoin, en abandonnant ce dont vous n'avez pas besoin, et en ajoutant la prise en charge multi-fournisseurs + modèles locaux. Comparaison complète : ../guides/comparison.md.

Dimension	Claude Code (TypeScript)	CheetahClaws (Python)
Langage	TypeScript + React/Ink	Python 3.8+
Fichiers source / LdC	~1 332 fichiers / ~283K	~315 fichiers / ~90K (cœur ; ~127K avec les tests)
Outils / commandes intégrés	44+ / 88	27 / 50+
Fournisseurs de modèles	Anthropic uniquement	8+ (Anthropic · OpenAI · Gemini · Kimi · Qwen · DeepSeek · MiniMax · …)
Modèles locaux	Non	Oui — Ollama, LM Studio, vLLM, tout point de terminaison compatible OpenAI
Étape de build	Oui (Bun + esbuild)	Non — `python cheetahclaws.py`
Extensibilité	Fermée (au moment de la compilation)	Ouverte — `register_tool()` à l'exécution, compétences Markdown, plugins git, MCP
Entrée vocale	WebSocket propriétaire (OAuth)	Whisper local / OpenAI — fonctionne hors ligne

Là où Claude Code gagne : interface React/Ink plus riche, plus d'outils intégrés, fonctionnalités d'entreprise (MDM, synchronisation des permissions d'équipe, OAuth/keychain), extraction de mémoire pilotée par IA, fiabilité de production en binaire unique.

Là où CheetahClaws gagne : basculement vers n'importe quel modèle (--model//model, sans recompilation) y compris une prise en charge complète locale/hors ligne ; une boucle d'agent lisible dans un seul fichier (agent.py, ~740 lignes) ; zéro build ; enregistrement d'outils à l'exécution + MCP + plugins git + compétences Markdown ; graphe de dépendances des tâches (blocks/blocked_by) ; compression de contexte à deux couches ; voix hors ligne ; synchronisation de session dans le cloud ; passerelles vers Telegram/WeChat/Slack/QQ.

À qui s'adresse-t-il : aux développeurs qui veulent un assistant de codage local/non-Anthropic, aux chercheurs qui étudient le fonctionnement des assistants agentiques, et aux équipes qui ont besoin d'une base modifiable — sans chaîne de build Node.js.

CheetahClaws vs OpenClaw

OpenClaw est un autre assistant open-source populaire (TypeScript/Node). Les deux ont des objectifs principaux différents — OpenClaw est un assistant personnel de la vie quotidienne à travers les canaux de messagerie ; CheetahClaws est un outil de développement/codage.

Dimension	OpenClaw (TypeScript)	CheetahClaws (Python)
Lignes de code	~245K (~10 349 fichiers)	~90K cœur (~315 fichiers)
Objectif principal	Assistant personnel à travers les canaux	Assistant de codage IA / outil de dev
Architecture	Démon Gateway toujours actif + applications	REPL de terminal sans installation
Canaux de messagerie	20+ (WhatsApp · Signal · iMessage · Discord · Matrix · …)	Terminal + passerelles Telegram · WeChat · Slack · QQ
Modèles locaux / hors ligne	Limité	Complet — Ollama · vLLM · LM Studio · tout compatible OpenAI
Outils d'édition de code	Contrôle du navigateur, Canvas	Read · Write · Edit · Bash · Glob · Grep · NotebookEdit · GetDiagnostics
Mobile / Live Canvas	Oui (barre de menu + iOS/Android, A2UI)	—
Prise en charge MCP	—	Oui (stdio/SSE/HTTP)
Modifiabilité	245K lignes, plus difficile à modifier	~90K lignes — boucle d'agent dans un seul fichier

Si vous voulez…	Utilisez
Un assistant personnel sur WhatsApp/Signal/Discord, orienté mobile, automatisation du navigateur + Canvas	OpenClaw
Un assistant de codage IA dans votre terminal, modèles entièrement hors ligne/locaux, basculement multi-fournisseurs, un code source lisible en une après-midi	CheetahClaws

Comparaison complète — les atouts des deux côtés + les principales différences de conception (boucle d'agent, enregistrement d'outils, compression de contexte, mémoire) : ../guides/comparison.md.

Fonctionnalités

Fonctionnalité	Détails
Multi-fournisseurs	Anthropic · OpenAI · Gemini · Kimi · Qwen · Zhipu · DeepSeek · MiniMax · Ollama · LM Studio · Point de terminaison personnalisé
Boucle d'agent	API en streaming + boucle automatique d'utilisation d'outils ; toute la boucle est dans `agent.py`
28 outils intégrés	Read · Write · Edit · Bash · Glob · Grep · WebFetch · WebSearch · NotebookEdit · GetDiagnostics · Memory* · Agent/SendMessage · Skill · AskUserQuestion · Task* · SleepTimer · EnterPlanMode/ExitPlanMode · (outils MCP + plugins ajoutés automatiquement)
Intégration MCP	Connectez n'importe quel serveur MCP (stdio/SSE/HTTP) ; outils enregistrés automatiquement — voir le guide des extensions
Système de plugins	Installer/activer/mettre à jour des plugins depuis des URL git ou des chemins locaux ; multi-portée ; moteur de recommandation
Gestion des tâches	`TaskCreate/Update/Get/List`, IDs séquentiels, arêtes de dépendance, persistées dans `.cheetahclaws/tasks.json`
Compression de contexte	Quatre couches coopérantes — plafond dynamique de `max_tokens`, registre de fenêtre de contexte par modèle, découpage à deux couches + résumé par IA à 70 %, et éclatement automatique pour les sorties d'outils surdimensionnées. Détails
Mémoire persistante	Double portée (utilisateur + projet), 4 types, métadonnées de confiance/source, détection de conflits, recherche pondérée par ancienneté, `/memory consolidate`. Obsolescence ancrée sur la vérification — la fraîcheur suit une date `last_verified` (et non le mtime du fichier), de sorte que lire une mémoire ne peut pas la rafraîchir faussement ; seul `MemoryVerify` réinitialise l'horloge. Détails
Multi-agent	Créer des sous-agents typés (coder/reviewer/researcher/…), isolation par git-worktree, mode arrière-plan
Système de permissions	Modes `auto` / `accept-edits` / `accept-all` / `manual` / `plan` (`accept-edits` = exécution automatique des modifications, tout en demandant pour les autres Bash ; une liste noire stricte bloque les commandes destructrices pour l'hôte dans tous les modes)
Points de contrôle & mode plan	Instantané automatique de la conversation + fichiers à chaque tour (`/checkpoint`, `/rewind`) ; mode d'analyse en lecture seule `/plan`
Commandes slash & thèmes	50+ commandes slash avec complétion par Tab ; `/theme` propose 15 palettes soignées
Brainstorm → Worker	`/brainstorm` lance un débat à N personas → `todo_list.txt` ; `/worker` implémente automatiquement les tâches en attente
Mode développeur SSJ	`/ssj` — menu de puissance persistant enchaînant Brainstorm, Worker, Review, Trading, Agent, Video/TTS, Monitor, etc.
Agent de trading	`/trading` analyse multi-agents, backtesting, calibration en paper-trade, portefeuilles MV. Guide
Monitor	`/monitor` s'abonne à des sujets surveillés par IA selon un calendrier (arxiv / bourse / crypto / actualités / personnalisé), pousse des rapports vers les passerelles/console
Recherche (multi-sources)	`/research` s'étale sur 20 sources avec tableau de chaleur d'attention, extraction d'entités, sparkline de tendance, mode comparaison. Guide
Agents autonomes	`/agent` boucles en arrière-plan à partir de modèles Markdown ; résumés d'itérations poussés via passerelle ; garde-fou d'arrêt en cas de stagnation
Passerelles + contrôle à distance	Telegram · WeChat · Slack · QQ — aller-retour de chat, passthrough des commandes slash, file d'attente de jobs par passerelle (`!jobs`/`!retry`/`!cancel`). Guide
Voix / Vision / Vidéo / TTS	Whisper hors ligne `/voice` ; vision du presse-papiers `/image` (local + cloud) ; usines de contenu `/video` + `/tts`. Guide
Interface Web	`--web` — chat multi-utilisateurs dans le navigateur + terminal PTY. Guide
Plus	Intégration Tmux · échappement shell `!cmd$ · \text{surveillance} \text{proactive} · \text{arr}ê\text{t} \text{forc}é \text{par} 3 \times \text{Ctrl}+\text{C} · \text{persistance} \text{de} \text{session} · \text{synchronisation} \text{GitHub}-\text{Gist} $/cloudsave` · suivi des coûts · mode non interactif `--print`

Référence complète des fonctionnalités — chaque ligne ci-dessus avec tous les détails (couches de compression de contexte, éclatement automatique, 15 thèmes, les descriptifs complets Trading/Research/Agents, …) : ../guides/features.md.

Modèles pris en charge

Propriétaires (API)

Fournisseur	Modèles d'exemple	Contexte	Variable d'env. de clé API
Anthropic	`claude-opus-4-6` · `claude-sonnet-4-6` · `claude-haiku-4-5-20251001`	200k	`ANTHROPIC_API_KEY`
OpenAI	`gpt-4o` · `gpt-4.1` · `gpt-5` · `o3` · `o4-mini`	128–200k	`OPENAI_API_KEY`
Google	`gemini-2.5-pro` · `gemini-2.0-flash` · `gemini-1.5-pro`	1–2M	`GEMINI_API_KEY`
Moonshot (Kimi)	`moonshot-v1-8k` / `-32k` / `-128k`	8–128k	`MOONSHOT_API_KEY`
Alibaba (Qwen)	`qwen-max` · `qwen-plus` · `qwen-turbo` · `qwq-32b`	32k–1M	`DASHSCOPE_API_KEY`
Zhipu (GLM)	`glm-4-plus` · `glm-4` · `glm-4-flash` (niveau gratuit)	128k	`ZHIPU_API_KEY`
DeepSeek	`deepseek-chat` · `deepseek-reasoner`	64k	`DEEPSEEK_API_KEY`
MiniMax	`MiniMax-Text-01` · `MiniMax-VL-01` · `abab6.5s-chat`	256k–1M	`MINIMAX_API_KEY`
AWS Bedrock / Azure / Vertex (via litellm)	`litellm/<provider>/<model>`	variable	spécifique au fournisseur

Adaptateur litellm/ : achemine vers 100+ fournisseurs derrière un seul SDK — principalement pour les upstreams à l'authentification délicate (SigV4 de Bedrock, routage de déploiement Azure, JWT de compte de service Vertex). Pour les points de terminaison standard au format OpenAI, préférez l'adaptateur custom/ sans dépendance. Installez avec pip install ".[litellm]". Voir recipes.md.

Open-source (local via Ollama)

Modèle	Taille	Points forts	Pull
`qwen2.5-coder`	7B / 32B	Le meilleur pour le codage	`ollama pull qwen2.5-coder`
`llama3.3` / `llama3.2`	70B / 3B–11B	Usage général	`ollama pull llama3.3`
`deepseek-r1`	7B–70B	Raisonnement, maths	`ollama pull deepseek-r1`
`mistral` / `mixtral`	7B / 8x7B	Rapide / MoE performant	`ollama pull mistral`
`phi4` · `gemma3` · `codellama`	14B · 4–27B · 7–34B	Raisonnement / ouvert / code	`ollama pull phi4`
`llava` · `llama3.2-vision`	7–13B · 11B	Vision	`ollama pull llava`

L'appel d'outils nécessite un modèle capable d'appeler des fonctions — recommandés : qwen2.5-coder, llama3.3, mistral, phi4. Les modèles qui émettent des appels d'outils sous forme de texte (<tool_call>…</tool_call>, [TOOL_CALLS]…) au lieu du champ structuré d'Ollama sont récupérés automatiquement, si bien qu'ils exécutent les outils d'emblée plutôt que de simplement en discuter. Les modèles de raisonnement (deepseek-r1, qwen3, gemma4) diffusent des blocs <think> natifs ; activez-les avec /verbose + /thinking.

Installation

pip install cheetahclaws

Fonctionne sur Linux, macOS, WSL2 et Android (Termux) (Python 3.10+). Le premier lancement vous guide à travers la configuration du fournisseur + de la clé API ; relancez à tout moment avec cheetahclaws --setup.

Windows : Windows natif n'est pas pris en charge — utilisez WSL2. Android/Termux : pkg install python git && pip install cheetahclaws.

Alternative : script d'installation en une ligne

curl -fsSL https://raw.githubusercontent.com/SafeRL-Lab/cheetahclaws/main/scripts/install.sh | bash

Après l'installation, rechargez votre shell pour que cheetahclaws soit dans le PATH :

source ~/.zshrc     # macOS
# or: source ~/.bashrc   # Linux
cheetahclaws        # start chatting!

Alternative : installation avec `pip` depuis le code source

git clone https://github.com/SafeRL-Lab/cheetahclaws.git
cd cheetahclaws
pip install .                       # then: cheetahclaws
git pull && pip install --force-reinstall .   # to update

Extras optionnels

pip install ".[voice]"      # voice input (sounddevice + faster-whisper)
pip install ".[vision]"     # clipboard image capture (Pillow)
pip install ".[autosuggest]"# typing-time slash autosuggest (prompt_toolkit)
pip install ".[browser]"    # headless browser (playwright); then: playwright install chromium
pip install ".[files]"      # PDF + Excel reading (pymupdf, openpyxl)
pip install ".[ocr]"        # image OCR (pytesseract)
pip install ".[trading]"    # trading agent (yfinance, rank-bm25)
pip install ".[qq]"         # QQ bot bridge (qq-botpy)
pip install ".[litellm]"    # AWS Bedrock / Azure / Vertex auth via litellm
pip install ".[all]"        # everything above

Alternative : installation avec `uv`

git clone https://github.com/SafeRL-Lab/cheetahclaws.git && cd cheetahclaws
uv tool install ".[all]"            # minimal: uv tool install .
uv tool install ".[all]" --reinstall   # update   ·   uv tool uninstall cheetahclaws

Alternative : exécution directe depuis les sources (sans installation)

git clone https://github.com/SafeRL-Lab/cheetahclaws.git && cd cheetahclaws
pip install -r requirements.txt
python cheetahclaws.py              # changes take effect immediately

Utilisation : modèles API propriétaires

Chaque fournisseur cloud suit le même schéma — exportez sa clé API (voir le tableau Modèles pris en charge pour le nom de la variable d'environnement), puis sélectionnez un modèle :

export ANTHROPIC_API_KEY=sk-ant-...     # or OPENAI_API_KEY / GEMINI_API_KEY / DEEPSEEK_API_KEY / …
cheetahclaws                            # default model
cheetahclaws --model gpt-4o             # pick any model
cheetahclaws --model deepseek-chat --thinking --verbose

Pages d'obtention de clé par fournisseur : Anthropic · OpenAI · Gemini · Kimi · Qwen · Zhipu · DeepSeek · MiniMax.

AWS Bedrock / Azure / Vertex utilisent la forme litellm/<provider>/<model> (pip install ".[litellm]") — recettes complètes de variables d'environnement dans recipes.md.

Guide complet par fournisseur — la page d'obtention de clé de chaque fournisseur + des exemples de commandes de modèle, ainsi que les recettes de variables d'environnement Bedrock/Azure/Vertex : ../guides/usage.md.

Utilisation : modèles open-source (locaux)

Ollama (recommandé)

curl -fsSL https://ollama.com/install.sh | sh   # install
ollama pull qwen2.5-coder                        # pull a tool-calling model
ollama serve                                     # http://localhost:11434 (auto-starts on macOS)
cheetahclaws --model ollama/qwen2.5-coder        # run (use `ollama list` to see local models)

LM Studio

Téléchargez LM Studio, récupérez un modèle GGUF, démarrez son Local Server (port 1234), puis :

cheetahclaws --model lmstudio/<model-name>

vLLM / serveur auto-hébergé compatible OpenAI

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Coder-32B-Instruct --port 8000 \
    --enable-auto-tool-choice --tool-call-parser hermes

export CUSTOM_BASE_URL=http://localhost:8000/v1
export CUSTOM_API_KEY=token-abc123      # any non-empty string if the server has no auth
cheetahclaws --model custom/Qwen2.5-Coder-32B-Instruct

Le nom après custom/ doit correspondre au --served-model-name du serveur. Pour l'interface Web, --web --model custom/<name> persiste le modèle avant le démarrage du serveur. Serveur distant ? Pointez CUSTOM_BASE_URL vers son IP.

Guide complet des modèles locaux — Ollama pas à pas, LM Studio, vLLM + interface Web : ../guides/usage.md.

Atlas Cloud (hébergé, compatible OpenAI)

🎁 Atlas Cloud sert DeepSeek, Qwen, GLM, Kimi, MiniMax et plus derrière un unique point de terminaison compatible OpenAI, via l'adaptateur custom/ sans dépendance :

export CUSTOM_BASE_URL=https://api.atlascloud.ai/v1
export CUSTOM_API_KEY=your_atlascloud_api_key
cheetahclaws --model custom/deepseek-ai/deepseek-v4-pro

N'importe quel identifiant de modèle de chat Atlas fonctionne de la même manière — liste complète des 59 modèles : ../guides/usage.md.

Format du nom de modèle

Trois formes équivalentes sont acceptées :

cheetahclaws --model gpt-4o                  # 1. auto-detect by prefix
cheetahclaws --model ollama/qwen2.5-coder    # 2. provider/model
cheetahclaws --model kimi:moonshot-v1-32k    # 3. provider:model

Auto-détection par préfixe : claude-→anthropic · gpt-/o1/o3→openai · gemini-→gemini · moonshot-/kimi-→kimi · qwen/qwq-→qwen · glm-→zhipu · deepseek-→deepseek · MiniMax-/abab→minimax · llama/mistral/phi/gemma/mixtral/codellama→ollama.

Agent de trading

Un module intégré d'analyse de trading IA + backtesting (pip install "cheetahclaws[trading]").

/trading analyze NVDA            # 5-phase pipeline: data → Bull/Bear debate → Judge → Risk panel → PM decision
/trading backtest AAPL dual_ma   # backtest a strategy (or let AI pick); Sharpe/Sortino/Calmar/drawdown/win-rate

4 stratégies (dual_ma, rsi_mean_reversion, bollinger_breakout, macd_crossover), mémoire BM25 des situations passées, marchés US/HK/actions A + crypto avec repli de données sans clé API. Sous-menu guidé via /ssj → Trading.

Guide complet : ../guides/trading.md

Interface Web

Une interface de navigateur prête pour la production — véritables comptes utilisateurs (bcrypt + JWT), historique adossé à SQLite, points de terminaison d'exploitation — servie par la bibliothèque standard Python + dix modules JS vanilla (pas de Node.js / React / étape de build).

pip install 'cheetahclaws[web]'
cheetahclaws --web                  # auto-picks a free port (tries 8080)
cheetahclaws --web --port 9000 --host 0.0.0.0   # bind explicitly / open to LAN
cheetahclaws --web --no-auth        # skip login (localhost dev only)

Ouvrez http://localhost:<port>/chat — le premier compte devient administrateur. Inclut le chat en streaming (WS) + commandes slash SSE, sessions persistantes avec dossiers/recherche/export Markdown, cartes d'outils, approbation de permission en ligne, panneau de paramètres, thème clair/sombre/système, et points de terminaison /health + /metrics. Un terminal PTY complet xterm.js est disponible à / (parité CLI à 100 %).

Guide complet : ../guides/web-ui.md · Docker / serveur domestique : ../guides/docker.md · Application desktop native : desktop/README.md

Documentation

Des guides détaillés vivent dans docs/guides/ pour garder ce README concentré :

Guide	Contenu
Fonctionnalités (complet)	Le tableau complet des fonctionnalités — chaque ligne avec tous les détails (compression de contexte, éclatement automatique, thèmes, descriptifs Trading/Research/Agents)
Utilisation (tous les fournisseurs)	Configuration par fournisseur + commandes d'exemple : Anthropic/OpenAI/Gemini/Kimi/Qwen/Zhipu/DeepSeek/MiniMax/litellm, et Ollama/LM Studio/vLLM en local
Interface Web	Interface de chat, terminal PTY, points de terminaison API, paramètres, authentification, streaming SSE
Application desktop	Coquille en fenêtre native (Electron) qui englobe l'interface web locale ; construisez un `.dmg`/`.exe`/`.AppImage` autonome
Docker / serveur domestique	Dockerfile + compose : interface web + passerelles dans un seul conteneur, Ollama sur l'hôte, montage de l'espace de travail
Référence	CLI, 50+ commandes, 33 outils intégrés, recherche de session, classification des erreurs, cache d'outils
Extensions	Mémoire, Compétences, Sous-agents, serveurs MCP, Plugins, Monitor, Agents autonomes
Passerelles	Configuration Telegram, WeChat, Slack, QQ + contrôle à distance depuis votre téléphone
Sécurité & variables d'env.	Modèle de menace, variables `CHEETAHCLAWS_*`, gestion des jetons de bot, liste noire Bash, bac à sable du système de fichiers, CSRF
Voix & Vidéo	Entrée vocale Whisper hors ligne, usine à vidéos, usine TTS
Trading	Analyse multi-agents, backtesting, mémoire BM25, replis de données, intégration SSJ
Avancé	Brainstorm, SSJ, Tmux, surveillance proactive, points de contrôle, mode plan, sessions, synchronisation cloud
Comparaison	Positionnement complet vs Claude Code et OpenClaw — tableaux en un coup d'œil, atouts des deux côtés, principales différences de conception
Recettes	12 exemples pas à pas : revue de code, contrôle à distance, recherche, correction de bug, navigation, e-mail, PDF/Excel
FAQ	La FAQ complète (MCP, modèles/fournisseurs, CLI/scripting, voix)
Création de plugins · Exemple	Construire un plugin : outils, commandes, compétences, MCP ; modèle de démarrage
Labo de recherche	`/lab start <topic>` — rédaction autonome de papiers multi-agents avec expériences en bac à sable
Agent OS · Index RFC	La couche `kernel/` + toutes les notes de conception (RFC 0001-0032)
Contribuer	Structure du projet, guide d'architecture, checklist de PR

Référence rapide

cheetahclaws [OPTIONS] [PROMPT]

  -p, --print          Non-interactive: run prompt and exit
  -m, --model MODEL    Override model (e.g. gpt-4o, ollama/llama3.3)
  --accept-all         Auto-approve all operations (no permission prompts)
  --verbose            Show thinking blocks and per-turn token counts
  --show-tools         Show each tool call instead of a per-turn summary
                       (alias: --no-quiet; compact summary is the default)
  --thinking           Enable Extended Thinking (Claude only)
  --web                Start web server (Chat UI + PTY terminal in browser)
  --port / --host      Web server port / host (default 8080 / 127.0.0.1)
  --no-auth            Disable web password (local use only)
  --version / -h       Print version / show help

cheetahclaws                                          # interactive REPL, default model
cheetahclaws -m ollama/deepseek-r1:32b                # pick a model
cheetahclaws -p "Write a Python fibonacci function"   # non-interactive
cheetahclaws --accept-all -p "Init a pyproject.toml"  # CI / automation
cheetahclaws --web --port 8008 --no-auth              # browser chat + terminal

Consultez le guide de référence pour l'ensemble des 50+ commandes slash, outils et options de configuration.

Contribuer

Nous accueillons les contributions ! Consultez le guide de contribution pour l'architecture, les conventions et la checklist de PR.

git clone https://github.com/SafeRL-Lab/cheetahclaws.git && cd cheetahclaws
pip install -r requirements.txt && pip install pytest
python -m pytest tests/ -x -q       # 341+ tests should pass
python cheetahclaws.py              # run the REPL

Vous construisez un plugin ? Consultez le guide de création de plugins et le modèle d'exemple.

FAQ

Quelques questions courantes — la FAQ complète est dans ../guides/faq.md.

Q : Comment ajouter un serveur MCP ?

/mcp add git uvx mcp-server-git          # or create .mcp.json in your project, then /mcp reload

Q : Les appels d'outils ne fonctionnent pas avec mon modèle Ollama local (il ne fait que décrire ce qu'il ferait au lieu de le faire). CheetahClaws récupère désormais automatiquement les appels d'outils que les modèles locaux émettent sous forme de texte (<tool_call>…</tool_call>, [TOOL_CALLS]…) au lieu du champ structuré d'Ollama, si bien que la plupart des modèles capables d'appeler des fonctions exécutent les outils d'emblée. Pour une fiabilité optimale, utilisez un modèle capable d'appeler des outils — qwen2.5-coder, llama3.3, mistral ou phi4. Les petits modèles sont également moins performants que les modèles cloud pour l'usage agentique des outils, alors attendez-vous à ce qu'ils aient besoin de prompts plus clairs et plus concrets.

Q : Après l'installation sur macOS, cheetahclaws: command not found et aucun ~/.zshrc n'a été créé. Rechargez d'abord votre shell : source ~/.zshrc (zsh) ou source ~/.bash_profile (bash). L'installateur crée ~/.zshrc s'il est absent, crée un lien symbolique du binaire dans ~/.local/bin et l'ajoute au PATH. Si vous avez installé une version plus ancienne, relancez l'installateur ou ajoutez vous-même cette ligne : echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc && source ~/.zshrc.

Plus — vLLM distant, coût de l'API (/cost), plusieurs clés par session, modèle par défaut entre projets, redirection d'entrée, configuration vocale, corrections de texte brouillé — sont tous traités dans ../guides/faq.md.

Citation

Si vous trouvez ce dépôt utile, merci de citer l'étude

@article{gu2026model,
  title={From Model Scaling to System Scaling: Scaling the Harness in Agentic AI},
  author={Gu, Shangding},
  journal={arXiv preprint arXiv:2605.26112},
  year={2026}
}

@article{cheetahclaws2026,
  title={CheetahClaws: Agent Harness Infrastructure for Long-Horizon, Multi-Model, and Tool-Using AI Systems},
  author={CheetahClaws Team},
  journal={github},
  year={2026}
}