ClawCodex
A terminal coding agent that combines Python tool execution, code editing, and multi-provider model access.
Per-dimension scores and reasoning
Evidence shows a permission system (/permissions, Full Access default, disableBypassPermissionsMode, refuse-to-start unsandboxed guard), but implementation details are not provided, and default Full Access may be over-privileged. User confirmation exists (permission requests, approval boxes), but not all sensitive operations are confirmed. Data flow transparency: tool-call transcripts and session history exist, but data flow is not explicit. Sensitive data handling: subprocess secret-scrubbing exists, but API key storage security is not detailed. Dependency security: version bounds exist, but no vulnerability scanning or lock files. External effects: Bash and network tools exist, but restrictions are not specified. Rollback: session resume and /clear exist, but operation rollback is not specified. Source attribution: license and authors exist, but publisher is unverified.
Self-consistency: README and code structure are consistent, with test coverage. Dependency availability: dependency list is complete, but no lock files. Failure messages: error handling exists, but no concrete examples.
Audience and scenarios: targets developers, provides CLI and desktop app. Capability boundaries: permission system and toolset exist, but not all capabilities are listed. Trigger precision: /permissions and /eco commands exist, but trigger conditions are not specified. Environment fit: supports multiple platforms, but not all environment requirements are specified.
Information architecture: README, docs, tests, clear structure. Install notes: one-line and manual install. Naming stability: version numbers and changelog. Examples and FAQ: examples and news, but no FAQ. Known limitations: not explicitly listed. License: MIT. Versioning and changelog: version numbers and news. Maintenance responsibility: active development, but publisher unverified.
Output usability: CLI and desktop app, clear output format. Marginal value: multi-model support and cost savings. Cost-benefit: cost savings data, but not independently verified.
Claim traceability: benchmarks and evaluations exist, but full reproduction steps are not provided. Cross-source corroboration: internal tests exist, but external validation is missing. Fact-inference separation: measured data exists, but some claims are inferred.
- Default Full Access permissions may be over-privileged; users should configure permissions explicitly.
- Publisher is unverified; install script from external domain poses supply chain risk.
- Dependencies are not locked, risking version drift.
- Benchmark results are not independently verified and are from a single run.
What does this agent do, and when should you use it?
ClawCodex is a Python implementation of a Claude Code-style coding agent with both an interactive terminal interface and scriptable CLI entry points. Its default interface is a TypeScript Ink TUI that launches and controls a Python agent-server over an NDJSON pipe, while headless work runs through `clawcodex -p`. The agent loop streams responses, invokes filesystem and shell tools, persists sessions, and extends slash commands through `SKILL.md` files. It documents support for Anthropic, OpenAI, Gemini, DeepSeek, OpenRouter, OpenAI-compatible vendors, and local Ollama, vLLM, and SGLang servers. It also includes permission modes, MCP tooling and resources, plan mode, scheduled tasks, and `/eco` Bash-output compression; adopters should account for its default interactive Full Access mode and dependence on external model services.
When a user starts clawcodex, the Ink TUI sends prompts, @ file references, and slash commands to the Python agent-server; clawcodex -p "..." runs a one-shot task instead. The agent loop receives streamed model responses from the configured provider and model, calls tools including Read, Write, Edit, Glob, Grep, Bash, WebFetch, WebSearch, AskUserQuestion, TodoWrite, and Agent, then returns tool results to the model until the task finishes. clawcodex login stores provider credentials, a default model, and optional TAVILY_API_KEY configuration in ~/.clawcodex/config.json, while sessions and permission settings can persist locally. /eco deterministically compresses Bash output before it enters model context while retaining recoverable full output, and clawcodex mcp serve exposes ClawCodex tools as an MCP stdio server.
- A Python or full-stack developer working in a local Git repository who wants a terminal agent to inspect source, edit files, run tests, and execute shell commands.
- An engineering team that needs one-off coding tasks in CI, scripts, or automation through
clawcodex -pand JSON or NDJSON input/output. - A team that wants to switch among Anthropic, OpenAI, DeepSeek, Gemini, or local Ollama/vLLM/SGLang models without changing the core tool workflow.
- A developer debugging failing suites or long-running commands who wants
/ecoto reduce Bash-log tokens sent to the model while preserving the raw output. - A repository maintainer defining custom, tool-restricted slash commands in
.clawcodex/skills/<skill-name>/SKILL.md. - A terminal user who needs an agent session to check a build, deployment, or maintenance prompt on a cron schedule or through
/loop.
What are this agent's strengths and limitations?
- One Python agent loop covers the 30 listed cloud and local providers, with a centralized registry for OpenAI-compatible services.
- It offers an Ink TUI, headless
-p, JSON/NDJSON streaming interfaces, and an agent-server, covering interactive development and script automation. - The documented toolset spans filesystem operations, search, Bash, skills, tasks, scheduling, worktrees, MCP, and permission controls.
/ecoprovides deterministic, recoverable Bash-result compression with a never-worse guard; the README includes a reproducible benchmark over 27 real command outputs.- It documents API-key-first Anthropic and OpenAI access as well as Claude Pro/Max and ChatGPT subscription login paths.
- Interactive
clawcodexstarts in Full Access and can edit any file and run commands, so permissions must be deliberately tightened outside an isolated environment. - The full TUI requires Node.js 18+ and a built TypeScript UI, adding runtime requirements beyond the Python CLI.
- WebSearch needs a separate Tavily API key, while cloud model usage depends on the selected provider's network availability, credentials, quota, and compatibility.
- The Claude Pro/Max and ChatGPT subscription integrations are explicitly subject to third-party-client and service-term limitations and may stop working.
- The README status table still marks parts of context depth, permission integration, and MCP runtime work as evolving or in progress.
How do you install or deploy this agent?
You need Python 3.10+, network access, and an API key for at least one provider or a supported subscription login. Recommended installation:
pipx install clawcodex-cliThen run:
clawcodex loginChoose a provider and configure credentials interactively, then verify with:
clawcodex --helpFor a source checkout:
git clone https://github.com/agentforce314/clawcodex.git && cd clawcodex
uv venv --python 3.11 && source .venv/bin/activate
uv pip install -e ".[dev]"The interactive Ink TUI additionally needs Node.js 18+ and a built ui-tui/dist; the headless -p path does not need Node.
How do you use this agent?
After login, run clawcodex in the target project to open the interactive TUI, or use clawcodex tui explicitly. Reference a file with @src/cli.py, inspect available tools with /tools, or invoke a project skill. For one-shot work, run clawcodex -p "Summarize src/cli.py"; to select a model, run clawcodex --provider anthropic --model claude-sonnet-4-6 -p "Find TODOs". Add TAVILY_API_KEY to the configuration env block to use WebSearch. Interactive sessions start in Full Access, so use /permissions to reduce access before work, or use --permission-mode plan for headless runs.
How does this agent compare with similar options?
Against Claude Code, ClawCodex positions itself as a Python rebuild that emphasizes multi-provider model support rather than Claude-family models alone. The README reports a self-described SWE-bench Verified comparison under the same Gemini 2.5 Pro standardized harness: ClawCodex resolved 291/499 instances (58.2%) and openclaude resolved 265/499 (53.0%). Compared with the Fusion Model concept in claude-code-router, the README says ClawCodex substitutes image content inside the agent loop so a text-only base model can consume a vision model's description.
FAQ
Is it limited to Claude models?
How can I control file edits and command execution?
/permissions with Ask for approval, Approve for me, and Full Access. Headless -p stays in default by default and can be overridden with --permission-mode or --dangerously-skip-permissions.Can it be used in CI or scripts?
clawcodex -p for a prompt-driven task; the documentation also shows --output-format json and NDJSON input/output through stream-json.Will long command logs consume model context?
/eco. It compresses model-bound Bash output, stores full output in the session directory with a recovery hint, and passes output through unchanged when compression does not help.