Platform Overview

flowchart TB
    subgraph User["User Interface Layer"]
        TUI["Terminal UI<br/>(Ratatui)"]
        CLI["CLI Interface<br/>(code exec)"]
        MCP_CLIENT["MCP Client<br/>(External Tools)"]
    end

    subgraph Core["Core Engine (Rust)"]
        CODEX["Codex Engine<br/>code-core"]
        PROTOCOL["Protocol Handler<br/>code-protocol"]
        CONFIG["Config Manager<br/>code-config"]
        AUTH["Auth Manager<br/>code-login"]
    end

    subgraph Agents["Agent Orchestration"]
        ORCHESTRATOR["Multi-Agent<br/>Orchestrator"]
        CLAUDE["Claude<br/>Adapter"]
        GEMINI["Gemini<br/>Adapter"]
        QWEN["Qwen<br/>Adapter"]
        GPT["GPT-5<br/>Adapter"]
        OLLAMA["Ollama<br/>(Local)"]
    end

    subgraph Execution["Execution Layer"]
        EXEC["Command Executor<br/>code-exec"]
        SANDBOX["Sandbox<br/>code-linux-sandbox"]
        GIT["Git Tooling<br/>code-git-tooling"]
        PATCH["Patch Engine<br/>code-apply-patch"]
    end

    subgraph MCP_LAYER["MCP Integration"]
        MCP_SERVER["MCP Server"]
        MCP_TOOLS["260+ Tools"]
        HANZO_MCP["@hanzo/mcp"]
    end

    subgraph External["External Services"]
        OPENAI["OpenAI API"]
        ANTHROPIC["Anthropic API"]
        GOOGLE["Google AI API"]
        DASHSCOPE["DashScope API"]
        LOCAL_LLM["Local Models"]
    end

    User --> Core
    Core --> Agents
    Core --> Execution
    Core --> MCP_LAYER

    ORCHESTRATOR --> CLAUDE
    ORCHESTRATOR --> GEMINI
    ORCHESTRATOR --> QWEN
    ORCHESTRATOR --> GPT
    ORCHESTRATOR --> OLLAMA

    CLAUDE --> ANTHROPIC
    GEMINI --> GOOGLE
    QWEN --> DASHSCOPE
    GPT --> OPENAI
    OLLAMA --> LOCAL_LLM

    MCP_SERVER --> MCP_TOOLS
    MCP_TOOLS --> HANZO_MCP

sequenceDiagram
    participant User
    participant TUI as Terminal UI
    participant Guard as Hanzo Guard
    participant Core as Codex Engine
    participant Agent as AI Agent
    participant MCP as MCP Tools
    participant Exec as Executor
    participant FS as File System

    User->>TUI: Input Command
    TUI->>Guard: Sanitize Input
    Guard->>Core: Safe Input
    Core->>Agent: Generate Response

    alt Tool Call Required
        Agent->>MCP: Tool Request
        MCP->>Guard: Sanitize Tool I/O
        Guard->>Exec: Execute Tool
        Exec->>FS: File Operations
        FS-->>Exec: Results
        Exec-->>Guard: Output
        Guard-->>MCP: Safe Output
        MCP-->>Agent: Tool Result
    end

    Agent-->>Core: Response Stream
    Core-->>Guard: Sanitize Output
    Guard-->>TUI: Safe Response
    TUI-->>User: Display Result

graph LR
    subgraph CLI["CLI Layer"]
        code-cli
        code-tui
    end

    subgraph Core["Core Layer"]
        code-core
        code-protocol
        code-common
    end

    subgraph Execution["Execution Layer"]
        code-exec
        code-execpolicy
        code-linux-sandbox
    end

    subgraph MCP["MCP Layer"]
        code-mcp-client
        code-mcp-server
        code-mcp-types
    end

    subgraph Tools["Tool Layer"]
        code-git-tooling
        code-apply-patch
        code-file-search
    end

    subgraph Auto["Automation Layer"]
        code-auto-drive-core
        code-auto-drive-diagnostics
    end

    code-cli --> code-core
    code-tui --> code-core
    code-core --> code-protocol
    code-core --> code-common
    code-core --> code-exec
    code-exec --> code-execpolicy
    code-exec --> code-linux-sandbox
    code-core --> code-mcp-client
    code-mcp-client --> code-mcp-types
    code-mcp-server --> code-mcp-types
    code-core --> code-git-tooling
    code-core --> code-apply-patch
    code-tui --> code-auto-drive-core

# NPX (fastest - no install required)
npx -y @just-every/code

# Global Installation
npm install -g @just-every/code

# Run the CLI
code  # or 'coder' if 'code' conflicts with VS Code

# Option 1: Sign in with ChatGPT (Plus/Pro/Team)
code  # Select "Sign in with ChatGPT" at prompt

# Option 2: API Key (usage-based)
export OPENAI_API_KEY=sk-...
code

# Option 3: Multiple Providers
export ANTHROPIC_API_KEY=sk-ant-...
export GOOGLE_API_KEY=...
export DASHSCOPE_API_KEY=...

# Interactive mode
code

# With initial prompt
code "explain this codebase to me"

# Non-interactive automation
code exec "run tests and fix failures"

# Full autonomous mode
code --full-auto "create the fanciest todo-list app"

# Install companion CLIs for multi-agent workflows
npm install -g @anthropic-ai/claude-code @google/gemini-cli @qwen-code/qwen-code

# Verify installations
claude --version
gemini --version
qwen --version

~/.code/config.toml    # Primary (write location)
~/.codex/config.toml   # Legacy (read-only fallback)
~/.hanzo/dev.yaml      # Extended configuration

# Model Settings
model = "gpt-5.1"
model_provider = "openai"  # openai | anthropic | google | dashscope | ollama

# Behavior
approval_policy = "on-request"  # untrusted | on-failure | on-request | never
model_reasoning_effort = "medium"  # minimal | low | medium | high
sandbox_mode = "workspace-write"

# UI Preferences
[tui.theme]
name = "light-photon"

# History
[history]
persistence = "save-all"
max-bytes = 10485760  # 10MB

[[agents]]
name = "claude"
command = "claude"
enabled = true
read-only = false
description = "Claude AI assistant"
args = ["--dangerously-skip-permissions"]

[[agents]]
name = "gemini"
command = "gemini"
enabled = true
read-only = false
args = ["-y"]

[[agents]]
name = "qwen"
command = "qwen"
enabled = true
read-only = false
args = ["-y"]

[subagents]

[[subagents.commands]]
name = "plan"
read-only = true
agents = ["claude", "gemini", "qwen"]
orchestrator-instructions = "Focus on discovering project layout and risks."
agent-instructions = "Summarize assumptions explicitly. Cite files you read."

[[subagents.commands]]
name = "solve"
read-only = true
agents = ["claude", "gemini", "qwen"]
orchestrator-instructions = "Run multiple approaches in parallel and compare."
agent-instructions = "Propose a concrete fix with steps to validate."

[[subagents.commands]]
name = "code"
read-only = false
agents = ["claude", "gemini", "qwen"]
orchestrator-instructions = "Coordinate implementations across agents."
agent-instructions = "Write minimal, focused changes with clear rationale."

# Clone repository
git clone https://github.com/hanzoai/dev.git
cd dev

# Install dependencies
pnpm install

# Fast development build
./build-fast.sh

# Run locally
./code-rs/target/dev-fast/code

# Full release build with LTO
cd code-rs && cargo build --release

# Binaries located at:
# ./code-rs/target/release/code
# ./code-rs/target/release/code-tui
# ./code-rs/target/release/code-exec

FROM rust:1.82-slim as builder
WORKDIR /app
COPY . .
RUN cargo build --release --bin code

FROM debian:bookworm-slim
COPY --from=builder /app/target/release/code /usr/local/bin/
ENV OPENAI_API_KEY=""
ENTRYPOINT ["code"]

# Global installation
npm install -g hanzo-node

# Usage
hanzo "your prompt"
hanzo-dev --help

# GitHub Actions example
name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
      - run: ./build-fast.sh
      - run: cargo test --all

  release:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v4
      - run: cargo build --release
      - uses: actions/upload-artifact@v4
        with:
          name: hanzo-dev
          path: target/release/code

flowchart TB
    subgraph Coordinator["Code Coordinator"]
        ORCH["Orchestrator"]
    end

    subgraph Agents["Parallel Agents"]
        CLAUDE["Claude<br/>Analysis"]
        GEMINI["Gemini<br/>Context"]
        QWEN["Qwen<br/>Implementation"]
        GPT["GPT-5<br/>Review"]
    end

    subgraph Consensus["Consensus Layer"]
        MERGE["Response Merger"]
        RANK["Quality Ranker"]
        SELECT["Best Selection"]
    end

    ORCH --> CLAUDE
    ORCH --> GEMINI
    ORCH --> QWEN
    ORCH --> GPT

    CLAUDE --> MERGE
    GEMINI --> MERGE
    QWEN --> MERGE
    GPT --> MERGE

    MERGE --> RANK
    RANK --> SELECT
    SELECT --> ORCH

flowchart TB
    subgraph Input["Input Security"]
        PII["PII Detection"]
        INJECT["Injection Detection"]
        FILTER["Content Filtering"]
    end

    subgraph Execution["Execution Security"]
        SANDBOX["Sandbox Isolation"]
        APPROVE["Approval Workflow"]
        AUDIT["Audit Logging"]
    end

    subgraph Output["Output Security"]
        SANITIZE["Output Sanitization"]
        REDACT["Secret Redaction"]
    end

    Input --> Execution
    Execution --> Output

import { Server } from "@modelcontextprotocol/sdk/server/index.js";

const server = new Server(
  {
    name: "my-custom-tools",
    version: "1.0.0",
  },
  {
    capabilities: { tools: {} },
  },
);

server.setRequestHandler("tools/list", async () => ({
  tools: [
    {
      name: "my_tool",
      description: "Does something useful",
      inputSchema: {
        type: "object",
        properties: {
          input: { type: "string" },
        },
      },
    },
  ],
}));

server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "my_tool") {
    return { content: [{ type: "text", text: "Result" }] };
  }
});

# Enable shared hooks
git config core.hooksPath .githooks