A local-first desktop manager for Claude Code, Codex CLI, and Gemini CLI — install once, run any model on any agent, and manage every project in a single window. No ACP rewrites, no per-agent config, no cloud lock-in.
Features · Quick Start · Architecture · Roadmap · FAQ
Works with: Claude Code · Codex CLI · Gemini CLI
Understand RunJam at a glance: Agents → RunJam (auto protocol conversion) → Models (cloud + local).
🇨🇳 中文版
Reading order (left → right):
- 01 · AGENTS — Any Agent CLI (Claude Code / Codex CLI / Gemini CLI / …) connects via
stdin/stdout— no agent modification required - 02 · RUNJAM CORE — Three core capabilities: 🔀 Protocol conversion (Anthropic ↔ OpenAI ↔ Gemini), 🗂️ Session management (parallel sessions, persistent state), ⚡ Cache optimization (prompt cache + response cache); plus four capabilities below: 🔌 Install / 💬 Chat / 📁 Workspace / 📊 Dashboard
- 03 · MODELS — Plug in any model: ☁️ Cloud (Anthropic, OpenAI, Google, DeepSeek, Qwen, custom API) and 💻 Local (llama.cpp + GGUF, OpenAI-compatible API)
- Bottom · Pain Points → Solutions — Terminal chaos, protocol silos, token waste, scattered config, tool islands, vendor lock-in, cloud leakage, lost sessions — each mapped to a built-in fix
- 🪟 One window, every project. Chat, file tree, Monaco editor, and terminal — all in one app, multiple sessions in parallel.
- 🔌 Any agent, any model. Built-in protocol proxy converts Anthropic ↔ OpenAI ↔ Gemini on the fly. Claude Code can use GPT. Codex can use Claude. Configure once, sync everywhere.
- 🛠️ Zero agent modifications. Unlike ACP-based tools, RunJam drives agents through their native CLI (stdin/stdout). Works today, with any agent.
- 💸 Cut your API bill. Automatic prompt-cache detection, local response cache, and one-click local models (llama.cpp).
- 🔒 Local-first & private. Conversations, configs, and API keys stay on your machine. Telemetry is on by default (anonymous usage data — disable anytime in Settings), no cloud sync.
If you use AI coding agents daily, you've felt at least one of these:
1. The terminal zoo. Five terminal tabs, each running a different agent, each on a different project. You forget which is which, kill the wrong one, and lose a session.
2. The model mismatch. You want to test a prompt on Claude Sonnet and GPT-4o and a local Qwen. Today that means three different configs in three different files in
~/.claude/,~/.codex/,~/.gemini/.
3. The protocol wall. Claude Code speaks Anthropic. Codex speaks OpenAI. Gemini CLI speaks Google. You can't easily mix-and-match — and adding a new model provider to one agent means digging into its internals.
4. The token bleed. You're paying for the same system prompt to be re-sent on every turn. You don't know which sessions cost the most. You can't tell what's cached vs. fresh.
5. The setup grind. New project, new agent, new API key, new config file, new PATH issue, new npm install, new version mismatch. Every. Single. Time.
6. The single-agent lock-in. Cursor wraps GPT-4. Copilot wraps OpenAI. If the model changes or the price doubles, you migrate your whole workflow.
7. The cloud data worry. Some "AI IDEs" send your code to vendor servers. Your proprietary code, your private configs, your prompts — out of your control.
8. The session black hole. Close your IDE → lose your chat history. Switch machines → start over. Want to find that one prompt from last week? Good luck.
| Pain | RunJam's answer |
|---|---|
| Terminal zoo | One unified window with parallel sessions, sidebar, and per-session workspaces |
| Model mismatch | Unified Model Hub — set a model once, assign per-agent with two clicks |
| Protocol wall | Built-in protocol proxy that auto-translates between Anthropic, OpenAI, and Gemini on the fly |
| Token bleed | Prompt-cache auto-detection + local response cache + per-session cost dashboard |
| Setup grind | Auto-detect + one-click install for Claude Code, Codex CLI, Gemini CLI |
| Single-agent lock-in | Agent-agnostic by design — switch agents without changing your workflow |
| Cloud data worry | Local-first. All data in ~/.runjam/, API keys in OS keychain, telemetry on by default (opt-out in Settings) |
| Session black hole | Persistent sessions, full-text search, archive, multi-device friendly |
| RunJam | Cursor / Copilot | AionUI | Multiple terminals (tmux) | |
|---|---|---|---|---|
| Local-first, no cloud | ✅ | ❌ | ✅ | ✅ |
| Works with any AI agent CLI | ✅ | ❌ | ✅ | |
| Auto-converts model protocols | ✅ | ❌ | ❌ | |
| One-click agent install | ✅ | ❌ | ❌ | ❌ |
| Multi-project in parallel | ✅ | ❌ | ✅ | |
| Built-in editor + terminal + file tree | ✅ | ✅ | ||
| Local model (llama.cpp) | ✅ | ❌ | ❌ | |
| App manager (configure your own web apps) | ✅ | ❌ | ❌ | ❌ |
| Session dashboard / kanban | ✅ | ❌ | ❌ | ❌ |
| Cost tracking dashboard | ✅ | ❌ | ❌ | ❌ |
| Open source (MIT) | ✅ | ❌ | ✅ | ✅ |
| Agent needs no modification | ✅ | n/a | ❌ | n/a |
- Auto-detection — Scans your
PATHforclaude,codex,geminiand shows what's installed - One-click install / uninstall —
npm install -gwith real-time progress - Agent config viewer — Edit
~/.claude/,~/.codex/,~/.gemini/from the GUI - Per-session enable / disable — Use only the agents you want, per project
- Real-time streaming — Watch thinking steps, tool calls, and final answers live
- Markdown + syntax highlighting + Mermaid diagrams — Rendered cleanly inline
- Collapsible thinking blocks — Agent reasoning is separate from the final answer
- Expandable tool call details — Inspect inputs and outputs without leaving the chat
- Multi-agent switching — Switch between Claude Code / Codex / Gemini as easily as switching chat partners
- VS Code-style file explorer — Tree view of your project
- Monaco-powered code editor — The same engine VS Code uses, with full syntax highlighting
- Integrated xterm.js terminal — One terminal per project, persistent
- Recent projects — Quick access to the directories you actually use
- Configure once, sync everywhere — One model config, applied to all agents
- Provider presets — Anthropic, OpenAI, Google AI, Groq, DeepSeek, Qwen, custom APIs
- Per-agent model assignment — Give Claude Code a different model than Codex
- Model aliases — Friendly names like
fastandsmartmapped to real model IDs - Local API proxy — Built-in proxy unifies API key management and protocol conversion
Run open-source LLMs on your own hardware. Free. Offline. Private.
- Built-in llama.cpp server management — Start, stop, and monitor local inference
- Download GGUF models from the UI — DeepSeek Coder, Qwen, Llama, Mistral, etc.
- One-click start — Pick a model, click Start, and RunJam wires it into the same proxy as cloud providers
- Zero API cost — No rate limits, no token bills, no data leaving your machine
- OpenAI-compatible API — Local models speak the same protocol, so every agent can use them out of the box
Why this matters: Your proprietary code and prompts never touch a vendor server. You can run a 7B model on a laptop for routine tasks and route only the hard ones to a paid API — best of both worlds.
Pin your own web apps alongside RunJam. One launcher, everything in reach.
- Register any web app — Internal dashboards, docs sites, Grafana, Sentry, your company wiki
- Custom name, URL, icon — Make it look like a first-class part of RunJam
- One-click open — No more digging through browser bookmarks
- Useful for AI context — Pair an app (e.g. logs dashboard) with an agent session so the agent can read it via MCP or browser tools
See every session at a glance. No more "which agent is doing what" guesswork.
- Kanban / list view — Sessions as cards across columns: Idle / Running / Waiting / Error
- Per-session status — Live indicator: is the agent working, waiting for input, or stalled?
- Project + agent badges — At-a-glance context for every card
- Last activity timestamp — Know which sessions need attention
- Drag to reorganize — Your workflow, your layout
- Click to jump — Open the session straight from the card
Why this matters: When you're running five agents on five repos, "where is everything" is the hardest question. The dashboard makes it obvious.
- Token usage per session — Know exactly where the budget goes
- Cost estimation — By model, by agent, by day
- Chart dashboard — Trends at a glance
- Cache hit rate — See how much the prompt cache is saving you
Most managers just hand the agent's request to a vendor API. RunJam does more:
- Anthropic ↔ OpenAI ↔ Gemini auto-translation — Any agent can use any model
- Response cache — Repeat queries answered locally, no token cost
- Prompt-cache detection — Sees when an upstream API already cached your prompt, so you don't get billed twice
- Single API key entry point — Keys stored in OS keychain, proxied to agents transparently
This is what makes "configure once, sync everywhere" real. Without the proxy, you'd need separate configs per agent per model. With it, one model definition drives all agents.
- All data local — Conversations, configs, and agent states in
~/.runjam/ - Telemetry on by default — anonymous usage data helps improve RunJam; disable anytime in Settings → General
- No cloud dependency — Works fully offline (agents need their own API access)
- System keychain — API keys never touch plaintext config files
- Local models — Run models via llama.cpp with zero API cost
- Multi-session parallel — Run as many agent sessions as your machine can handle
- Session persistence — Sessions survive app restarts, even crashes
- Full-text search — Find any past prompt, response, or tool call
- Archive — Move old sessions out of the sidebar without losing them
- Cost tracking — Built-in, per session
Scenario 1 — Monday morning, three repos to touch
Open RunJam. The session dashboard shows three cards: runjam-core (Claude Code, running), api-refactor (Codex, idle, needs your input), experiments (Gemini, waiting for review). You click the Codex one, drop a new prompt, and move on. All three projects in one window. No terminal switching.
Scenario 2 — Mid-week, cost audit
Open the Cost Tracking dashboard. The chart shows you spent 60% of this week's tokens on the api-refactor session, mostly on GPT-4o. You open the model hub, swap it to a local Qwen-Coder for routine refactors, and reserve GPT-4o for the hard ones. Next week, the same chart is half the size.
Scenario 3 — Friday, sensitive task
Client sends you a contract clause with their proprietary pricing model. You don't want any of it touching a vendor API. You open the Local Model Launcher, click Start on the Qwen-72B you already downloaded, and run the analysis entirely on your machine. Data never leaves your laptop.
| Agent | CLI Command | Install | Provider |
|---|---|---|---|
| Claude Code | claude |
npm install -g @anthropic-ai/claude-code |
Anthropic |
| Codex CLI | codex |
npm install -g @openai/codex |
OpenAI |
| Gemini CLI | gemini |
npm install -g @google/gemini-cli |
More agents on the way. RunJam's agent layer is pluggable — adding a new agent is detection + invocation, no protocol work needed.
- Node.js ≥ 18 (required by AI agent CLIs)
- Rust ≥ 1.80 (for building from source)
- System dependencies:
- macOS: Xcode Command Line Tools
- Windows: Microsoft Visual Studio C++ Build Tools + WebView2
- Linux:
webkit2gtkand related packages
Grab the latest installer from GitHub Releases:
| Platform | Installer |
|---|---|
| macOS (Apple Silicon) | RunJam_*-aarch64.dmg |
| macOS (Intel) | RunJam_*-x64.dmg |
| Windows (x64) | RunJam_*-x64-setup.exe |
| Linux | Work in progress (see Roadmap) |
macOS Gatekeeper: RunJam isn't Apple-notarized yet, so macOS may warn "RunJam is damaged and can't be opened" on first launch. Fix it one of two ways:
- Right-click
RunJam.app→ Open, then confirm Open in the dialog; or- Remove the quarantine flag in Terminal:
xattr -cr /Applications/RunJam.app(Developer ID signing + notarization are in the works to remove this step.)
Install, open RunJam, and it auto-detects the AI agents already on your PATH. Then follow the First Run steps — most people are chatting with an agent in under 5 minutes.
# Clone the repository
git clone https://github.com/peintune/runjam.git
cd runjam
# Install frontend dependencies
npm install
# Run in development mode (hot reload)
npm run tauri dev
# Build for current platform (macOS → .dmg, Windows → .msi/.exe, Linux → .deb/.AppImage)
npm run tauri buildBuild artifacts will be in src-tauri/target/release/bundle/.
# macOS: build universal binary (Intel + Apple Silicon)
npm run tauri build -- --target universal-apple-darwin
# macOS: build Intel-only .dmg
npm run tauri build -- --target x86_64-apple-darwin
# macOS: build Apple Silicon-only .dmg
npm run tauri build -- --target aarch64-apple-darwin
# Windows: build .msi / .exe (run on Windows, or cross-compile from macOS/Linux)
npm run tauri build -- --target x86_64-pc-windows-msvc
# Linux: build .deb / .AppImage
npm run tauri build -- --target x86_64-unknown-linux-gnuCross-compilation note: Building Windows binaries from macOS/Linux requires additional Rust toolchains. It's recommended to build each platform's package on that platform directly (e.g., use CI runners).
- Open RunJam — it auto-detects installed AI agents
- Go to Settings → Agents to install missing agents (one-click)
- Go to Settings → Models to configure your API keys and models
- (Optional) Go to Local Models to download and start a GGUF model
- (Optional) Go to App Manager to pin your most-used web apps
- Click New Session, pick an agent, optionally select a project folder
- Start chatting!
| Layer | Technology | Why |
|---|---|---|
| Desktop Framework | Tauri 2 | 90% smaller than Electron, native performance |
| Backend | Rust | Zero GC pauses, excellent process management |
| Frontend | Vue 3 + TypeScript | Reactive, ecosystem maturity |
| Styling | Tailwind CSS v4 | Rapid UI development |
| State | Pinia | Vue 3 official, great TS support |
| Database | SQLite (rusqlite) | Local-first, zero-config |
| Code Editor | Monaco Editor | VS Code's editor engine |
| Terminal | xterm.js | Industry standard web terminal |
| Local Inference | llama.cpp | Best-in-class CPU/GPU local LLM runtime |
| Process Comm | stdin/stdout pipes | No agent modification needed |
runjam/
├── src-tauri/ # Rust backend
│ └── src/
│ ├── commands/ # Tauri command handlers (IPC bridge)
│ ├── agent/ # Agent detection & installation
│ ├── session/ # Session management & process control
│ ├── dashboard/ # Session dashboard state
│ ├── apps/ # App manager
│ ├── local_model/ # llama.cpp / GGUF management
│ ├── models/ # Data structures
│ ├── db/ # SQLite layer & migrations
│ ├── proxy.rs # Local API proxy + protocol adapter
│ └── ...
├── src/ # Vue 3 frontend
│ ├── components/ # UI components
│ ├── views/ # Page views (Chat, Dashboard, AppMgr, ...)
│ ├── stores/ # Pinia state management
│ ├── api/ # Tauri invoke wrappers
│ ├── composables/ # Vue composables
│ └── i18n/ # Internationalization (EN/ZH)
├── docs/
│ └── screenshots/ # README screenshots (you fill these in)
├── landing.html # Landing page (separate build)
└── package.json
RunJam manages AI agent CLI tools as child processes:
- Detection — Scans
PATHforclaude,codex,geminiexecutables - Invocation — Spawns agent CLI as a child process with
stdinpiped - Streaming — Reads
stdoutline-by-line, streams to frontend via Tauri events - Protocol Proxy — RunJam's built-in proxy intercepts agent API calls and automatically converts between different LLM protocols (Anthropic ↔ OpenAI ↔ Gemini), so any agent can use any model
- Local inference — When a model points to a local llama.cpp server, the proxy talks to it via OpenAI-compatible API
- Parsing & rendering — Parses agent output (thinking steps, tool calls, final responses); Vue renders Markdown, code blocks, and Mermaid diagrams
No network protocols required. No agent modifications needed. Just native CLI processes with automatic protocol adaptation.
- Agent auto-detection & one-click install
- Unified chat interface with streaming
- Multi-agent, multi-project sessions
- Built-in file explorer, editor, and terminal
- Unified model configuration with sync
- Session persistence & search
- Local API proxy for unified key management
- i18n (English / 中文)
- Prompt cache optimization (auto-detect cache hits, response cache)
- llama.cpp local model support (download, run, manage GGUF models)
- PTY session mode (persistent multi-turn context)
- Cost tracking dashboard with charts
- App Manager — pin your own web apps inside RunJam
- Session Dashboard — kanban view of every session's status
- Local Model Launcher — one-click start a local model server
- Git worktree integration
- Agent auto-update detection
- Plugin / skill system
- Linux builds
- Mobile companion (read-only session view)
Cursor and Copilot are AI-powered code editors. They wrap a specific model, ship your code to a vendor cloud, and lock you into one workflow. RunJam is not an AI and not an editor — it's a manager that makes your existing AI CLI agents (Claude Code, Codex CLI, Gemini CLI) more productive. You keep your agents, your models, your local data, and your flexibility.
AionUI requires every agent to implement the ACP (Agent Client Protocol). That's a real commitment from each agent's maintainer — and many agents don't speak ACP. RunJam takes a different approach: it drives agents through their native CLI over stdin/stdout. Zero agent modifications needed. That means RunJam works with any CLI agent today, and new agents work on day one.
A terminal gives you processes; RunJam gives you context. tmux won't translate Anthropic ↔ OpenAI ↔ Gemini, won't let you swap a session's model in two clicks, won't show you which session is burning your budget, and won't persist chat history across restarts. If you're happy juggling five terminals, RunJam isn't for you — but if you want one window with per-project sessions, a dashboard, and a cost view, that's what RunJam adds on top of your agents.
No. RunJam auto-detects what's on your PATH and offers one-click install for Claude Code, Codex CLI, and Gemini CLI via npm install -g. Real-time progress shown in the UI.
Yes. That's exactly what the protocol proxy is for. Example: Claude Code (Anthropic protocol) talking to GPT-4o (OpenAI protocol). The proxy translates on the fly. You don't touch the agent or the model.
No. RunJam is local-first. All agent processes run on your machine. All data (conversations, configs, agent states) is stored locally in ~/.runjam/. Telemetry is on by default — anonymous usage data (launch & version info, key feature usage, sanitized error logs) helps improve the product. You can disable it anytime in Settings → General. There is no cloud sync. API keys live in the OS keychain, not in config files.
The only thing that touches the cloud is the LLM API call itself — and you choose the provider. Run a local llama.cpp model and nothing leaves your laptop at all.
Yes. RunJam is fully open-source under the MIT license. Free to use, modify, and distribute. Local models are free forever (you bring the hardware). Cloud model usage is billed by the provider as usual.
Yes. You can create separate sessions for different projects, each using a different agent. They run independently in parallel without interfering. The Session Dashboard gives you a kanban view of all of them at once.
macOS, Windows, and Linux are all supported. The only prerequisite is Node.js ≥ 18 (required by AI agent CLIs). RunJam will check and guide you through installation if needed.
This is macOS Gatekeeper blocking unsigned apps. Run the following in Terminal to remove the quarantine attribute:
xattr -cr /Applications/RunJam.appWe are working on Apple code signing and notarization to eliminate this step in the future.
Yes. RunJam's agent layer is small and explicit — adding a new agent is a matter of detection + invocation. See CONTRIBUTING.md for the agent integration guide. PRs welcome.
We'd love to hear from you — bug reports, feature requests, or just saying hi. Pick whichever channel fits you best:
- 🐛 GitHub Issues — Report bugs, request features, or track progress → github.com/peintune/runjam/issues
- 💡 GitHub Discussions — Ask questions and chat with the community → github.com/peintune/runjam/discussions
- 🎮 Discord — Real-time chat with the team and community → Join our Discord
Tip: For bug reports, please include your OS, RunJam version, and steps to reproduce — it helps us fix things faster. 🙏
Contributions are welcome! See CONTRIBUTING.md for setup instructions, code style guidelines, and PR workflow.
- Linux build testing & packaging
- New agent support (Aider, Continue, Goose, …)
- UI/UX improvements
- Documentation & translations
- Bug reports & testing
- Local model benchmarks & presets
MIT © RunJam Contributors
⭐ Star this repo if you find it useful!
Made with Rust 🦀 and Vue 3 💚