<div align="center"> <a href="https://endor.dev/rover"> <picture> <source media="(prefers-color-scheme: dark)" srcset="https://github.com/user-attachments/assets/d53e2e6d-2dac-4999-b1c9-63961035ffd9"> <img alt="Endor logo" src="https://github.com/user-attachments/assets/fea0f426-7577-4935-a345-b00ef681b490" height="128"> </picture> </a> <h1>Rover</h1>

</div>

Rover is a manager for AI coding agents that works with Claude Code, Codex, Cursor, Gemini, and Qwen.

It helps you get more done, faster, by allowing multiple agents to work on your codebase simultaneously. The agents work in the background in separate, isolated environments: they don't interfere with your work or each other.

Rover does not change how you work: everything runs locally, under your control, and using your already installed tools.

Getting Started

First, install Rover:

npm install -g @endorhq/rover@latest

Then, run rover task in your project to create a task describing what you want to accomplish and hand it to Rover. You can specify which agent to use with the --agent (or -a) flag. Rover will automatically detect your project and register it.

Supported agents: claude, codex, cursor, gemini, and qwen.

A screencast showing rover task

Rover will:

🔒 Prepare a local isolated environment (using containers) with an independent copy of your project code
⚙️ Install and configure your preferred AI coding agent in that environment
🤖 Setup a workflow for the agent to complete the task and run it in the background until it finishes
📖 Collect a set of developer-friendly documents with information about the changes in the code

Depending on the task complexity, it might take a few minutes. Meanwhile, you can create new tasks and run them in parallel or simply relax, step back and do some other work, whether on your computer or away from it!

Why Rover?

Running and managing multiple AI coding agents simultaneously can be overwhelming. You need to run them isolated from each other and they constantly ask for attention. Context switching quickly becomes a productivity drain.

At the same time, parallel execution is one of the most powerful capabilities of AI coding agents. You can focus on a task while a team of agents complete small issues, start another task, or just write some documentation.

To simplify this process, Rover manages AI coding agents on your behalf. It integrates with both your terminal and VSCode (as an extension).

block-beta
columns 1
  block:Tool
    columns 1
    Repository["Your Repository"]
    Rover
  end
  space
  block:ID
    block:group1
        columns 1
        Task1["Task 1: Add a new feature ..."]
        Agent1["Claude"]
        Repo1["Git Worktree (rover/1-xxx)"]
        Container1["Container (rover-1-1)"]
    end
    block:group2
        columns 1
        Task2["Task 2: Add a missing docs ..."]
        Agent2["Cursor"]
        Repo2["Git Worktree (rover/2-xxx)"]
        Container2["Container (rover-2-1)"]
    end
    block:group3
        columns 1
        Task3["Task 3: Fix issue X ..."]
        Agent3["Gemini"]
        Repo3["Git Worktree (rover/3-xxx)"]
        Container3["Container (rover-3-1)"]
    end
  end
  block
    Computer["Your Computer"]
  end
  Tool --> ID
  style Rover fill:#107e7a,stroke:#107e7a

Main features

🚀 Easy to use: Manage multiple AI coding agents working on different tasks with a single command
🔒 Isolated: Prevent AI Agents from overriding your changes, accessing private information or deleting system files
🤖 Bring your AI agents: Use your existing AI agents like Claude Code, Codex, Cursor, Gemini, and Qwen. No new subscriptions needed
💻 Local: Everything runs on your computer. No new apps and permissions in your repositories
👐 Open Source: Released under the Apache 2 license

Quickstart

Prerequisites

You need at least one supported AI agent in your system:

Terminal

Install it using npm:

npm install -g @endorhq/rover@latest

First steps

Create your first task with Rover:

cd <your-project> && rover task --agent claude

Check the status of your task:
```
rover ls -w
```
Keep working on your own tasks 🤓

After finishing, check the task result:

rover inspect 1
rover inspect 1 --file changes.md
rover diff 1

If you want to apply more changes, create a second iteration with new instructions:
```
rover iterate 1
```
If you need to apply changes manually, jump into the task workspace:
```
rover shell 1
```
If changes are fine, you can:
- Merge them:
```
rover merge 1
```
- Push the branch to the remote using your git configuration:
```
rover push 1
```
- Take manual control:
```
rover shell 1
git status
```

💡 TIP: You can run multiple tasks in parallel. Just take into account your AI agents' limits.

Configuration

Although it's not required, we recommend running rover init in your project to generate an initial configuration:

rover init

VSCode

Rover is available on the VSCode Marketplace. You can look for Rover in your VSCode Extensions Panel or access the Marketplace page and click Install there.

If the Rover CLI is not in the PATH, the extension will guide you through the setup process. Once everything is ready, you will be able to create your first task!

See the VSCode documentation site.

How it works

Rover relies on local tools you already have like Git, Docker/Podman and AI coding agents. When you create your first task in a project, Rover automatically detects your project setup, identifies its requirements, and registers it in a central store.

Once you create a task, Rover creates a separate git worktree (workspace) and branch for that task. It starts a container, mounts the required files, installs tools, configures them, and lets your AI agent complete a workflow. Rover workflows are a set of predefined steps for AI coding agents. Depending on the workflow, you might get a set of changes in the workspace or a document with research.

After an AI agent finishes the task, all code changes and output documents are available in the task workspace (git worktree). You can inspect those documents, check changes, iterate with an AI agent, or even take full control and start applying changes manually. Every developer has a different workflow, and Rover won't interfere with it.

Once you are ready, you can merge changes or push the branch. That's it! 🚀

Model Selection

Rover supports selecting both the AI agent and the model using the agent:model syntax:

rover task -a claude:sonnet    # Use Claude with Sonnet model
rover task -a claude:opus      # Use Claude with Opus model
rover task -a gemini:pro       # Use Gemini with Pro model

You can also configure default models per agent in .rover/settings.json:

{
  "defaults": {
    "models": {
      "claude": "sonnet",
      "gemini": "flash"
    }
  }
}

Multi-Project Support

Rover supports managing tasks across multiple projects. Use the --project flag or the ROVER_PROJECT environment variable to target a specific project:

rover ls --project my-project
rover task --project /path/to/project

To view all registered projects and their tasks:

rover info

MCP Server

Rover can run as a Model Context Protocol (MCP) server, allowing AI assistants to interact with Rover programmatically:

rover mcp

This exposes all core Rover commands (task creation, inspection, logs, diff, merge, push, etc.) as MCP tools. You can configure it in your AI agent's MCP settings:

{
  "mcpServers": {
    "rover": {
      "command": "rover",
      "args": ["mcp"]
    }
  }
}

Workflow Management

Rover ships with built-in workflows and supports adding custom ones. Use the workflow commands to manage them:

rover workflow list                       # List available workflows
rover workflow add <url-or-path>          # Add a custom workflow
rover workflow inspect <workflow-name>    # Inspect a workflow definition

Rover

Install / Use

README