---

What is Quanta?

Quanta is a local-first AI code editor built on VS Code OSS, powered by a high-performance Rust backend. It gives you a complete agentic coding experience — reading files, writing code, running terminals, applying LSP fixes, and managing git — all driven by local LLMs through Ollama. Cloud providers (OpenAI, Anthropic) are supported as optional backends, but Ollama is the primary engine. Your code never has to leave your machine.

Unlike cloud-first AI editors, Quanta is designed around local inference. The agent loop, tool execution, LSP integration, checkpoint system, and inline completions all happen locally through a Rust backend that communicates with the editor via JSON-RPC over TCP.

---

Table of Contents

• Key Features
• Feature Comparison
• Architecture
• Quick Start
• Installation
• Agent Tools
• Agent Modes
• LSP & Diagnostics
• Checkpoint System
• Edit History & Undo/Redo
• MCP Integration
• Model Management
• HuggingFace Integration
• Engineering Skills
• Voice & TTS
• Session Management
• Plan Mode
• Configuration
• License

---

Key Features

Core Agent

• 30+ built-in tools — read/write/edit files, unified diffs, terminal, grep, glob, git operations, LSP actions, and more
• ReAct agent loop — Think, Act, Observe, Feedback pattern with anti-loop guards and automatic retries
• 3 agent modes — Code (full capability), Ask (read-only), Plan (read-only + plan writing)
• Sub-agent spawning — Delegate scoped tasks to parallel sub-agents with up to 3 levels of nesting
• Persistent todo lists — Track multi-step work across conversation turns

Local-First

• Ollama integration — Auto-detects and lists all local models with metadata
• Thinking/reasoning support — Configurable think levels (Low/Medium/High) for reasoning models
• Inline code completion — FIM completions with LRU cache, debouncing, and in-flight cancellation
• Local-first by design — Ollama is the primary backend; cloud providers (OpenAI, Anthropic) are optional. Your code never has to leave your machine.

Safety & Control

• Shadow-git checkpoints — Automatic workspace snapshots before every agent write action
• Edit review system — Accept/reject individual edits with diff previews
• Stale-file detection — Prevents edits to files that changed since last read
• Terminal safety guards — Blocks destructive commands (format, shutdown, force-delete)
• Atomic writes — All file operations use temp-file-and-rename for crash safety

Developer Experience

• Full LSP integration — Diagnostics, go-to-definition, find references, code actions, rename symbol
• 20+ engineering skills — Built-in guidance for TDD, code review, security review, debugging, and more
• MCP support — One-click enable for GitHub, Jina AI, Brave Search, Postgres, Puppeteer, and more
• HuggingFace model browser — Search, download, and install GGUF models directly from the editor
• Per-model configuration — Override temperature, think level, edit format, tool call mode, and more per model
• Voice support — Speech-to-text via Whisper, text-to-speech via Piper

---

Feature Comparison

Note: Competitor data is based on publicly available documentation as of 2025. Features change frequently — verify with each tool's official docs before relying on this table for decisions. A dash (—) means we could not verify the feature's presence or absence and chose not to guess.

Footnotes:

1. Cursor — Supports Ollama via OpenAI-compatible endpoint for chat and tab completion, but agent modes do not work with local LLMs as of May 2025 (community feature request open).
2. Claude Code — Supports local Ollama models via Anthropic-compatible API endpoint (Ollama 0.14+). Cloud (Anthropic) is the default backend.
3. Cursor — Has session-local checkpoints that do not persist across IDE restarts and do not use a shadow git repository. They capture file changes only, not terminal side effects.
4. Cursor — Has parallel agents via git worktrees (Agents Window) and /best-of-n multi-model runs, but does not support spawning sub-agents from within an ongoing conversation.

---

Architecture

┌─────────────────────────────────────────────────────────────┐
│                     Quanta AI Editor                        │
│  ┌───────────────────────────────────────────────────────┐  │
│  │              VS Code OSS (Electron Frontend)          │  │
│  │  ┌───────────────┐  ┌─────────────┐  ┌──────────────┐ │  │
│  │  │  Chat Webview │  │   Editor    │  │  Inline Comp │ │  │
│  │  │  (TypeScript) │  │  (Monaco)   │  │  (TypeScript)│ │  │
│  │  └──────┬────────┘  └──────┬──────┘  └──────┬───────┘ │  │
│  │         │                  │                │         │  │
│  │  ┌──────┴──────────────────┴────────────────┴───────┐ │  │
│  │  │           Quanta Extension (TypeScript)          │ │  │
│  │  │     RPC Client · Diagnostics · LSP Bridge        │ │  │
│  │  └──────────────────────┬───────────────────────────┘ │  │
│  └─────────────────────────┼─────────────────────────────┘  │
│                            │ JSON-RPC 2.0 over TCP          │
│  ┌─────────────────────────┴─────────────────────────────┐  │
│  │              Quanta Backend (Rust)                    │  │
│  │  ┌─────────────┐  ┌──────────────┐  ┌──────────────────┐ │  
│  │  │ Agent Loop  │  │ Tool Registry│  │  Session Manager │ │ 
│  │  │ (ReAct)     │  │ (30+ tools)  │  │  (persistence)   │ │ 
│  │  └──────┬──────┘  └──────────────┘  └──────────────────┘ │ 
│  │  ┌──────┴──────────────────────────────────────────────┐ │ 
│  │  │  Checkpoint Service · MCP · LSP Reverse RPC         │ │ 
│  │  └─────────────────────────────────────────────────────┘ │ 
│  │  ┌─────────────┐  ┌─────────────┐  ┌──────────────┐   │  │
│  │  │   Ollama    │  │  OpenAI API │  │ Anthropic API│   │  │
│  │  │ (localhost) │  │  (optional) │  │  (optional)  │   │  │
│  │  └─────────────┘  └─────────────┘  └──────────────┘   │  │
│  └───────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Key design principles:

• The extension is a thin UI layer — all agent logic lives in the Rust backend
• Communication via newline-delimited JSON-RPC 2.0 over TCP (localhost only)
• The backend manages tool execution, LSP reverse-RPC, checkpoints, sessions, and MCP
• Cloud providers (OpenAI, Anthropic) are optional — Ollama is the primary inference engine

---

Quick Start

Prerequisites

1. Ollama — Install and start the Ollama service

   # Install a model (example)
   ollama pull qwen2.5-coder:7b
   

2. Git — Required for the checkpoint system

Run Quanta

1. Download the latest release from the Releases page
2. Extract the archive and run Quanta.exe
3. Open a project folder (File > Open Folder)
4. Open the chat panel — Click the Quanta icon in the activity bar
5. Select a model — Click the model name in the chat header to pick from your Ollama models
6. Start coding — Ask Quanta to build features, fix bugs, refactor code, or explain your codebase

Tip: Use @ in the chat input to mention files and inject them as context.

---

Installation

Option 1: Pre-built Release (Recommended)

Download the latest release from the Releases page. Extract and run — no build tools required.

Option 2: Build from Source

Prerequisites

• Rust (stable, with cargo)
• Node.js v20+
• Ollama running on localhost:11434
• Git

---

Agent Tools

Quanta's agent has access to 30+ tools organized into functional groups:

Filesystem & Terminal

LSP Integration

Git

Agent Management

Network & Context

---

Agent Modes

Switch modes using the mode button in the chat header.

---

LSP & Diagnostics

Quanta provides deep LSP integration that feeds real-time diagnostics to the model:

• Push-based diagnostics — VS Code sends diagnostics to the backend cache as they change
• Per-file version tracking — Ensures diagnostics are fresh and correctly scoped
• Deduplication — Merges diagnostics from multiple sources (LSP, tree-sitter)
• Auto-refresh — Diagnostics are re-fetched after agent file edits
• Tree-sitter fallback — Syntax-based diagnostics for languages without an LSP
• Language-specific configuration — Auto-configures LSP servers for 20+ languages

Supported LSP features:

• Diagnostics (errors, warnings, info, hints)
• Go to definition
• Find references
• Code actions (quick fixes, refactorings)
• Apply code action (with edit tracking)
• Rename symbol (workspace-wide)

Auto-configured languages: C#, TypeScript/JavaScript, Rust, Python, Go, Java, Kotlin, Dart, Ruby, F#, Erlang, Haskell, D, R, LaTeX, and more.

---

Checkpoint System

Quanta creates automatic workspace-level snapshots using a shadow git repository — completely separate from your project's own git repo.

• Automatic — A checkpoint is saved before every agent write action
• Works without git — Your project doesn't need to be a git repo
• Workspace-level — Covers edits, deletes, moves, and terminal-generated changes
• Browseable — View checkpoint timeline with messages and timestamps
• Restorable — Revert the entire workspace to any checkpoint
• Diffable — Compare any checkpoint against current state or another checkpoint
• Deletable — Select and delete individual checkpoints or all at once
• Safe — Checkpoints are stored in ~/.quanta/checkpoints/ and never touch your project

---

Edit History & Undo/Redo

Every agent edit is tracked in a per-edit history with full undo/redo support:

• Diff preview — See exactly what changed before accepting
• Accept/reject individually — Review each edit one at a time
• Accept/reject all — Bulk operations for multi-file changes
• Undo — Revert specific edits after they've been applied
• Redo — Re-apply undone edits
• Full diff view — Open a complete diff in a separate editor panel
• Edit history panel — Timeline of all edits in the current session

---

MCP Integration

Quanta supports the Model Context Protocol for extending the agent with external tools:

Built-in MCP Servers (One-Click Enable)

MCP Features

• On-demand tool loading — MCP tools are deferred until needed, reducing context overhead by ~85%
• Custom server configuration — Add any MCP-compatible server
• API key management — Securely store credentials for MCP servers
• Server status monitoring — See connection status at a glance
• Tool search — The agent can search for and load MCP tools by keyword

---

Model Management

Per-Task Model Routing

Route different models to different tasks for optimal performance:

Per-Model Configuration Overrides

Fine-tune each model individually via the Local Model Override Settings panel (~/.quanta/model_overrides.json):

Override priority: User override > Built-in profile > Baseline defaults

---

HuggingFace Integration

Browse and install models directly from HuggingFace without leaving the editor:

• Search — Find GGUF models by name, filter by pipeline tag and size
• Sort — By downloads, likes, or relevance
• Download — GGUF files or safetensors directories with progress tracking
• Auto-register — Downloaded models are automatically registered with Ollama
• Hardware specs — Detects CPU, RAM, GPU VRAM to help you pick the right model
• Cleanup — Tracks and removes orphaned blobs from cancelled downloads
• Model management — View and delete locally installed models

---

Engineering Skills

Quanta includes 20+ built-in engineering skills that provide structured guidance for common development tasks:

User-Invoked Skills

Model-Invoked Skills

Custom Skills

Create your own skills in:

• Project-local: .agents/skills/{name}/SKILL.md
• Global: ~/.agents/skills/{name}/SKILL.md

---

Voice & TTS

Speech-to-Text

• integration (tiny.en, base.en, small.en models)
• Configurable language
• Dictation toggle: Ctrl+Shift+M
• Audio buffer processing with temporary file handling

Text-to-Speech

• integration with voice model downloads from HuggingFace
• Configurable voice (e.g., en_US-lessac-medium)
• Speed control
• Read aloud toggle: Ctrl+Shift+L
• Markdown cleaning for natural speech
• Voice listing (installed and available)

---

Session Management

Conversations

• Create, list, load, and delete sessions
• Auto-generated conversation titles
• Search sessions by content
• Per-session and cumulative token usage tracking
• Session persistence to disk
• Cascade delete for sub-agent sessions

Export & Import

• Export to Markdown, JSON, or PDF
• Import from JSON or Markdown
• Exports include thinking content, tool calls, and timestamps

---

Plan Mode

Plan before you build:

1. Switch to Plan mode in the chat header
2. Ask Quanta to create an implementation plan
3. Review the rendered markdown plan in the plan panel
4. Click Implement Plan to switch to Code mode and execute
5. Edit the plan at any time via Edit Plan

Plan files are saved to .quanta/plans/ and persist across sessions.

---

Configuration

Server

Models

Inline Completion

Editing

Diagnostics

Voice

---

License

MIT License — see LICENSE for details.

Copyright (c) 2026 Quanta AI

---