conduit

conduit

A fast, memory-efficient Go implementation of Claude Code — the agentic CLI for Claude.

Conduit is a 1:1 functional reimplementation of Claude Code v2.1.126, written in Go with Bubble Tea. It runs on your existing Claude Max or Teams subscription, uses the same OAuth flow, the same API wire format, and the same tool set — but starts faster, uses less memory, and ships as a single static binary.

Why conduit?

Features

Core agent

• Full Claude Code parity — 249/264 scoped features implemented (94%)
• Streaming SSE — real-time token-by-token output with cost tracking
• Auto-compact — context window managed automatically; manual /compact
• Thinking mode — extended reasoning via /effort low|normal|high|max
• Fast mode — /fast toggles Haiku for faster/cheaper turns
• Coordinator mode — Claude as orchestrator managing parallel sub-agents
• Exponential backoff — automatic retry on 429 with jitter

Tools (30+ built-in)

MCP (Model Context Protocol)

• stdio, HTTP, SSE transports — connect any MCP server
• Plugin system — install from marketplace (claude-plugins-official), enable/disable per-session
• Resource listing and reading — ListMcpResources, ReadMcpResource
• MCP panel — /mcp opens full browser with per-server tool lists and reconnect
• Plugin panel — /plugin browses marketplace, manages installed plugins

Memory & context

• CLAUDE.md loading — walks from cwd to root, injects as system blocks
• @include directives — compose CLAUDE.md files across directories
• Auto-memory — summarises conversations to MEMORY.md; injected on next session
• Memory scanning — /memory scan finds stale or contradicted facts
• Relevant memory search — surfaces related memories by keyword on session start

TUI

• Bubble Tea v2 — native Shift+Enter via Kitty keyboard protocol
• Full GFM markdown — tables, task lists, strikethrough, blockquotes, code blocks with syntax
• Light and dark themes — /theme picker with 6 built-in palettes (dark, light, daltonized variants, ANSI variants), custom theme support
• Output styles — /output-style for different response modes (default, Explanatory, Learning; plugins can add more)
• Custom keybindings — ~/.claude/keybindings.json remaps any action
• Status bar — model, mode, context %, cost, rate-limit indicator
• Coordinator footer — live sub-agent progress during multi-agent runs

Multi-account

• Platform keychain storage — macOS Keychain, Linux libsecret, Windows Credential Manager via go-keyring
• /account panel — add, switch, remove, and delete accounts without restarting
• accounts.json — tracks all registered accounts; auto-selects most-recently-added on first run

In-process RTK (token savings)

Conduit ships with RTK (Rust Token Killer) ported to Go as a zero-overhead in-process filter. Every BashTool result is passed through the filter before being sent to the model.

Typical savings:

• git status → 90% reduction
• cargo test → 85% (test failures only)
• npm install → 80%
• eslint → 75%

View your savings: type /rtk gain inside the TUI.

Hooks

• PreToolUse / PostToolUse / SessionStart / Stop — shell, HTTP, prompt, and agent hooks
• Async hooks — PostToolUse hooks run in background without blocking the next turn
• Desktop notifications — notify on turn complete (macOS native + Linux notify-send)

Session management

• JSONL transcripts — every session saved to ~/.claude/projects/<path>/<id>.jsonl
• /resume — fuzzy-search all past sessions, load with full history
• /search — search across all session transcripts for a term
• Cost persistence — accumulated cost tracked per-session, shown in /status
• Session recording — /record captures terminal output in asciicast v2 format

Installation

Homebrew (macOS / Linux)

brew install icehunter/tap/conduit

Go install

go install github.com/icehunter/conduit/cmd/conduit@latest

Pre-built binary

Download from Releases for your platform:

curl -L https://github.com/icehunter/conduit/releases/latest/download/conduit-darwin-arm64 -o conduit
chmod +x conduit
mv conduit /usr/local/bin/

Build from source

git clone https://github.com/icehunter/conduit
cd conduit
make build
# binary at ./conduit

Quick start

# Start an interactive session
conduit

# Sign in with your Claude Max / Teams subscription (inside the TUI)
/login

# One-shot prompt (no TUI)
conduit --print "explain this codebase"

# Continue last session
conduit --continue

# Resume a specific session
conduit --resume <session-id>

Slash commands

Configuration

Settings file

~/.claude/settings.json — all settings managed via /config panel or edited directly.

Key settings:

{
  "model": "claude-sonnet-4-6",
  "defaultPermissionMode": "default",
  "autoCompactEnabled": true,
  "alwaysThinkingEnabled": true,
  "theme": "dark",
  "outputStyle": "default",
  "env": {
    "MY_TOKEN": "..."
  }
}

CLAUDE.md

Place a CLAUDE.md in any directory — conduit reads from the file's directory up to the repo root and your home directory, injecting each as a system context block. Use @path/to/file inside to include another file inline.

Custom keybindings

~/.claude/keybindings.json:

{
  "compact": ["ctrl+k"],
  "command:clear": ["ctrl+l"],
  "submit": ["enter"]
}

Hooks

// ~/.claude/settings.json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "BashTool",
        "hooks": [{ "type": "command", "command": "echo pre-bash" }]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "*",
        "hooks": [{ "type": "command", "command": "notify.sh", "async": true }]
      }
    ]
  }
}

Hook types: command (shell), http (POST JSON to URL), prompt (inject result as context), agent (spawn sub-agent).

MCP servers

// ~/.claude/settings.json
{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"]
    },
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"]
    }
  }
}

Themes

Built-in themes (matching Claude Code's palette set):

Switch with /theme, or set "theme": "dark-ansi" in settings.json.

Custom themes can be defined under "themes" in settings.json:

{
  "themes": {
    "my-theme": {
      "primary": "#c0caf5",
      "secondary": "#565f89",
      "accent": "#7aa2f7",
      "background": "#1a1b26"
    }
  }
}

RTK — in-process token compression

Conduit ships with RTK (originally a Rust CLI) ported to Go and fused directly into the process. It intercepts BashTool results before they reach the model and applies command-aware compression rules.

Inside the TUI:

/rtk gain      # cumulative savings across all sessions
/rtk discover  # scan transcripts for missed compression opportunities

RTK covers 70 command patterns including: git, cargo, npm/yarn/pnpm, pytest, eslint, dotnet, aws CLI, ls, and structured log output.

Multi-agent / coordinator mode

/coordinator

Enables coordinator mode: Claude acts as an orchestrator that spawns sub-agents via AgentTool. Sub-agents run in parallel, each with their own tool context and history. The coordinator footer in the status bar shows live agent progress.

Building from source

Requirements: Go 1.26+

make build      # builds to ./conduit
make test       # go test ./...
make test-race  # go test -race ./...
make lint       # golangci-lint run

Parity

Conduit implements 249/264 scoped Claude Code features (94%). The remaining features are Claude-internal or require the VS Code/JetBrains bridge:

• Bridge (VS Code / JetBrains JSON-RPC) — use real Claude Code for IDE integration
• Remote agents / ULTRAPLAN — Anthropic-hosted, bridge-dependent
• Voice recording — no portable Go audio; would require cgo + whisper.cpp
• Team swarm (SendMessageTool, TeamCreateTool) — requires Anthropic teammate mailbox
• GrowthBook feature flags / KAIROS — Anthropic-internal
• Vim mode — 1,513 LOC port of CC vim bindings; deferred

Full breakdown: PARITY.md

License

MIT — see LICENSE.

Conduit is an independent project and is not affiliated with or endorsed by Anthropic. Claude® is a trademark of Anthropic, PBC.