English · 简体中文 · 日本語

VaneHub AI

Desktop-first workspace for managing AI coding agents through one React interface and explicit Web/mock and Tauri runtime boundaries.

Version Tauri React CI License

Overview

VaneHub AI brings Claude Code, OpenCode, Codex CLI, Gemini CLI, and Antigravity CLI into a shared desktop workspace. It manages CLI availability, sessions, terminal execution, projects and worktrees, settings, tools, observability, and desktop integrations without letting React components depend directly on native APIs.

Supported CLIs

One is enough to start. You do not need all five.

Agent Provider Command Model family In-app install Third-party model endpoint
Claude Code Anthropic claude Anthropic @anthropic-ai/claude-code
Codex CLI OpenAI codex OpenAI @openai/codex
OpenCode OpenCode (open source) opencode Unknown opencode-ai
Gemini CLI Google gemini Google @google/gemini-cli ⚠️ Custom endpoint allowed, but the catalog ships only the official preset
Antigravity CLI Google agy Google ❌ No npm package; use the official installer script ❌ Google sign-in only
  • In-app install means VaneHub AI can install and upgrade the CLI for you from Settings → CLI management. It drives npm, WinGet on Windows, and per-CLI audited vendor installers. A copy that came from Homebrew, Bun, Volta, a desktop bundle, or a system package is detected and reported but never changed — VaneHub names the tool that owns it instead of installing a second copy beside it.
  • Third-party model endpoint means the CLI can be pointed at a compatible endpoint such as DeepSeek or OpenRouter from Settings → Agent configurations. Vendor subscription login (OAuth) always happens in your terminal; VaneHub AI does not broker it.
  • OpenCode's model family is "Unknown" by decision, not omission: it drives whichever model you configured, so it has no fixed family, and policies such as "require a reviewer from a different model family" do not apply to it.
  • Gemini CLI is being replaced by Antigravity CLI. Google began phasing it out for personal and free accounts on 2026-06-18.
  • If you would rather install no CLI at all, the built-in native API Agent OnePiece calls model providers over HTTP entirely inside the application. See the user guide below.

Supported model providers

Twenty-five providers ship as configuration templates, shared by OnePiece and three of the CLI Agents. Anything outside the catalog can be added as a custom compatible endpoint.

Category Providers
Official Anthropic, OpenAI
Aggregators and cloud platforms OpenRouter, SiliconFlow, Alibaba Bailian, Volcengine Ark, Together AI, Fireworks AI, NVIDIA NIM, ModelScope, PPIO, Qiniu AI
Model vendors DeepSeek, Zhipu GLM, Kimi / Moonshot, xAI, Mistral AI, MiniMax, MiniMax Global, StepFun, Baichuan AI, Xiaomi MiMo, Z.AI
Inference accelerators Groq, Cerebras

Which Agent a provider can serve depends on the endpoint protocols it offers: the 16 providers speaking Anthropic Messages can back Claude Code, and the 24 speaking OpenAI Chat Completions can back Codex CLI and OpenCode.

The full catalog — vendor icons, endpoint protocols, default models, and API key links — is in the built-in model provider catalog (Simplified Chinese).

Download

Prebuilt desktop packages are published on the Releases page: a signed Windows x64 .exe installer, signed and notarized macOS x64 and Apple Silicon .dmg files, and Linux x64 and ARM64 .deb and AppImage builds. No .msi or .rpm is published.

Verify downloads against the published SHA256SUMS, SPDX SBOM, and GitHub attestations. Linux packages carry integrity and provenance evidence but do not use operating-system code signing.

Documentation

User guide

Topic Entry
Quick start Five steps from installing a CLI to working in a workspace
Basic configuration Interface language, theme, font size, default policy template, launch at login, network proxy, data directory, log directory
User interface overview Main layout, navigation, panel toggles, session/conversation/workspace tabs/info panel
Session list Grouping/search/filter/batch/drag, context menu, focus mode
Floating assistant Standalone floating window session, status badge, main action menu
Loop center Loop run controls, verification command, timeline
OnePiece Plan mode Read-only planning and approved transition to Agent mode
Goal Center Track scattered execution items in one place
Todo Board Board view and stage transitions for work items
Agent evaluation Run several Agents head-to-head on the same task; compare pass rate, tokens, and time
Notification center Bell, unread count, mark all read, clear
System tray Show/hide main window, startup, notification integration
CLI management, install & auth Two install methods, authentication, install detection, conflict diagnostics, upgrades
Multi-Agent group chat Seats, @ handoff, turn bounds
Git worktrees Parallel changes to one repository without stepping on each other
Code review The review center and review flow
Slash commands In-session command entry points
Memory and context Cross-session memory and context compaction
Code indexing Workspace code indexing and its privacy boundary
LSP code intelligence The live language server and its trust model
OnePiece native Agent The built-in API Agent usable without installing a CLI
Scheduled tasks Scheduled tasks and usage statistics
Remote workspaces & SSH connections SSH workspaces, saved connections, and IM access
CLI parameters Per-CLI-Agent launch parameters, with a per-CLI parameter quick reference
Extension capabilities Local extension install/enable/disable
Plugin integration Built-in product integrations and readiness checks
MCP servers MCP server configuration and per-Agent binding
Agent configurations Provider, endpoint, and model per Agent
Expert roles Role fields, responsibilities, and review policy
Agent policies Agent permission policies and approval template configuration
Personalization Custom instructions and cross-session memory
Skill management Skill installation and binding
Prompt Hooks Hook management
IM connectors IM connector configuration
Execution observability Execution tracing and log collection policy
Usage statistics Token usage statistics
About Version, update check, changelog, and repository links
Troubleshooting Check here first when something fails
Reporting issues Which entry point to use, what the forms need, and how to redact before submitting

Developer guide

Topic Entry
Repository layout Repository layout and module ownership
Runtime boundaries Frontend service boundaries, Web/mock and Tauri adapters
Bounded contexts What each of the 21 native bounded contexts owns
Agent lifecycle & provider runtime Registered Agent edits, stable provider resolution, capability declarations
Terminal & PTY runtime Session-scoped Agent Terminal, auto-start/attach, remote terminals
Tool registry & execution Fixed native tool catalog, per-interface_format translation, multi-turn tool loop
Permission model Unified decision point, explicit-Deny-first, approval broker, CLI flag projection, Claude Code hook bridge
Context compaction Token-aware trigger and character fallback, summarization compaction, recent turns kept
Retrieval & vector search Host-level shared memory pool, workspace code index, graceful degradation
Tree-sitter code indexing Grammar parsing, bounded chunks, symbol metadata, grammar version, redaction
Cross-session memory Host-level shared pool, provenance metadata, OnePiece tool vs CLI auto-extraction
Session recovery Recovery status orthogonal to lifecycle, durable execution identity and ownership
OnePiece native Agent Built-in API Agent identity, Profile lifecycle, provider directory
Multi-Agent group chat Seat model, mid-session add/remove, turn routing, durable presence
Skill management Dual scope, SKILL.md contract, drift, built-in seeding/reconciliation
MCP tools & clients Transport and configuration model, MCP tools in the native catalog
IM connectors Five built-in connectors, first-version direct-message scope, inbound routing
Loop & Plan runtimes Durable Loop definitions, topology-aware serial subtask scheduling, Worker/Verifier trust
Usage statistics Reported tokens vs estimated characters, time ranges, per-Agent breakdown
LSP code intelligence In-session LSP integration implementation
Persistence & logging SQLite ownership and unified redacted logs
Testing & release Testing, packaging, and release flow
OpenSpec workflow Proposal→design→delta spec→tasks→validation→archive change flow
Native API reference Rustdoc-generated internal contract and ownership documentation
Architecture decisions Repository layout and module orientation, bounded contexts and call relationships

User guides are available in English and Simplified Chinese. Japanese, Traditional Chinese, and Korean are delivered as application UI resource locales only; no user guide is provided for those locales.

Architecture

flowchart LR
  UI[React UI] --> Service[Frontend service interfaces]
  Service --> Web[Web/mock adapters]
  Service --> Tauri[Tauri adapters]
  Tauri --> Commands[Rust commands]
  Commands --> Contexts[Native bounded contexts]
  Contexts --> SQLite[(SQLite)]
  Contexts --> CLI[Agent CLIs]

React components call services in src/services/. Tauri-specific invoke() calls stay in frontend Tauri adapters, while SQLite, CLI processes, filesystem access, and desktop lifecycle behavior stay in Rust.

Run from source

Prerequisites: Node.js 22+, npm, stable Rust, and the Tauri prerequisites for your platform.

For platform linker requirements, release-profile behavior, worktree cache guidance, and measured build evidence, see the native build performance guide.

npm ci

Run Web/mock preview:

npm run dev -- --host 127.0.0.1

Run the desktop application:

$env:PATH="$env:USERPROFILE\.cargo\bin;$env:PATH"
npm run tauri -- dev

Web/mock is a deterministic browser simulation. It does not claim local CLI execution, SQLite persistence, filesystem changes, or operating-system side effects.

Development

Run every command in the「校验命令」(validation commands) section of AGENTS.md verbatim before submitting changes; that list is the single source of truth aligned with CI.

New features and architecture changes require an OpenSpec proposal before implementation. See AGENTS.md and openspec/project.md for project rules.

Agent infrastructure technical documentation

Topic Entry
MCP protocol model and three-role architecture, transports, core primitives, lifecycle, authorization and security
Function Calling the call loop and constrained decoding, Anthropic versus OpenAI API differences, parallel calls and streaming assembly, structured output
LSP protocol layering and lifecycle, capability negotiation, text synchronization, language and workspace features
A2A AgentCard/Task/Message/Artifact data model, task state machine, discovery, asynchronous update channels
Multi-Agent systems orchestration topologies and role frameworks, communication, context management, execution isolation, failure modes
Agent Skills the open specification and file format, progressive-disclosure loading, triggering and execution, comparison with MCP and prompts
AI coding CLI parameter reference every parameter family across the five CLIs, and the matrix projecting host task models onto each
RAG indexing and retrieval pipelines, semantic versus keyword retrieval, hybrid retrieval and reranking, evaluation
Tree-sitter GLR incremental parsing, grammar toolchain and ABI, the query system, structured code chunking and repo maps
OpenSpec the knowledge model behind spec-driven development, change-package artifact chains, the opsx command family, delta spec merging

Reference: native architecture inventory · contributing · native build performance · release signing

Build the mdBook guides and Rustdoc reference:

npm run docs:check
npm run docs:test
npm run docs:build

The documentation build requires the mdBook version pinned in docs/toolchain.json.

Roadmap

Implemented work and current contracts are recorded in OpenSpec main specifications. Near-term product work includes custom Agents, a plugin marketplace, and extended local OCR/speech capabilities.

Contributing

Read CONTRIBUTING.md before opening a change. Keep documentation, both frontend runtime adapters, native contracts, tests, and OpenSpec artifacts aligned with the behavior you change.

License

Licensed under the Apache License 2.0. See LICENSE.