Agentrove

What is Agentrove about?

Agentrove delivers a self‑hosted web UI that wraps Claude Code as the execution harness. It supports routing requests to Anthropic, OpenAI, GitHub Copilot, OpenRouter, or any custom Anthropic‑compatible endpoint while preserving Claude Code’s tool behaviour, permissions, and MCP orchestration. Workspaces provide isolated sandboxes (Docker or host) and a shared file system, enabling a VS Code‑like experience directly in the browser or as a native desktop app.

How to use Agentrove?

1. Start the service – clone the repo and launch the Docker Compose stack (web mode) or run the Tauri desktop build (desktop mode).
2. Open the UI at http://localhost:3000 (web) or launch the bundled macOS app.
3. Create a workspace, choose a source type (empty, Git clone, local folder) and a sandbox provider.
4. Configure providers in Settings → Providers: add Anthropic token, OpenAI device flow, Copilot token, OpenRouter key, or custom base URL.
5. Interact with Claude Code through chat, execute code, run commands, or develop custom skills, agents, and slash commands via the MCP extension surface.

Key Features of Agentrove

• Claude Code‑native chat execution via claude-agent-sdk.
• Anthropic Bridge that translates Claude requests to OpenAI, OpenRouter, or Copilot models while keeping the same request shape.
• Workspace‑based organization with per‑workspace sandbox isolation (Docker or host).
• Multi‑sandbox runtimes – Docker containers or host processes.
• MCP extensibility – custom skills, agents, slash commands, and marketplace plugins.
• Streaming SSE architecture with resumable events and explicit cancellation.
• Built‑in recurring task scheduler (async, no external worker).
• Web and desktop modes – React/Vite frontend, FastAPI backend; desktop uses Tauri with a bundled Python sidecar and SQLite.
• Full developer stack – PostgreSQL + Redis for production, SQLite for desktop.

Use Cases of Agentrove

• Full‑stack development: write, run, and debug code in a browser‑based VS Code experience powered by Claude Code.
• Multi‑model experimentation: switch between Anthropic, OpenAI, OpenRouter, or Copilot models without changing the workspace or file system.
• Isolated testing environments: spin up separate Docker sandboxes for each project or client, ensuring reproducible execution.
• Custom AI agents: build and deploy skills, agents, and slash commands that interact with the sandbox via MCP.
• Educational platforms: provide students with a safe, sandboxed coding environment backed by powerful LLM assistants.

FAQ from the Agentrove

Q: Do I need a separate database for the desktop version? A: No. The desktop mode uses a local SQLite file and an in‑memory cache/pub‑sub, removing the need for PostgreSQL or Redis.

Q: Can I run Agentrove without Docker? A: Yes. In desktop mode the sandbox runs on the host process, and in web mode you can choose the host sandbox provider when creating a workspace.

Q: How does provider switching keep the context? A: The workspace’s filesystem, .claude configuration, and MCP settings remain unchanged; only the model endpoint changes, so chat history and state are preserved.

Q: What is the Anthropic Bridge? A: It is a lightweight service launched inside the sandbox that exposes an Anthropic‑compatible API, routing calls to non‑Anthropic providers while preserving Claude Code request semantics.

Q: How are recurring tasks scheduled? A: Agentrove includes an in‑process asynchronous scheduler that runs tasks defined in skills or agents; no external worker process is required.

Agentrove

Self-hosted Claude Code workspace with multi-provider routing, sandboxed execution, and a full web IDE.

Note: Agentrove is under active development. Expect breaking changes between releases.

Community

Join the Discord server.

Why Agentrove

• Claude Code as the execution harness, exposed through a self-hosted web UI
• One workflow across Anthropic, OpenAI, GitHub Copilot, OpenRouter, and custom Anthropic-compatible endpoints
• Anthropic Bridge routing for non-Anthropic providers while preserving Claude Code behavior
• Isolated sandbox backends (Docker, host)
• Extension surface: MCP servers, skills, agents, slash commands, prompts, and marketplace plugins
• Provider switching with shared working context

Core Architecture

React/Vite Frontend
  -> FastAPI Backend
  -> PostgreSQL + Redis (web/docker mode)
  -> SQLite + in-memory cache/pubsub (desktop mode)
  -> Sandbox runtime (Docker/Host)
  -> Claude Code CLI + claude-agent-sdk

Claude Code harness

Agentrove runs chats through claude-agent-sdk, which drives the Claude Code CLI in the selected sandbox. This keeps Claude Code-native behavior for tools, session flow, permission modes, and MCP orchestration.

Anthropic Bridge for non-Anthropic providers

For OpenAI, OpenRouter, and Copilot providers, Agentrove starts anthropic-bridge inside the sandbox and routes Claude Code requests through:

• ANTHROPIC_BASE_URL=http://127.0.0.1:3456
• provider-specific auth secrets such as OPENROUTER_API_KEY and GITHUB_COPILOT_TOKEN
• provider-scoped model IDs like openai/gpt-5.2-codex, openrouter/moonshotai/kimi-k2.5, copilot/gpt-5.2-codex

Agentrove UI
  -> Claude Agent SDK + Claude Code CLI
  -> Anthropic-compatible request shape
  -> Anthropic Bridge (OpenAI/OpenRouter/Copilot)
  -> Target provider model

For Anthropic providers, Agentrove uses your Claude auth token directly. For custom providers, Agentrove calls your configured Anthropic-compatible base_url.

Key Features

• Claude Code-native chat execution through claude-agent-sdk
• Anthropic Bridge provider routing with provider-scoped models (openai/*, openrouter/*, copilot/*)
• Workspace-based project organization with per-workspace sandboxes
• Multi-sandbox runtime (Docker/Host)
• MCP + custom skills/agents/commands + plugin marketplace
• Streaming architecture with resumable SSE events and explicit cancellation
• Built-in recurring task scheduler (in-process async, no worker service)

Workspaces

Workspaces are the top-level organizational unit. Each workspace owns a dedicated sandbox and groups all related chats under one project context.

Source types

• Empty — creates a new empty directory in the sandbox
• Git clone — clones a repository (HTTPS or SSH) into a fresh sandbox
• Local folder — mounts an existing directory from the host filesystem (host sandbox only)

Sandbox isolation

Each workspace gets its own sandbox instance (Docker container or host process). Chats within a workspace share the same filesystem, installed tools, and .claude configuration. Switching between workspaces switches the entire execution environment.

Per-workspace sandbox provider

When creating a workspace you can override the default sandbox provider (Docker or Host). The provider is locked at creation time — all chats in that workspace use the same provider.

Workspace lifecycle

• Creating a workspace provisions the sandbox and initializes it with your settings (GitHub token, env vars, skills, agents, slash commands)
• Deleting a workspace soft-deletes all its chats and destroys the sandbox container

Quick Start (Web)

Requirements

• Docker + Docker Compose

Start

git clone https://github.com/Mng-dev-ai/agentrove.git
cd agentrove
docker compose -p agentrove-web -f docker-compose.yml up -d

Open http://localhost:3000.

Stop and logs

docker compose -p agentrove-web -f docker-compose.yml down
docker compose -p agentrove-web -f docker-compose.yml logs -f

Desktop (macOS)

Desktop mode uses Tauri with a bundled Python backend sidecar on localhost:8081, with local SQLite storage.

Download prebuilt app

• Apple Silicon DMG: Latest Release

How it works

When running in desktop mode:

• Tauri hosts the frontend in a native macOS window
• the sidecar backend process serves the API on 8081
• desktop uses local SQLite plus in-memory cache/pubsub (no Postgres/Redis dependency required for desktop mode)

Tauri Desktop App
  -> React frontend (.env.desktop)
  -> bundled backend sidecar (localhost:8081)
  -> local SQLite database

Build and run from source

Requirements:

• Node.js
• Rust

Dev workflow:

cd frontend
npm install
npm run desktop:dev

Build (unsigned dev):

cd frontend
npm run desktop:build

App bundle output:

• frontend/src-tauri/target/release/bundle/macos/Agentrove.app

Desktop troubleshooting:

• Backend unavailable: wait for sidecar startup to finish
• Database errors: verify local app data directory permissions
• Port conflict: free port 8081 if already in use

Provider Setup

Configure providers in Settings -> Providers.

• anthropic: paste token from claude setup-token
• openai: authenticate with OpenAI device flow in UI
• copilot: authenticate with GitHub device flow in UI
• openrouter: add OpenRouter API key and model IDs
• custom: set Anthropic-compatible base_url, token, and model IDs

Model examples

• OpenAI/Codex: gpt-5.2-codex, gpt-5.2, gpt-5.3-codex
• OpenRouter catalog examples: moonshotai/kimi-k2.5, minimax/minimax-m2.1, google/gemini-3-pro-preview
• Custom gateways: models like GLM-5, M2.5, or private org-specific endpoints (depends on your backend compatibility)

Shared Working Context

Switching providers within a workspace does not require a new workflow:

• Same sandbox filesystem/workdir
• Same .claude resources (skills, agents, commands)
• Same MCP configuration in Agentrove
• Same workspace and chat history

This is the main value of using Claude Code as the harness while changing inference providers behind Anthropic Bridge.

Services and Ports (Web)

• Frontend: 3000
• Backend API: 8080
• PostgreSQL: 5432
• Redis: 6379
• VNC: 5900
• VNC Web: 6080
• OpenVSCode server: 8765

API and Admin

• API docs: http://localhost:8080/api/v1/docs
• Admin panel: http://localhost:8080/admin

Health and Ops

• Liveness endpoint: GET /health
• Readiness endpoint: GET /api/v1/readyz
  • web mode checks database + Redis
  • desktop mode checks database (SQLite) only

Deployment

• VPS/Coolify guide: docs/coolify-installation-guide.md
• Production setup uses frontend at / and API under /api/*

Screenshots

Tech Stack

• Frontend: React 19, TypeScript, Vite, TailwindCSS, Zustand, React Query
• Backend: FastAPI, SQLAlchemy, Redis, PostgreSQL/SQLite
• Runtime: Claude Code CLI, claude-agent-sdk, anthropic-bridge, uvicorn

License

Apache 2.0. See LICENSE.

Contributing

Contributions are welcome. Please open an issue first to discuss what you would like to change, then submit a pull request.

References

• Anthropic Claude Code SDK: docs.anthropic.com/s/claude-code-sdk
• Anthropic Bridge package: pypi.org/project/anthropic-bridge
• OpenAI Codex CLI sign-in: help.openai.com/en/articles/11381614
• OpenRouter API keys: openrouter.ai/docs/api-keys
• GitHub Copilot plans: github.com/features/copilot/plans