September 25, 2026
EN
August 27, 2026 · By YasKad
ultraworkers/claw-code

Claw Code: the Rust museum exhibit born from the Claude Code source leak

ultraworkers/claw-code · 195,287★ · 108,387 forks

Claw Code is a public Rust implementation of claw, a coding-agent harness with the shape and workflow of Claude Code, that also presents itself —and operates— as an “agent-managed museum exhibit”: a repository built and maintained with minimal human intervention, steered through Discord and a multi-agent coordination layer (OmX, clawhip, and OmO). Its origin is tied to the most consequential incident in the AI industry in 2026: the Claude Code source-code leak of March 31, 2026, after which the project became one of the most visible rewrites of that architecture on GitHub, with 195,110 stars as of measurement.

Identity note: the current canonical location is ultraworkers/claw-code. The API shows that instructkr/claw-code (the original author’s personal account) now permanently redirects to the same repository, indicating the project was created under that account and later transferred to the ultraworkers organization. Older links, including several Hacker News threads, still point to instructkr/claw-code.

Origin

The repository was created on March 31, 2026, the same day, according to press coverage and the project’s site, the Claude Code source code leaked. The chronology verified across recovered sources is: a mistakenly published source map revealed “over half a million lines” of Claude Code source code —a 59.8 MB .map file bundled in the npm package @anthropic-ai/claude-code v2.1.88, roughly 512,000 lines of TypeScript across 1,906 files— and security researcher Chaofan Shou was among the first to spot it. Days later, Anthropic filed over 8,100 DMCA takedown requests to slow the copies spreading on GitHub.

That same March 31, 2026, Claw Code appeared: a rewrite of the harness architecture, attributed by German magazine heise to Korean developer Sigrid Jin (realsigridjin) with AI assistance. heise describes it as “the fastest-growing repository in GitHub history”; the claw-code.codes site claims it was “one of the fastest projects in GitHub history to reach 30,000 stars” (within hours).

The repository describes itself as “An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.” heise notes the project was “gladly embraced, for example, by Elon Musk’s xAI” thanks to it, citing a post by Sigrid Jin on X.

A dark cyberpunk forensic scene depicting a software source-code leak, a massive glowing source-map file spills across a black server room floor like liquid neon plasma, translucent streams of code pour from a cracked npm package container, abstract lines of TypeScript form towering holographic monoliths, red DMCA takedown signals pulse across the background like warning lasers, a lone security researcher silhouette observes the breach from a terminal, floating event logs and timestamp fragments swirl in the air, no readable text, dark mode, cyberpunk/tech aesthetic, neon accents, ultra-detailed, 8K resolution

Philosophy and principles

The repository’s PHILOSOPHY.md states the project’s thesis explicitly: “Stop Staring at the Files” — only looking at the generated files is looking at the wrong layer; “the Python rewrite was a byproduct. The Rust rewrite was too. What’s actually worth studying is the system that produced them: a clawhip-based coordination loop where humans give direction and autonomous claws execute the work.” The human interface is Discord: “A person can write a sentence from their phone, walk away, go to sleep… The claws read the directive, break it into tasks, assign roles, write code, run tests, debate failures, recover, and push the code once the work passes.”

The three-piece system: (1) OmX (oh-my-codex), the workflow layer that turns short directives into structured execution; (2) clawhip, the event and notification router that watches git commits, tmux sessions, issues, and PRs; (3) OmO (oh-my-openagent), multi-agent coordination among Architect/Executor/Reviewer-type roles.

The ROADMAP.md (8,016 lines) formalizes the “clawable” harness concept: deterministic on startup, machine-readable in state and failure modes, recoverable without a human watching the terminal, “event-first, not log-first.” The README insists it’s not a production project: “it’s closer to a museum exhibit than a product pitch,” and recommends LazyCodex or Gajae-Code for real work.

A cinematic dark-mode visualization of human direction and autonomous agent execution, a small holographic smartphone emits a short glowing message into a Discord-like chat channel suspended in a neon void, the message expands into a branching task graph, robotic claws and agent avatars materialize around the graph, each claw picks up a glowing task node and begins writing code, testing, reviewing, and pushing commits, the scene contrasts one calm human gesture with a vast coordinated swarm of AI agents working in parallel, floating abstract terminal windows and git commit trails connect the nodes, no readable text, dark mode, cyberpunk/tech aesthetic, neon accents, ultra-detailed, 8K resolution

How it works

Claw Code is a coding-agent CLI (claw) whose canonical workspace lives in rust/ (~96% of the repository’s bytes) and reimplements the Claude Code harness architecture: tool system, streaming query engine, sessions and memory, permission system, MCP integration, and model-provider abstraction.

A detailed cyberpunk system architecture image showing three interlocking coordination layers floating above a dark grid, the first layer is a workflow engine with planning gears and execution loops, the second is an event router receiving pulses from git commits, terminal sessions, issues, pull requests, and agent lifecycle signals, the third is a multi-agent coordination chamber where Architect, Executor, and Reviewer roles negotiate around a glowing decision core, neon data pipes connect the layers, warning lights indicate failure recovery, the composition emphasizes that the coordination system is more important than the output files, no readable text, dark mode, cyberpunk/tech aesthetic, neon accents, ultra-detailed, 8K resolution

Parity status (PARITY.md): nine “lanes” integrated into main —bash validation, CI/sandbox fixes, file tools, TaskRegistry, Team+Cron, MCP lifecycle, LSP client, and permission enforcement— with a deterministic mock parity harness: 12 scripted scenarios and 21 captured /v1/messages requests. The repo has 1,690 total commits as of this investigation’s measurement.

A hyper-detailed Rust workspace visualization in dark mode, nine glowing Rust crate modules arranged as a crystalline circuit around a central claw binary, each crate pulses with cyan and orange light, a deterministic mock service module runs scripted test scenarios as small looping holographic chambers, commit trails and line-count counters rise as abstract neon bars, a parity dashboard shows nine integrated lanes as illuminated tracks, the scene conveys a mature, auditable, machine-readable coding harness, floating abstract test results and permission shields orbit the workspace, no readable text, dark mode, cyberpunk/tech aesthetic, neon accents, ultra-detailed, 8K resolution

User surface: an interactive REPL with /help, /status, /cost, /config, /session, /model, /permissions, /export, and the advanced /ultraplan (deep multi-step planning), /teleport (jump to file or symbol), and /bughunter (suspicious-pattern scanning). Model and permission control: model aliases (opus, sonnet, haiku) and three permission modes: read-only, workspace-write (default), and danger-full-access. Multi-provider: Anthropic, OpenAI-compatible endpoints, OpenRouter, Ollama, xAI, and DashScope (Qwen).

A sleek dark-mode CLI terminal scene for an agent coding harness, a large holographic REPL interface dominates the frame, command icons for deep planning, file teleportation, bug hunting, status, cost, permissions, model switching, and JSON audit output float as neon glyphs around the prompt cursor, a robotic claw hovers over the terminal, ready to execute the next autonomous step, three permission modes appear as glowing shields: read-only, workspace-write, and danger-full-access, subtle model routing indicators show provider connections in the background, no readable text, dark mode, cyberpunk/tech aesthetic, neon accents, ultra-detailed, 8K resolution

A cyberpunk multi-provider model routing network in dark mode, a central claw-shaped router distributes neon request streams to abstract provider nodes representing Anthropic, OpenAI-compatible endpoints, OpenRouter, Ollama, xAI, and Qwen, each node glows with a different accent color, model alias labels appear as abstract symbol badges instead of readable words, permission gates and streaming query packets travel along fiber-optic data highways, the composition emphasizes flexible provider abstraction, session memory, and MCP integration, background shows a dark grid with floating session containers and tool-call traces, no readable text, dark mode, cyberpunk/tech aesthetic, neon accents, ultra-detailed, 8K resolution

What it doesn’t do: it doesn’t ship an ACP/Zed daemon or a real JSON-RPC entrypoint yet —claw acp is currently a discovery alias that returns status and exits code 0—; it also doesn’t support OpenAI Codex CLI sessions or importing/exporting them.

The ecosystem

The README links Claw Code to the broader UltraWorkers tooling, which —per the API’s creation dates— existed before the leak: clawhip (March 8, 2026), oh-my-openagent (December 3, 2025), oh-my-claudecode (January 9, 2026), and oh-my-codex (February 2, 2026). Claw Code was the public showcase of that ecosystem.

UltraWorks chain repos (stars as of August 22, 2026): code-yeongyu/oh-my-openagent (OmO) 68,252 ★; Yeachan-Heo/oh-my-claudecode 38,739 ★; Yeachan-Heo/oh-my-codex (OmX) 32,801 ★; ultraworkers/claw-code-parity 6,653 ★ (a temporary parity working repo during the Rust migration); code-yeongyu/lazycodex 3,296 ★; Yeachan-Heo/gajae-code 2,551 ★; Yeachan-Heo/clawhip 929 ★.

Community projects: odysa/mini-claw-code (27 ★, a derivative exercise); ornith-ai/Tokenless-Claw-Code (17 ★, a rewrite aimed at reducing token usage); StartripAI/claw_code (10 ★, “Production-grade Rust rewrite”); Skynet-Pro-Plus/ClawCodex (4 ★).

A grand cosmic constellation map of a multi-repository AI agent ecosystem, the central repository glows brightest with a massive star-count visualization, connected by neon orbital arcs to surrounding repositories for agent orchestration, workflow hooks, parity testing, lazy coding harnesses, and red-claw agent systems, each repository is represented as a glowing satellite with its own star graph and fork network, the constellation forms a crab-claw motif above a dark digital museum floor, the image conveys a public, agent-managed ecosystem rather than a single product, no readable text, dark mode, cyberpunk/tech aesthetic, neon accents, ultra-detailed, 8K resolution

Official / semi-official status

  • No affiliation with Anthropic: the README includes an “Ownership / affiliation disclaimer” stating the repository “does not claim ownership of the original Claude Code source material” and “is not affiliated with, endorsed by, or maintained by Anthropic.”
  • No official marketplace or formal status: the API also shows has_discussions: false, has_wiki: false, and no official homepage, though the unofficial claw-code.codes documentation site exists.
  • Semi-official vendor recognition: heise claims Claw Code was “gladly embraced, for example, by Elon Musk’s xAI.” This is the only vendor acceptance verified in this investigation.
  • crates.io: the claw-code package (0.1.0, 302 downloads) is deprecated (“This crate has been renamed to agent-code”); the agent-code package (0.30.0) exists with 5,077 cumulative downloads.

Repo numbers

Measured: August 22, 2026, GitHub API.

MetricValue
Stars195,110
Forks109,000
Subscribers1,940
Total commits1,690
Open issues (incl. 25 PRs)41
LanguagesRust 4,077,650 B · Python 168,159 B
LicenseMIT
Releases/tagsnone formal
CreatedMarch 31, 2026
Last pushAugust 16, 2026

Top contributors: Yeachan-Heo (609), code-yeongyu (566), TheArchitectit (16), realsigridjin (7). The top two account for ~88% of the top-ten contributions — consistent with self-management by two agent teams.

Quick-start guide

Installation and first run

Prerequisites: a Rust toolchain with cargo and an API key. The repository is build-from-source only; the README explicitly warns: don’t use cargo install claw-code (it installs the deprecated stub).

git clone https://github.com/ultraworkers/claw-code
cd claw-code/rust
cargo build --workspace

export ANTHROPIC_API_KEY="sk-ant-..."

./target/debug/claw doctor
./target/debug/claw prompt "say hello"
./target/debug/claw

After building, the binary isn’t added to PATH automatically: it stays at rust/target/debug/claw.

Common workflows

  1. Initialize a project: ./target/debug/claw init creates .claw/settings.json, .claw.json, and a guiding CLAUDE.md; it’s idempotent.
  2. Plan a complex task: /ultraplan refactor the auth module to use async/await inside the REPL.
  3. Review code before a full review: /bughunter (whole workspace) or /bughunter src/auth.rs.
  4. Automate with JSON output: printf 'summarize this repository\n' | ./target/debug/claw prompt --output-format json.

Essential configuration

  1. ANTHROPIC_API_KEY vs ANTHROPIC_AUTH_TOKEN: not interchangeable — sk-ant-* keys go in ANTHROPIC_API_KEY; OAuth/proxy bearer tokens go in ANTHROPIC_AUTH_TOKEN.
  2. Config resolution order: ~/.claw.json → ~/.config/claw/settings.json → <repo>/.claw.json → <repo>/.claw/settings.json → <repo>/.claw/settings.local.json.
  3. --permission-mode: read-only, workspace-write (default), or danger-full-access.

Common pitfalls and fixes

  • cargo install claw-code installs the wrong thing: it drops a stub that only prints that it was renamed to agent-code.
  • 401 Invalid bearer token: usually an sk-ant-* key placed in ANTHROPIC_AUTH_TOKEN.
  • “command not found: claw”: the binary stays at rust/target/debug/claw, not on PATH.
  • ACP/Zed doesn’t work: claw acp serve is only a discovery alias; there’s no ACP daemon or JSON-RPC yet.

Integrations and migration

MCP is configured in mcpServers (.claw.json); claw mcp --output-format json validates entries. Providers: Anthropic, OpenAI-compatible endpoints, OpenRouter, xAI, and DashScope. Migrating from Claude Code, Claw Code presents itself as a runtime with the same workflow shape but multi-provider; the project itself recommends leaving production work to LazyCodex or Gajae-Code.

Contributing

CONTRIBUTING.md documents: small, reviewable changes tied to a concrete issue; local setup with git clone, cargo build --workspace, cargo test --workspace; a local pre-push build gate (git config core.hooksPath .github/hooks); ROADMAP id assignment via scripts/roadmap-next-id.sh; pre-PR checks (cargo fmt --all --check, cargo clippy --workspace); and accepting the project’s MIT license by contributing.

How the community received it

Hacker News — “Claw code reaches 100k stars on GitHub in 1 day” (13 points, 1 comment): tedeh criticizes that clout-chasing was the point all along. “Claw Code – A Full Rewrite of Claude Code in Python” (1 point, 3 comments): dghong attacks the clean-room label: “‘Clean-room rewrite’ doesn’t mean much when you’ve read the original first — that’s not clean-room, that’s copying with extra steps.” In an April 2026 Ask HN, the author asks about a fully local setup rivaling Claude Code and names ultraworkers/claw-code and Gitlawb/openclaude as the competing harnesses that emerged “from the March 31 leak.”

heise online published the incident’s reference article (8,100 DMCA takedowns and the birth of Claw Code as a community reaction). The claw-code.codes site lists figures (“48k+ stars”) already stale relative to the API (195,110 stars).

Claw Code versus other proposals

ProjectStarsDescription
anomalyco/opencode200,382“The open source coding agent.”
ultraworkers/claw-code195,110An agent-managed museum exhibit; a Claude Code-shaped harness in Rust, multi-provider.
anthropics/claude-code142,574Anthropic’s official agentic coding tool.
openai/codex113,627OpenAI’s lightweight coding agent.
Gitlawb/openclaude30,802Cited alongside claw-code as a harness born from the leak.

Claw Code stands out for its explicit positioning (a coordination exhibit/demo, not a product), its documented multi-provider support, and being the public artifact of the UltraWorks chain.

Use cases and who this repository can help

  • People studying autonomous software development: the OmX + clawhip + OmO trinity (workflow, event routing, multi-agent coordination) is the pattern worth examining, not so much the binary itself.
  • Teams wanting a Claude Code-shaped harness over other providers: the documented multi-provider support with auditable JSON output fits CI and automation.
  • “Discord as a development interface” experiments: the pattern of directing agents from a phone is the use case the repository demonstrates by operating on itself.
  • Researchers of the leaked Claude Code architecture: PARITY.md and the mock parity harness are also a case study in deterministic testing methodology for agents.
  • Anyone wanting to work in production: the README explicitly redirects to LazyCodex or Gajae-Code — Claw Code, as an exhibit, is not the recommended tool for real work.

Resources

Note: this article combines the repository’s README, PHILOSOPHY.md, USAGE.md, PARITY.md, ROADMAP.md, CONTRIBUTING.md, the GitHub API endpoints, the heise online article, the claw-code.codes site, Hacker News searches, the crates.io API, and the GitHub repository search API, consulted on August 22, 2026. Figures change over time.

Related articles
Yeachan-Heo/oh-my-claudecode
August 27, 2026

oh-my-claudecode: teams-first multi-agent orchestration for Claude Code, installed as an official plugin

38,737★
openai/symphony
August 23, 2026

Symphony: a spec for turning tickets into autonomous code runs

24,700★
bmad-code-org/BMAD-METHOD
September 13, 2026

BMAD-METHOD: the agile method that organizes AI agent teams to build software

52,875★

Comments