Skillget

agentrove

agent
Security Audit
Pass
Health Pass
  • License — License: Apache-2.0
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Community trust — 252 GitHub stars
Code Pass
  • Code scan — Scanned 12 files during light audit, no dangerous patterns found
Permissions Pass
  • Permissions — No dangerous permissions requested
Purpose

This tool provides a self-hosted, browser-based workspace for interacting with AI coding agents like Claude Code and Codex. It integrates a full web IDE, terminal, and chat interface while keeping individual projects isolated within separate Docker or host sandboxes.

Security Assessment

By design, this application inherently requires access to highly sensitive operations. It actively manages and executes shell commands via local CLI tools, accesses local file systems to read and write code, and makes outbound network requests to various AI providers (Anthropic, OpenAI, OpenRouter). No hardcoded secrets or dangerous permission requests were found in the scanned code. However, because the tool orchestrates autonomous AI agents capable of executing commands inside its sandboxes, developers must ensure strict network and access controls are applied. Overall risk: Medium.

Quality Assessment

The project is very healthy and actively maintained, with recent pushes occurring within the last day. It has a solid community foundation with 252 GitHub stars and an active Discord server for support. The codebase uses modern, standard technologies (React, FastAPI, Python) and operates under the permissive and standard Apache-2.0 license. A preliminary code audit of 12 files found no dangerous patterns. Note that the developers explicitly warn that the project is under active development and breaking changes should be expected.

Verdict

Use with caution: the code itself appears safe and well-maintained, but the inherent nature of the tool requires strict user oversight of AI-driven file system and shell operations.
SUMMARY

Your own Claude Code UI, sandbox, in-browser VS Code, terminal, multi-provider support (Anthropic, OpenAI, GitHub Copilot, OpenRouter), custom skills, and MCP servers.

README.md

Agentrove

Self-hosted AI coding workspace with Claude and Codex agents, isolated sandboxes, and a full web IDE.

License: Apache 2.0
Python 3.13
React 19
FastAPI
Discord

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

Screenshots

Chat Interface
Agent Workflow

Community

Join the Discord server.

Why Agentrove

  • Run Claude Code and Codex from one self-hosted interface
  • Keep each project in its own Docker or host sandbox
  • Work in chat, editor, terminal, diff, secrets, and PR review views side by side
  • Reuse the same workspace context across chats and sub-threads
  • Manage MCP servers, agents, skills, commands, personas, env vars, and marketplace plugins from the app

Core Architecture

React/Vite Frontend
  -> FastAPI Backend
  -> PostgreSQL + Redis (web mode)
  -> SQLite + in-memory cache/pubsub (desktop mode)
  -> Workspace sandbox (Docker or Host)
  -> Claude Code ACP / Codex ACP
  -> Claude Code CLI / Codex CLI

The app can launch either:

  • Claude via claude-agent-acp + Claude Code
  • Codex via codex-acp + Codex CLI

Key Features

  • Claude and Codex model selection in the same UI
  • Agent-specific permission modes and reasoning/thinking modes
  • Workspace-based project organization with per-workspace sandboxes
  • Docker and host sandbox providers
  • Built-in editor, terminal, diff, secrets, and PR review panels
  • Git helpers for branches, commits, push/pull, and PR creation
  • Streaming chat sessions with resumable SSE events and explicit cancellation
  • Sub-threads for branching work from an existing chat
  • Extension management for MCP servers, custom agents, skills, slash commands, personas, env vars, and marketplace plugins
  • Web app and macOS desktop app

Workspaces

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

Source types

  • Empty: create a new empty directory
  • Git clone: clone a repository into a fresh sandbox
  • Local folder: mount an existing host directory when using the host sandbox

Sandbox isolation

Each workspace gets its own sandbox instance. Chats in the same workspace share the same filesystem, installed tools, auth files, and .claude / .codex resources.

Per-workspace sandbox provider

You can choose a sandbox provider per workspace:

  • Docker: isolated local container
  • Host: runs directly on the host machine

Models And Agents

The app currently exposes two agent families:

  • Claude: default, opus, haiku
  • Codex: gpt-5.4, gpt-5.4-mini, gpt-5.3-codex, gpt-5.2-codex, gpt-5.2, gpt-5.1-codex-max, gpt-5.1-codex-mini

Agent-specific controls:

  • Claude permission modes: default, acceptEdits, plan, bypassPermissions
  • Codex permission modes: default, read-only, full-access
  • Claude thinking modes: low, medium, high, max
  • Codex reasoning modes: low, medium, high, xhigh

Settings Surface

Current settings are organized around:

  • General account settings
  • Marketplace plugins
  • MCP servers
  • Custom agents
  • Skills
  • Slash commands
  • Personas
  • Environment variables
  • Custom instructions

General settings also include:

  • GitHub personal access token
  • Default sandbox provider
  • Timezone
  • Notification preferences
  • Auto-compact toggle
  • Attribution toggle

Quick Start (Web)

Requirements

  • Docker
  • Docker Compose

Start

git clone https://github.com/Mng-dev-ai/agentrove.git
cd agentrove
cp .env.example .env

Set a SECRET_KEY in .env:

openssl rand -hex 32

Start the stack:

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 and local SQLite storage.

Download prebuilt app

How it works

Tauri Desktop App
  -> React frontend
  -> bundled backend sidecar (localhost:8081)
  -> local SQLite database
  -> local workspace sandbox access

Build and run from source

Requirements:

  • Node.js
  • Rust

Dev workflow:

cd frontend
npm install
npm run desktop:dev

Build:

cd frontend
npm run desktop:build

App bundle output:

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

Included Tooling

The backend and sandbox images install the tooling Agentrove needs to run coding agents locally, including:

  • Claude Code
  • Codex CLI
  • claude-agent-acp
  • codex-acp
  • GitHub CLI
  • Playwright MCP

Agentrove also syncs local Claude and Codex auth/config files into sandboxes when available.

Services and Ports (Web)

  • Frontend: 3000
  • Backend API: 8080
  • PostgreSQL: 5432
  • Redis: 6379

API and Admin

Health and Ops

  • Liveness endpoint: GET /health
  • Readiness endpoint: GET /api/v1/readyz
    • web mode checks database and Redis
    • desktop mode checks database only

Deployment

Tech Stack

  • Frontend: React 19, TypeScript, Vite, TailwindCSS, Zustand, React Query, Monaco, xterm.js
  • Backend: FastAPI, SQLAlchemy, Redis, PostgreSQL/SQLite
  • Runtime: Claude Code, Codex CLI, ACP, Docker, Tauri

License

Apache 2.0. See LICENSE.

Contributing

Contributions are welcome. Open an issue first to discuss the change, then submit a pull request.

Reviews (0)

No results found