Volt

The open-source agentic editor, built on the VS Code core.

Drive Claude Code, Codex or Grok over ACP, or a local model through Ollama,
then review every change hunk by hunk before it lands. MIT licensed, in public beta.

Download · Website · Install guide · Changelog · Discord · Contributing

⭐ If Volt looks useful, star the repo. It's an independent project, and stars are how other developers find it.

Volt is highly inspired by Cursor, but open source all the way down. It is a workspace for working with coding agents: the chat, the code, Git, a browser and a terminal share one window. Because it is built on the real VS Code core, your extensions, themes, keybindings, language servers and debuggers come along.

Public beta. Volt is below 1.0 and moves fast. Expect rough edges and changes between releases. The changelog lists what changed in each one.

1. Install. On macOS or Linux, one command downloads the right build, checks its SHA-256 against the release and installs it, with no sudo:

curl -fsSL https://raw.githubusercontent.com/LeulAria/volt/main/install.sh | bash

Or download an installer from GitHub Releases:

2. Open it.

• macOS: open the .dmg and drag Volt to Applications. From 0.0.4 the builds are signed with an Apple Developer ID and notarized, and they update themselves. Volt 0.0.3 and older cannot update themselves: download the new version once and replace the app. Your settings and chats stay.
• Windows: the installers are not code-signed yet. When SmartScreen says Windows protected your PC, click More info, then Run anyway.
• Linux: sudo apt install ./volt-stable-<version>-linux-x64.deb, or sudo dnf install ./volt-stable-<version>-linux-x64.rpm.

3. Connect an agent. Open Volt Settings from the command palette (⇧⌘P) and pick one:

• an agent CLI you already use and are signed in to, such as Claude Code, Codex or Grok (early access), over the Agent Client Protocol. Volt leaves your plan and credentials with that tool;
• a local model through Ollama (127.0.0.1:11434 by default);
• an API key.

4. Start. Press ⌘N for a new agent chat, ask for a change, then keep or undo it hunk by hunk.

macOS is the platform Volt is developed and tested on; Windows and Linux builds come from the same pipeline but have had little testing. There are also Beta and Nightly channels, each its own app that installs next to Volt (see Releasing Volt). Everything about installing is in docs/install.

Volt is highly inspired by Cursor. The difference is that it is MIT-licensed, and it drives the agent CLIs you already pay for instead of selling tokens.

• Agent CLIs over ACP. Claude Code, Codex, OpenCode, Cursor (early access), Grok (early access), Antigravity, Kimi and any generic Agent Client Protocol agent. Warm sessions are kept ready, so a new chat doesn't pay a cold start.
• Direct model access. OpenAI, Anthropic, Gemini, OpenRouter, any OpenAI-compatible endpoint, Ollama and LM Studio, driven by Volt's own native tool loop.
• Five modes in one composer. Agent, Plan, Ask, Debug and Multitask. Plan and Ask can't edit files or run shell commands. Plan mode proposes a plan card you approve, revise, edit or save.
• Subagents. Delegate work to subagents, watch them in the side toolbar, read their chats, and resume a stopped one or retry a failed one. Each subagent's changes show up in the turn's review.
• Several Claude accounts. Sign in to more than one login and switch by hand, or let Volt move to another account near a usage limit.
• MCP. Connect MCP servers (stdio or HTTP) from .mcp.json, .cursor/mcp.json, .vscode/mcp.json or .volt/mcp.json. Agents call them like built-in tools, under the same permissions.
• Project instructions. AGENTS.md, CLAUDE.md, .volt/AGENTS.md, .cursorrules and .github/copilot-instructions.md are picked up automatically.
• A code index for agents. Volt indexes your open projects in the background, so grep, glob and symbol lookups answer from an index instead of walking the tree.

• Access presets. Supervised (default), Auto-accept edits, Auto and Full access, layered with project, agent, session and mode rules. Allow-always decisions are remembered and visible.
• Pending edits. Keep or undo changes hunk by hunk against a baseline, with Undo All and Keep All a click away in the Changes header.
• Checkpoints. A Git snapshot before and after every turn, stored under a hidden ref (refs/volt/*), with preview, restore and redo. Your index and branches stay untouched.
• Per-chat worktrees and sandboxes. Give a chat its own checkout so parallel agents don't trample each other, and choose its sandbox level and network.

• Agent and IDE layouts. One command toggles between a chat-first window and the full editor workbench.
• Projects. Add a project from this computer, a Git URL or GitHub, and switch between projects and chats from one sidebar.
• In-app browser with design mode. The agent can navigate, click, type, take screenshots and read the console and network. You can pick an element or draw an area, name what to change, and batch several annotations into one message.
• Git, built in. Branches, Remotes, Tags, Worktrees, Stashes and Commits sit in Source Control, and pull requests open in Volt (GitHub, with reading support for GitLab, Bitbucket, Gitea and Azure DevOps).
• A rich composer. @-mention files, folders, terminals, other chats, branches, editor selections, browser elements and images. Queue your next message while the agent works, or dictate it.
• Questions, plans and todos. Agents can ask you a structured question, propose a plan you approve before it runs, and show their task list as they go.
• Context and usage meters. See how much of a model's context a chat is using, and what Claude, Codex and Cursor usage costs, from local transcripts and account data.

• Tab completion and next-edit prediction. Inline suggestions from the model you choose, plus a one-shot Volt: AI Edit command for multi-file changes. Disabled for .env*, lockfiles and secrets by default.
• Everything VS Code. Debugging, tasks, the extension host, remote development and the full set of built-in language features.

The workbench never embeds a provider SDK. The UI talks to a runtime service; the runtime decides which model or agent runs, asks the access broker before any tool touches your machine, and uses platform services for processes, Git and the loopback MCP server that exposes Volt's browser and question tools to agents.

Everything else is the VS Code core, kept as close to upstream as we can so that merging new releases stays tractable. VOLT-ARCHITECTURE-REVIEW.md is a candid engineering review, and VOLT-MULTI-PROJECT-AGENT-WORKSPACE-PLAN.md describes where the agent window is headed.

Open Volt Settings from the command palette (⇧⌘P) and choose how you want to run agents:

1. An agent CLI you already use. Install it and sign in the way that tool documents. Volt finds it on your PATH (or launches a pinned adapter through npx) and leaves your plan and credentials with that tool. Volt does not store them.
2. An API key. Add a provider (OpenAI, Anthropic, Gemini, OpenRouter or any OpenAI-compatible endpoint). Keys go in the editor's secret storage, not in settings files.
3. A local model. Point Volt at Ollama (127.0.0.1:11434 by default) or LM Studio.

Then press ⌘N for a new agent chat.

You need Node.js 22.19 (the version in .nvmrc; 22.15.1 is the minimum), npm, Git, Python 3 and a C/C++ toolchain for native modules. On macOS that is the Xcode Command Line Tools. CONTRIBUTING.md lists the Linux and Windows packages.

git clone https://github.com/LeulAria/volt.git
cd volt

nvm install                          # picks up Node from .nvmrc
npm install                          # installs dependencies, builds native modules
npm run electron                     # downloads the Electron runtime into .build/
node build/lib/builtInExtensions.js  # fetches the pinned built-in extensions

make start                           # compile, watch and launch Volt

make start runs a file watcher and launches the app with hot reload: save a file and the window reloads. make help lists the rest (make stop, make reload, make restart). The first compile takes a few minutes; after that, rebuilds are incremental.

To package a macOS app yourself:

unset ELECTRON_RUN_AS_NODE
VOLT_BUILD_IGNORE_TYPE_ERRORS=1 \
  node --max-old-space-size=16384 ./node_modules/gulp/bin/gulp.js vscode-darwin-arm64-min

The unsigned app lands in ../VSCode-darwin-arm64/VOLT.app. VOLT_BUILD_IGNORE_TYPE_ERRORS=1 reports type errors but still packages, because the tree can carry known TypeScript diagnostics; see CONTRIBUTING.md. Release builds for every platform are made by GitHub Actions, as described in Releasing Volt.

Volt ships with no telemetry endpoint. What leaves your machine is what you choose to send: prompts, file contents and tool results go to whichever model or agent you select, and tab prediction (on by default) sends the code around your cursor to the model you picked for it. Volt also makes requests to GitHub (when you add a project from GitHub and, in release builds, to check a static update feed for new versions), Open VSX (extensions) and the usage endpoints of the agents you've signed into. Development builds never check for updates.

Permissions are an approval policy, not a sandbox: an agent you allow to run shell commands runs them as you. Read SECURITY.md for the full trust model before you point Volt at code you don't trust.

Volt is built in the open and we'd love your help. Bug reports with clear reproduction steps, focused fixes and well-tested improvements are the fastest way to get something merged. For a larger feature, open an issue first so we can agree on the shape before you invest the time.

Read CONTRIBUTING.md and the Code of Conduct to get started. To report a security problem, don't open a public issue; follow SECURITY.md.

Volt stands on a lot of open work:

• Visual Studio Code (Code - OSS) by Microsoft and its contributors, the foundation of this project
• Open VSX by the Eclipse Foundation, the extension registry
• Agent Client Protocol and the Model Context Protocol, the interfaces that let Volt work with many agents and tools
• The authors of every agent CLI Volt can drive, and of the third-party packages listed in ThirdPartyNotices.txt

Volt is an independent project. It is not affiliated with, endorsed by or sponsored by Microsoft, Anthropic, OpenAI, Google, Cursor or any other company named here. "Visual Studio Code" is a trademark of Microsoft Corporation, and all other product names and logos belong to their owners.

Volt is released under the MIT License.

Copyright (c) 2026 - present Volt ADK. Portions copyright (c) 2015 - present Microsoft Corporation.