Skip to content

Quanta Ai Code Editor

Latest
Latest

Choose a tag to compare

View all tags
@ContegoCode ContegoCode released this 25 Aug 06:10
· 13 commits to main since this release
v0.1.0
1b1daa1
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

🚀 Quanta AI Code Editor v0.1.0

A local-first, self-learning AI code editor — powered by a Rust backend and Ollama. Your code never leaves your machine.

PlatformBackendFrontendModelsLicense

✨ What is Quanta AI?

Quanta AI is a fully local AI code editor built on top of VS Code. It pairs a high-performance Rust backend with a TypeScript extension to deliver an agentic coding experience that runs entirely on your machine — no cloud, no API keys, no data leakage.

Powered by Ollama for local model inference and optionally accelerated by llama.cpp MTP (Multi-Token Prediction), Quanta gives you a Claude Code–class agent loop with the privacy of local execution.

🎯 Core Features

🤖 Agentic Coding

Feature | Description -- | -- ReAct Agent Loop | Think → Act → Observe → Feedback pattern with anti-loop guards, adaptive backoff with jitter, and run-budget enforcement 30+ Agent Tools | Read/write/edit files, unified diffs, terminal, grep, glob, git operations, LSP actions, web search, skill management, and more 3 Agent Modes | Code (full capability), Ask (read-only), Plan (read-only + plan writing with Implement Plan button) Sub-Agent Spawning | Delegate scoped tasks to parallel sub-agents (up to 3 levels deep) with restricted tool sets Per-Model Routing | model_overrides.json with per-model edit formats, context windows, teacher models, summarization models, and sub-agent models 5 Edit Attempts | Robust edit retry with fuzzy matching — up from 3 attempts to handle model formatting inconsistencies

⚡ MTP / llama.cpp Acceleration

Multi-Token Prediction (MTP) uses speculative decoding to accelerate local LLM generation. On Windows, Ollama doesn't support MTP (macOS-only via MLX), so Quanta manages a local llama-server subprocess.

  • Embedded MTP (Qwen3.5/3.6, Hunyuan 3, GLM-5.2): MTP heads included in the GGUF — no separate draft model needed

  • Separate Draft (Gemma 4): Base GGUF + separate assistant/draft GGUF

  • Safe fallback: If MTP is enabled but the server isn't healthy, requests fall back to Ollama

  • Windows Job Objects: Guaranteed child process cleanup on exit

  • Per-model config: Backend selection (CUDA, Vulkan, CPU), VRAM estimation, per-model MTP toggle

🔧 Configuration

All config lives in ~/.quanta/config.json:

json
{
  "curator": {
    "enabled": true,
    "interval_hours": 168,
    "min_idle_hours": 2.0,
    "consolidate": false
  },
  "memory": {
    "enabled": true,
    "nudge_interval": 10,
    "write_approval": false
  },
  "model": {
    "selected": "your-model-name"
  },
  "skills": {
    "creation_nudge_interval": 10
  }
}

📋 Prerequisites

  • Ollama installed and running

  • Git installed

  • (Optional) NVIDIA GPU for MTP acceleration via CUDA

🚀 Installation

  1. Download and extract the release archive for your platform

  2. Run Quanta.exe

  3. Open a project folder

  4. Open the chat panel and select an Ollama model

  5. Start coding! 🎉

⚠️ Known Limitations

  • Windows is the primary tested platform

  • Local model quality depends on your hardware and the model you choose

  • MTP acceleration requires a compatible GGUF model (separate from Ollama blobs)

  • First public release — please report any bugs you may find

🗺️ Roadmap

  • Context Collapse — Reversible projection/folding system for even larger context windows

  • Cross-platform sandboxing — Linux/macOS terminal sandbox support

  • More MCP servers — Expanding the built-in MCP ecosystem

  • Model fine-tuning integration — Train and use fine-tuned models directly from the editor

🤝 Feedback

Found a bug or have a feature request? Open an issue.


🚀 Quanta AI Code Editor v0.1.0 A local-first, self-learning AI code editor — powered by a Rust backend and Ollama. Your code never leaves your machine.

PlatformBackendFrontendModelsLicense

✨ What is Quanta AI?
Quanta AI is a fully local AI code editor built on top of VS Code. It pairs a high-performance Rust backend with a TypeScript extension to deliver an agentic coding experience that runs entirely on your machine — no cloud, no API keys, no data leakage.

Powered by Ollama for local model inference and optionally accelerated by llama.cpp MTP (Multi-Token Prediction), Quanta gives you a Claude Code–class agent loop with the privacy of local execution.

🎯 Core Features
🤖 Agentic Coding
Feature Description
ReAct Agent Loop Think → Act → Observe → Feedback pattern with anti-loop guards, adaptive backoff with jitter, and run-budget enforcement
30+ Agent Tools Read/write/edit files, unified diffs, terminal, grep, glob, git operations, LSP actions, web search, skill management, and more
3 Agent Modes Code (full capability), Ask (read-only), Plan (read-only + plan writing with Implement Plan button)
Sub-Agent Spawning Delegate scoped tasks to parallel sub-agents (up to 3 levels deep) with restricted tool sets
Per-Model Routing model_overrides.json with per-model edit formats, context windows, teacher models, summarization models, and sub-agent models
5 Edit Attempts Robust edit retry with fuzzy matching — up from 3 attempts to handle model formatting inconsistencies
🛡️ Safety & Trust
Feature Description
14 Safety Invariants File protection, repetition guard, hooks, Windows sandboxing, donor validation, threat scanning, context fencing, untrusted wrapping, run budget, permission rules, permission modes, telemetry, auto-test, and expanded hooks
Shadow-Git Checkpoints Automatic workspace snapshots before every agent write action — with reflog-expired garbage collection so deleted checkpoints are physically pruned from disk
Orphaned Checkpoint Cleanup Startup scan removes checkpoint directories from abandoned sessions
Edit Review System Accept/reject individual edits with diff previews, per-hunk review, and full undo/redo
Permission System allow / deny / ask lists with Tool(pattern) syntax, persisted to ~/.quanta/permissions.json
3 Permission Modes default (ask for writes), acceptEdits (auto-approve), auto (full autonomy)
Windows Sandbox Restricted Token + DACL + Job Object sandboxing for terminal commands — Windows-first by design
🧠 Self-Learning System (Hermes Parity)
Quanta ports 8 core features from the open-source Hermes Agent and extends them with 19 additional features — 27 self-learning features total.

Feature Description

1 Persistent Memory Frozen snapshot at session start, threat-scanned, drift-detected, mid-session writes
2 FTS5 Cross-Session Search Full-text search across all past sessions with Porter tokenizer and snippet excerpts
3 Autonomous Skill Creation 6 actions: create, edit, patch, delete, write_file, remove_file — with /learn command
4 Skill Curator Inactivity-triggered, archive-only, opt-in LLM consolidation with pre-run tarball snapshots
5 Repetition Guard Detects pathological verbatim repetition, fail-open for short fragments
6 Run Budget 80% wrap-up notice (latched), 100% hard stop — injected into tool messages to preserve cache
7 Adaptive Backoff Exponential backoff with uniform jitter (xorshift RNG, 5s base, 120s max)
8 Learning Graph UI Force-directed graph visualization of learned skills, memory cards, and connections
9 Memory Write Approval Approval gate when write_approval=true
10 Path-Triggered Skills trigger_paths frontmatter with glob matching on file tools
11 Conditional Rule Globs globs frontmatter on rules files, matched against open files
12 User-Global Rules ~/.quanta/QUANTA.md loaded as user-global rules
13 Microcompaction + Disk Persistence Stub old tool results before LLM summarization; large tool results persisted to disk with 2KB preview + read_file pointer (Claude Code Layer 1 parity)
14 Expanded Hooks 6 events: PreToolUse, PostToolUse, SessionStart, UserPromptSubmit, PreCompact, Stop
15 Permission Rule Learning Persistent allow/deny/ask lists with Tool(pattern) syntax
16 Permission Modes default / acceptEdits / auto via session/set_permission_mode RPC
17 Local Telemetry Local-only event log, disabled by default, no network egress
18 Auto-Test Loop test_cmd field runs after diagnostics pass, feeds failures back to the agent
19 Session Forking Deep-copy messages + checkpoints via session/fork RPC
20 Per-Hunk Edit Review compute_hunks, edit/hunks RPC, accepted_hunks parameter
21 MCP HTTP Transport Streamable-HTTP transport alongside stdio
22 MCP alwaysAllow + Prompts Per-server auto-approval, MCP prompts as slash commands
23 Custom Subagents .md-defined agent definitions with built-in explore type
24 Cache Keepalive Anthropic cache warm during idle, 5-min pings
25 /commit-turn Commit accepted edits with generated message + Co-authored-by trailer
26 Diff-Fenced + Patch Formats DiffFenced for Gemini, Patch V4A for GPT-4.1-class models
27 Web Search Tool DuckDuckGo HTML endpoint, no API key needed
📝 Context & Compaction
Feature Description
Proactive Compaction Triggers at 90% input budget with Zed-parity summarization prompt and 80KB retained user-message budget
Microcompaction Stubs old tool results before LLM summarization — skip summarization entirely if enough tokens are freed
Tool-Result Disk Persistence Large tool outputs (>50KB) are saved to ~/.quanta/tool_results/ with a 2KB in-context preview + file path — the model can read_file the full output on demand. Matches Claude Code's Layer 1 compression pipeline.
Observation Masking Clears old tool results based on age and size, with exemptions for edit and diagnostics tools
Stale Preview Stripping Removes stale preview.new_content from older edit results for the same file path
Circuit Breaker Compaction stops after 3 consecutive failures
🔌 Integrations
Feature Description
Full LSP Integration Diagnostics, go-to-definition, find references, code actions, rename symbol
Tree-Sitter Lint Syntax-level linting for JavaScript, Python, and Rust
MCP Support 14 built-in MCP servers including Jina AI, GitHub, Playwright, Serena, and more
Ollama Integration Auto-detects local models with per-model configuration overrides
HuggingFace Model Browser Search, download, and install GGUF models directly from the editor
MTP / llama.cpp Acceleration Optional speculative decoding via managed llama-server subprocess for supported models
🎨 Editor & UX
Feature Description
Inline Code Completion FIM completions with LRU cache and in-flight cancellation
Voice Support Speech-to-text via Whisper, text-to-speech via Piper
Session Management Create, search (FTS5), export (MD/JSON/PDF), import, and fork conversations
Plan Mode Plan before you build with rendered markdown plans and Implement Plan button
Checkpoint Overlay Visual checkpoint browser with diff previews and restore functionality
Learning Graph Panel Interactive force-directed graph of learned skills and memory connections
Curator Status Panel Curator run reports, rollback UI, and snapshot management
Slash Commands /learn, /curator, /mtp, /commit-turn, and more
Status Bar Indicators MTP status, memory toggle, server status — all at a glance
📊 By the Numbers
Metric Value
Backend source files 116 Rust files
Extension source files 27 TypeScript files
Auxiliary crate files 31 Rust files (Completion, HuggingFace, llmfit-core, Skill)
Total source files 180
RPC methods 107
Agent tools 30+
Library tests 739
E2E learning tests 27
Self-learning features 27
Safety invariants 14
Built-in skills 25+
MCP servers 14
Dead code files 0
⚡ MTP / llama.cpp Acceleration
Multi-Token Prediction (MTP) uses speculative decoding to accelerate local LLM generation. On Windows, Ollama doesn't support MTP (macOS-only via MLX), so Quanta manages a local llama-server subprocess.

Embedded MTP (Qwen3.5/3.6, Hunyuan 3, GLM-5.2): MTP heads included in the GGUF — no separate draft model needed
Separate Draft (Gemma 4): Base GGUF + separate assistant/draft GGUF
Safe fallback: If MTP is enabled but the server isn't healthy, requests fall back to Ollama
Windows Job Objects: Guaranteed child process cleanup on exit
Per-model confi

Assets 3
Loading