Vix

Introduction

What if you could cut your AI coding agent's token bill in half without switching models?

Vix is a Go-native coding agent that answers that question with architecture, not gimmicks. Instead of bolting on a caching layer or asking you to use cheaper models, Vix rethinks how coding agents interact with LLMs in the first place. It delivers a terminal-based agent that claims 40–50% lower token costs than traditional coding agents — backed by benchmark data against Claude Code across real coding scenarios.

Written in Go and released under AGPL-3.0, Vix is built by Vix Labs — currently at v0.5.0 (released June 14, 2026) with 31 releases and 107 commits since launching in April 2026. It ships a stem agent architecture that keeps LLM prompt cache warm across planning and execution phases, a Tree-sitter virtual filesystem that reads minified code at 20–50% fewer tokens, Programmable Workflows in JSON, a Whiteboard Mode with voice AI, and a self-evolving agent that writes its own scheduled jobs.

This isn't yet another Claude Code wrapper. Vix makes fundamentally different architectural choices about how a coding agent should use an LLM.

Why Token Efficiency Matters

Every call to an LLM costs money and time. For coding agents, the cost compounds fast:

• Exploration — reading files to understand the codebase
• Planning — formulating a strategy for changes
• Execution — writing and editing code
• Review — checking the output

Traditional agents treat each phase as a separate agent with its own system prompt. That means every phase starts cold — no shared cache, no accumulated context. Claude Code, for example, spawns separate Explore, Plan, and Execute agents with different system prompts, making it impossible to reuse the prompt cache between phases.

The numbers add up. In Vix's own benchmarks across 7 real coding tasks (starting a project from scratch, fixing a bug in serde-json, adding features to large codebases, writing test suites, refactoring):

Both agents used the same model (Claude Opus 4.6) and the same prompts. The difference is architectural.

Stem Agent Architecture

Vix's core innovation is the stem agent — a single generic agent that handles all phases of a coding task within one conversation.

Instead of spawning a new agent with a specialized system prompt for each phase (Explore → Plan → Execute), Vix creates one agent with a generic system prompt. The agent is told upfront that multiple phases are coming. Each phase is described in a user message, not a system prompt. When Explore is done, Vix sends another user message: "Now act as a planner."

The same prompt cache stays warm across all phases. When Vix moves from Explore to Plan, the LLM already has the full exploration context cached.

The key insight: phase instructions delivered as user messages instead of system prompts. A system prompt carries more weight in most LLMs, so this approach might affect response quality. Vix's benchmarks show no measurable quality difference, and the cost savings are substantial.

What changes:

1. No cold start between phases — the LLM already has the codebase context in its cache
2. No redundant exploration — Claude Code spawns up to 3 Explore agents that sometimes read the same files; Vix's single agent explores just once
3. Phase switching is instant — no agent spawning overhead, just a user message telling the LLM to switch roles

The stem agent pattern is inspired by the MAKER approach, which Vix's documentation cites as a key influence.

Tree-sitter Virtual Filesystem

Reading source code is one of the most expensive operations in any coding agent — especially during the Explore phase when the LLM needs to build a mental model of the codebase.

Vix's approach: minify the code before sending it to the LLM. Instead of feeding full source with whitespace, indentation, and blank lines, Vix uses a Tree-sitter-based virtual filesystem that strips all non-semantic whitespace (\s+ characters) while preserving every meaningful token.

The result is a 20–50% token reduction on file reads — the LLM sees the same code, same logic, same structure, just without the formatting overhead. Benchmarks confirm no measurable loss in code understanding.

This isn't a novel insight — minification is an old web optimization trick — but applying it at the VFS layer of a coding agent is. The VFS is transparent: the LLM reads and edits in the minified world, while Vix maps everything back to real file positions on disk.

The remaining edge case: very long files (3,000+ lines) where minification happens only during exploration but falls back to regular read/edit tools during execution. Vix's README acknowledges this and says a fix is coming.

20–50% fewer tokens on file reads — zero semantic loss.

Programmable Workflows

Vix lets you define multi-phase agent pipelines in JSON — stored in settings.json — that orchestrate agent actions, bash commands, and tool calls with templating, branching, parallelism, and history forking.

A workflow can:

• Run agent steps — prompt the LLM in a specific phase context
• Execute bash commands — run tests, linters, or deployment scripts between phases
• Branch on conditions — fork the workflow based on LLM output or command results
• Parallelize steps — run multiple actions simultaneously
• Fork history — create divergent session histories for A/B testing different approaches

Workflows also support budgets, signals, and error routing — if a step exceeds a cost or time budget, the workflow can route to a fallback or abort cleanly. Resumable runs mean you can restart a workflow from where it left off after a crash.

Vix becomes a programmable automation engine, not just a chat-based agent. You can encode your team's entire development workflow — analysis → planning → implementation → testing → review — as a single Vix workflow.

Whiteboard Mode

Not every planning session belongs in a terminal. Vix's Whiteboard Mode opens a visual canvas where the agent presents its plan with diagrams, flowcharts, and structured layouts.

The mode includes voice AI walkthroughs — the agent talks through its plan while you look at the visual representation. You can challenge specific decisions, ask for alternatives, or redirect the approach — all without typing commands.

This is Vix's answer to the "blank terminal" problem: when you're not sure what to ask next, Whiteboard Mode lets the agent show its thinking visually and verbally. Complex multi-file refactoring where a text-based plan would be hard to follow — that's where this mode earns its keep.

Self-Evolving Agent

One of Vix's more unusual features: the agent can write its own scheduled jobs, watchers, and alerts.

Tell Vix "run tests every hour and alert me if they fail," and it will write the cron-style job, configure the watcher, and set up the alert — all as part of its own runtime state. The scheduled jobs engine (added in v0.5.0) persists jobs to disk and restores them on daemon restart, so your automation outlives individual sessions.

This crosses into meta-agent territory: Vix writing configurations that control Vix's own behaviour over time. It's the tool sharpening itself.

Getting Started

Vix requires a Go runtime and an Anthropic API key (or another supported provider key).

curl -fsSL https://getvix.dev/install.sh | bash

# Or via Homebrew
brew tap get-vix/vix
brew install vix

Start the daemon (required for session persistence and background jobs):

vixd

Then launch the TUI:

vix

Basic Workflow

Vix supports multiple workflow modes. The most common flow:

1. vix plan — Explore the codebase and produce a plan. The stem agent reads your project, identifies relevant files (using the Tree-sitter VFS for token-efficient scanning), and formulates a strategy.
2. Review the plan — Vix presents the plan in the TUI or Whiteboard Mode. Challenge it, ask for changes, or approve.
3. vix run — Execute the approved plan. The stem agent switches to execution mode with the Explore cache still warm — no re-reading files.
4. vix init — Bootstrap a new project with Vix-friendly configuration.

You can also launch the TUI directly with vix and type requests conversationally, similar to Claude Code's interactive mode.

Switching Providers

# Use a different model per session
vix --model claude-sonnet-4-2026

# Or switch inside the TUI
# Tab to Settings → Model Picker → Select provider

Vix supports Anthropic, OpenAI, OpenRouter, Amazon Bedrock, Ollama, and llama.cpp. Provider credentials can be stored via the OAuth/PKCE authentication subsystem or environment variables.

Roadmap & Community

At v0.5.0, Vix is early-stage — 209 GitHub stars, 19 forks, and 107 commits across 31 releases. The development cadence is aggressive (in June 2026, Vix shipped 15+ releases in 14 days), but the community is still forming.

The project roadmap lists:

• Evaluation on Terminal-bench 2.0
• Cron task implementation (beyond the current scheduled jobs engine)
• Full "project brain" to reduce exploration cost and time
• Better handling of long files in the Tree-sitter VFS
• Windows support

The Discord community is active but small. The GitHub issues (7 open) suggest a focused team addressing bugs and feature requests in real time.

Conclusion

Who is Vix for? Developers who are spending serious money on Claude Code, Cursor, or GitHub Copilot and want to cut costs without switching models. The stem agent architecture is a clever approach to token efficiency — not a hack, but a fundamental redesign of how coding agents interact with LLMs.

The Tree-sitter virtual filesystem, programmable workflows, and Whiteboard Mode are substantial features that already work. The self-evolving agent is a taste of where Vix is heading rather than a production-ready feature, but the trajectory is interesting.

Verdict: Vix is the most architecturally innovative coding agent I've seen at this price point (free, open source, BYO API keys). It's early — 209 stars, no Windows support, documentation still maturing — but the architecture is sound and the benchmarks are credible. If you're burning through API credits on Claude Code and want to see what a token-first redesign looks like, curl -fsSL https://getvix.dev/install.sh | bash is worth the 30 seconds.

Skip Vix if you need Windows support, a large community, commercial-friendly licensing (AGPL-3.0), or a polished IDE plugin. Watch it if you care about where coding agent architecture is heading — because the stem agent pattern is likely to show up in every major agent within the next year.

Further Reading

• Vix GitHub Repository — Source code, issues, releases, and benchmarks
• Vix Documentation — Official docs for installation, configuration, and workflows
• Vix Benchmarks — Reproducible evaluation suite comparing Vix vs Claude Code
• MAKER Paper (arxiv.org) — The paper that inspired Vix's stem agent and workflow architecture
• Vix Discord — Community discussions and support
• Vix Releases — Changelog and download links for all versions