Open Claude Code 2.0 (Nightly): The Reverse-Engineered Clone

What is Open Claude Code?

Open Claude Code claims to be a clean-room implementation of Claude Code — not a fork, not a wrapper, but a complete rebuild informed by AI-assisted decompilation. The project uses a process called "ruDevolution" (Reverse Evolution through AI) to analyze the published npm package and generate functionally equivalent TypeScript code.

The key difference from a simple fork: this is an independent implementation that happens to produce the same results. It can be studied, modified, and redistributed under the MIT license.

Core Architecture — Async Generator Agent Loop

The heart of Open Claude Code is an async generator function that yields 13 distinct event types. This is architecturally unique in this field — most agents use a callback or promise-based loop:

Key characteristics of the loop:

• Recursive execution: After tool calls, recursively calls itself with yield* run(null, { continuation: true })
• Token tracking: Accumulates input/output tokens from API responses
• Auto-compaction: Triggers context compaction at 80% threshold
• Hook integration: Runs PreToolUse/PostToolUse hooks, can block tool execution
• Permission checking: Before tool execution, checks permissions

Context Manager — Two-Tier Compaction

Open Claude Code implements a sophisticated two-tier compaction system:

Token estimation uses a simple character-based heuristic: 4 characters ≈ 1 token. No external tokenizer dependency.

Tools System — 25 Tools

Tools follow a consistent validateInput/call interface pattern:

const Tool = {
    name: 'ToolName',
    description: '...',
    inputSchema: { type: 'object', properties: {...}, required: [...] },
    validateInput(input) { return []; },  // Returns array of errors
    async call(input) { return result; }
};

Multi-Agent Teams System

Open Claude Code implements a full agent-to-agent messaging system:

Custom agents are loaded from .claude/agents/{name}/agent.md with YAML frontmatter specifying name, description, model, and tools.

Hooks System — 7 Event Types

The hook system provides deep extensibility with 7 event types:

Hooks support both command (shell) and function implementations, configured via settings.json.

Permissions System — 6 Modes

Open Claude Code has a comprehensive permission system:

Additional security layers include sandboxing (bubblewrap on Linux, seatbelt on macOS), injection check for command injection detection, and path check for file path validation.

MCP Implementation — 4 Transports

More comprehensive MCP support than most agents:

Auto-detection from server config prioritizes: explicit transport > command (stdio) > URL pattern (ws:// → websocket, /sse → SSE, else streamable-http).

Settings Chain — 4 Sources

Configuration uses a 4-source deep merge chain:

1. .claude/settings.local.json — local, gitignored
2. .claude/settings.json — project, shared
3. ~/.claude/settings.json — user global
4. Managed policy — enterprise

Environment variables: 104 supported via config/env.mjs.

Unique Features Summary

Comparison to Claude Code

As a clean-room implementation, Open Claude Code aims for functional parity with Claude Code. Key similarities and differences:

Architecture Patterns Used

• Factory pattern — for agent loop, tools, permissions
• Registry pattern — for tools (tools.get('ToolName'))
• Event-driven — via async generator yielding events
• Middleware hooks — for extensibility
• Transport abstraction — for MCP (stdio/SSE/WS/http)
• Character-based token estimation — no external tokenizer

Key Files

Bottom Line

Open Claude Code is remarkable for being the most complete clone implementation in this set — a functional recreation of Claude Code through reverse engineering. Its async generator architecture and 7-type hook system represent architectural choices that differ from most other agents, while features like git worktree isolation, file checkpointing, and session teleport add capabilities the original doesn't have.

The 1,581 passing tests demonstrate functional parity in core functionality. For anyone wanting to understand how Claude Code works internally, this is the most transparent view available outside of Anthropic.