Manage and run multiple AI agents — Claude Code, Codex CLI, Gemini CLI, and more — in a single unified desktop app. Auto-detect, one-click install, real-time streaming, local-first, automatic protocol proxy, cache optimization, llama.cpp local models, built-in code editor, terminal, and more.
Features · Quick Start · Architecture · Roadmap · FAQ
RunJam is a local-first, cross-platform desktop manager for AI agents. It manages your AI CLI tools and LLM model configurations — think of it as a unified control panel for all your AI coding assistants.
Instead of juggling multiple terminal windows, manually configuring each agent, and losing track of which agent is working on which project, RunJam brings everything into one clean interface with a single model configuration for all projects and agents:
- Auto-detect agents already installed on your system
- One-click install missing agents (Claude Code, Codex CLI, Gemini CLI)
- Unified chat interface with real-time streaming, Markdown rendering, and syntax highlighting
- Multi-project, multi-agent sessions running in parallel
- Built-in file explorer, terminal, and code editor for each project workspace
- Unified model configuration — configure once, sync to all agents with automatic protocol proxy
- Cache optimization — automatic prompt cache detection saves tokens and reduces costs
- Run local models — built-in llama.cpp support for free, offline inference with open-source models
- Local-first — all data stays on your machine, no cloud, no telemetry
Core philosophy: RunJam doesn't require manually installing agent CLI tools — one-click auto-install. No need to manually configure the right model for each agent — RunJam's proxy auto-converts model protocols. No need for multiple editor windows for multiple projects — one interface manages all projects in parallel. Zero modifications needed. Just install and go.
- Auto-detection — Scans your PATH for installed AI agents (Claude Code, Codex CLI, Gemini CLI)
- One-click install/uninstall — Installs agents via
npm install -gwith real-time progress - Agent configuration — View and edit agent config files (
~/.claude/,~/.codex/,~/.gemini/) - Enable/disable agents per session
- Real-time streaming — Watch agent thinking process, tool calls, and responses live
- Markdown rendering — Full Markdown support with syntax highlighting and Mermaid diagrams
- Thinking process — Agent reasoning steps are separated and auto-collapsed
- Tool call details — Expand to see tool inputs and outputs
- Multi-agent switching — Switch between agents as naturally as switching chat partners
- File explorer — Browse project files with a VS Code-style tree
- Built-in code editor — Monaco-powered editor with syntax highlighting
- Integrated terminal — xterm.js terminal for each project
- Recent projects — Quick access to recently used project directories
- Unified model hub — Configure models once, sync to all agents automatically
- Provider presets — OpenAI, Anthropic, Google AI, Groq, DeepSeek, custom APIs, and local models
- Per-agent model assignment — Assign different models to different agents
- Model aliases — Map friendly names to model IDs
- API proxy — Built-in local proxy for unified API key management
- Cache optimization — Automatic prompt cache hit detection & local response cache to save tokens and reduce costs
- Local models — Built-in llama.cpp integration to run open-source models (DeepSeek Coder, Qwen, Llama, etc.) 100% locally and free
- Multi-session parallel — Run multiple agent sessions simultaneously
- Session persistence — Sessions survive app restarts
- Search — Full-text search across all conversation history
- Archive — Archive old sessions to keep the sidebar clean
- Cost tracking — Token usage and cost estimation per session
- All data local — Conversations, configs, and agent states stored in
~/.runjam/ - No telemetry — Zero data collection, no analytics, no phone-home
- No cloud dependency — Works fully offline (agents need their own API access)
- System keychain — API keys stored securely in OS keychain
- Local models — Run models via llama.cpp with zero API costs
| 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 coming soon. RunJam's architecture makes it easy to add new agents — just add their detection and invocation logic.
- 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
Pre-built binaries will be available on the GitHub Releases page.
# 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
- Click New Session, pick an agent, optionally select a project folder
- Start chatting!
flowchart LR
subgraph Frontend["🖥️ Vue 3 Frontend"]
UI[Chat UI]
Settings[Settings Panel]
WS[Workspace Panel]
end
subgraph Agents["🤖 AI Agents"]
Claude[Claude Code]
Codex[Codex CLI]
Gemini[Gemini CLI]
end
subgraph Proxy["🔀 RunJam Proxy"]
Router[Protocol Router]
Cache[Response Cache]
LLM[LLM Protocol Adapter]
end
subgraph Backend["☁️ LLM APIs"]
Anthropic[Anthropic API]
OpenAI[OpenAI API]
Google[Google AI API]
DeepSeek[DeepSeek API]
Qwen[Qwen API]
Custom[Custom APIs]
end
subgraph Local["💻 Local Models"]
Llama[llama.cpp Server]
GGUF[GGUF Models]
end
UI -->|"Tauri IPC"| Agents
Settings -->|"Tauri IPC"| Agents
WS -->|"Tauri IPC"| Agents
Agents -->|"stdin/stdout"| Proxy
Proxy -->|"Auto Protocol\nConversion"| Router
Router --> Cache
Cache --> LLM
LLM --> Anthropic
LLM --> OpenAI
LLM --> Google
LLM --> DeepSeek
LLM --> Qwen
LLM --> Custom
Router -.->|"local models"| Llama
Llama --> GGUF
style Frontend fill:#42b883,color:#fff
style Agents fill:#ce422b,color:#fff
style Proxy fill:#6366f1,color:#fff
style Backend fill:#f59e0b,color:#fff
style Local fill:#8b5cf6,color:#fff
flowchart TB
subgraph Desktop["🖥️ RunJam Desktop (Tauri 2)"]
direction TB
subgraph Frontend2["Vue 3 Frontend"]
Chat[Chat Messages]
Sidebar[Session Sidebar]
Explorer[File Explorer]
Editor[Monaco Editor]
Terminal[xterm.js Terminal]
end
subgraph RustBackend["Rust Backend"]
Cmds[Tauri Commands]
AgentMgr[Agent Manager]
SessionMgr[Session Manager]
DB[(SQLite DB)]
Proxy2[API Proxy]
LlamaSrv[llama.cpp Manager]
end
end
subgraph Processes["📦 External Processes"]
ClaudeProc[Claude Code Process]
CodexProc[Codex ACP Process]
GeminiProc[Gemini CLI Process]
LlamaProc[llama-server Process]
end
Chat -->|"Tauri Events"| Cmds
Sidebar --> Cmds
Explorer --> Cmds
Editor --> Cmds
Terminal --> Cmds
Cmds --> AgentMgr
Cmds --> SessionMgr
AgentMgr --> DB
SessionMgr --> DB
Proxy2 --> DB
AgentMgr -->|"spawn & pipe"| ClaudeProc
AgentMgr -->|"spawn & pipe"| CodexProc
AgentMgr -->|"spawn & pipe"| GeminiProc
LlamaSrv -->|"spawn & manage"| LlamaProc
ClaudeProc -->|"stdout stream"| Proxy2
CodexProc -->|"stdout stream"| Proxy2
GeminiProc -->|"stdout stream"| Proxy2
LlamaProc -->|"OpenAI API"| Proxy2
Proxy2 -->|"HTTP"| AnthropicAPI[Anthropic API]
Proxy2 -->|"HTTP"| OpenAIAPI[OpenAI API]
Proxy2 -->|"HTTP"| GoogleAPI[Google AI API]
Proxy2 -->|"HTTP"| DeepSeekAPI[DeepSeek API]
Proxy2 -->|"HTTP"| QwenAPI[Qwen API]
style Desktop fill:#1e1e2e,color:#fff
style Frontend2 fill:#42b883,color:#fff
style RustBackend fill:#ce422b,color:#fff
style Processes fill:#6366f1,color:#fff
| 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 |
| 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
│ ├── models/ # Data structures
│ ├── db/ # SQLite layer & migrations
│ ├── proxy.rs # Local API proxy
│ └── ...
├── src/ # Vue 3 frontend
│ ├── components/ # UI components
│ ├── views/ # Page views
│ ├── stores/ # Pinia state management
│ ├── api/ # Tauri invoke wrappers
│ ├── composables/ # Vue composables
│ └── i18n/ # Internationalization (EN/ZH)
├── 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
- Parsing — Parses agent output (thinking steps, tool calls, final responses)
- Rendering — Vue frontend 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
- Git worktree integration
- Agent auto-update detection
- Plugin/skill system
- Linux builds
Cursor and Copilot are AI-powered code editors. RunJam is not an AI or an editor — it's a manager that makes your existing AI CLI agents more productive. Think of it as a unified dashboard for Claude Code, Codex CLI, and Gemini CLI.
AionUI requires agents to implement the ACP (Agent Client Protocol). RunJam takes a different approach: it manages agents as native CLI processes via stdin/stdout. Zero agent modifications needed. This means RunJam works with any CLI agent out of the box.
No. RunJam is local-first. All agent processes run on your machine. All data (conversations, configs, agent states) is stored locally in ~/.runjam/. No telemetry, no analytics, no cloud sync.
Yes. RunJam is fully open-source under the MIT license. Free to use, modify, and distribute.
Yes. You can create separate sessions for different projects, each using a different agent. They run independently in parallel without interfering with each other.
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.
Contributions are welcome! See CONTRIBUTING.md for setup instructions, code style guidelines, and PR workflow.
- Linux build testing & packaging
- New agent support (Aider, Continue, etc.)
- UI/UX improvements
- Documentation & translations
- Bug reports & testing
MIT © RunJam Contributors
⭐ Star this repo if you find it useful!
Made with Rust 🦀 and Vue 3 💚