vtcode 0.123.2

Quick start

Launch VT Code in any project directory to start an interactive session:

vtcode

Common commands

# Ask a quick question (no tools, prints reply to stdout)
vtcode ask "explain the difference between Rc and Arc in Rust"

# Run a headless task with full tool access (file edits, search, terminal)
vtcode exec "refactor src/main.rs to use clap for CLI parsing"

# Review uncommitted changes before committing
vtcode review

# Review a specific commit range
vtcode review --target HEAD~3..HEAD

# Continue the most recent session
vtcode --resume

# List available models and their status
vtcode models list

# Switch the default provider and model
vtcode models set-provider openai
vtcode models set-model gpt-5

# Update vtcode to the latest release
vtcode update

Real-world workflows

# Generate and save a code snippet
vtcode ask "write a Rust function that reads a file and counts word frequencies" > word_count.rs

# Summarize what changed on the current branch
vtcode exec "summarize all changes between main and HEAD, grouped by file"

# Security-focused review of staged changes
vtcode review --style security

# Run a task from stdin (useful in pipelines)
cat error.log | vtcode exec "analyze this log and suggest fixes"

# Explore workspace structure
vtcode analyze

# Manage agent skills
vtcode skills list

Interactive TUI

Launch vtcode with no arguments to enter the interactive terminal UI. Type / inside a session to see all available slash commands.

Session modes

/mode edit     # agent can read and write files (default)
/mode auto     # autonomous mode, minimal confirmations
/mode plan     # read-only research mode, no file changes
/mode          # cycle through modes

Working with models

/model                        # open interactive model picker
/effort high                  # set reasoning effort (low, medium, high)

Session management

/resume                       # pick a previous session to continue
/fork                         # branch the current conversation
/history                      # browse past sessions
/clear                        # clear the screen
/clear new                    # start a fresh conversation
/compact                      # compress context to free tokens
/compact --reasoning-effort high --verbosity concise
/rewind                       # undo recent turns
/copy                         # copy the last assistant reply to clipboard
/share                        # export session as JSON, Markdown, or HTML

Code review and analysis inside TUI

/review                       # review uncommitted changes
/review --last-diff           # review the last commit
/review --style security      # security-focused review
/analyze                      # full workspace analysis
/analyze security             # security scan only

Workspace setup

/init                         # guided setup: vtcode.toml, AGENTS.md, indexing
/config                       # browse current settings
/config memory                # inspect memory and loaded rules
/config model                 # view or change model config

MCP and integrations

/mcp                          # show MCP connection status
/mcp list                     # list configured MCP providers
/mcp tools                    # show tools exposed by active providers
/mcp refresh                  # reindex MCP tools without restarting
/mcp repair                   # restart MCP connections

Skills and agents

/skills list                  # list available agent skills
/skills load <name>           # load a skill into the session
/agents list                  # list configured subagents
/agents create                # create a new agent definition

Automation

/loop 5m check the deployment # repeat a prompt every 5 minutes
/schedule                     # open the task scheduler UI
/schedule list                # browse scheduled tasks

Theming and terminal

/theme                        # open the theme picker
/theme ciapre                # switch to a specific theme
/doctor                       # run diagnostics
/help                         # list all slash commands
/help review                  # show help for a specific command

Autonomous agent

VT Code can run as an autonomous agent that plans, executes, and verifies work without waiting for human approval on each step.

Interactive auto mode

Inside the TUI, switch to auto mode to let the agent proceed through tool calls with minimal interruptions:

/mode auto      # autonomous mode, minimal confirmations
/mode edit      # switch back to interactive edit mode

Full-auto CLI mode

For headless or CI workflows, --full-auto skips all permission prompts and executes against a configurable tool allow-list:

vtcode exec --full-auto "migrate the test suite from jest to vitest"

Full-auto requires explicit opt-in via vtcode.toml:

[automation.full_auto]
enabled = true
require_profile_ack = true
profile_path = "automation/full_auto_profile.toml"
allowed_tools = [
    "read_file",
    "list_files",
    "grep_file",
    "run_pty_cmd",
]

Tools not in the allow-list are rejected automatically. Setting allowed_tools = ["*"] permits every tool, but is only safe in isolated workspaces.

Orchestrated harness

For longer autonomous builds, enable the plan-build-evaluate harness. The agent writes working artifacts under .vtcode/tasks/ (spec, contract, tracker, evaluation) so that multi-round revision is explicit and resumable:

[agent.harness]
orchestration_mode = "plan_build_evaluate"
max_revision_rounds = 2

vtcode exec --full-auto "implement the payment service with tests and docs"

Subagents and background workers

VT Code delegates bounded work to child agent threads with isolated context and tool restrictions. Built-in agents include explorer (read-only search), plan (read-only planning), and worker (bounded implementation). Background subagents can run as managed child processes for long-running or parallel tasks.

Scheduled automation

Durable scheduled tasks run on cron or interval schedules without an active session:

vtcode schedule                          # manage tasks interactively
vtcode schedule create --cron "0 9 * * 1" --prompt "review open PRs"

Inside the TUI, /loop repeats a prompt on an interval within the current session, and /schedule opens the task manager.

Read the full guide: Full-Auto Mode

Features

Installation

macOS and Linux

curl -fsSL https://raw.githubusercontent.com/vinhnx/vtcode/main/scripts/install.sh | bash

Skip optional search tools:

curl -fsSL https://raw.githubusercontent.com/vinhnx/vtcode/main/scripts/install.sh | bash -s -- --without-search-tools

Windows PowerShell

irm https://raw.githubusercontent.com/vinhnx/vtcode/main/scripts/install.ps1 | iex

[!NOTE] Windows release artifacts are best-effort and may lag behind macOS/Linux builds.

Package managers

cargo install vtcode
brew install vtcode

# Development tap
brew tap vinhnx/tap
brew install vinhnx/tap/vtcode

[!TIP] Official macOS/Linux release archives include ghostty-vt/ runtime libraries for richer PTY snapshots. Custom installs continue to work with the built-in legacy_vt100 backend.

More details: Installation Guide, Native Installer Guide, Ghostty VT Packaging.

Providers

VT Code supports 21 LLM providers out of the box — from cloud APIs to local inference servers — plus any OpenAI-compatible API through [[custom_providers]].

For detailed setup guides, see Provider Guides.

Provider spotlight: Xiaomi MiMo V2.5 Series

VT Code is happy to be part of the Xiaomi MiMo Orbit Program

Xiaomi's MiMo V2.5 Pro is the default model in VT Code — available as the native MiMo provider and through OpenRouter. It delivers strong performance in agentic capabilities, complex software engineering, and long-horizon tasks with a 1M context window and deep reasoning.

Pricing: Pay-as-you-go · Subscription · Quick Access

Read: Xiaomi MiMo documentation | OpenRouter models.

Atlas Cloud

Atlas Cloud is an LLM provider accessible through VT Code's [[custom_providers]] support — no dedicated runtime provider needed.

[agent]
provider = "atlascloud"
default_model = "deepseek-ai/DeepSeek-V3-0324"

[[custom_providers]]
name = "atlascloud"
display_name = "Atlas Cloud"
base_url = "https://api.atlascloud.ai/v1"
api_key_env = "ATLASCLOUD_API_KEY"
model = "deepseek-ai/DeepSeek-V3-0324"

Other custom OpenAI-compatible providers use the same [[custom_providers]] pattern.

Configuration

VT Code reads configuration from vtcode.toml in your project root. The default agent uses the MiMo provider with mimo-v2.5-pro as the default model.

[agent]
provider = "openai"
default_model = "gpt5.5"

Useful configuration docs:

• Configuration Precedence
• Config Field Reference
• Tool Configuration
• Lifecycle Hooks

Extension points

Skills

VT Code discovers repository, user, admin, and bundled system skills using the open Agent Skills SKILL.md format.

vtcode skills list
vtcode skills info my-skill
vtcode skills create my-skill
vtcode skills validate ./.agents/skills/my-skill

Read: Agent Skills Guide.

MCP

VT Code ships as both an MCP client and server:

• Client: connect to any MCP server for tools like Figma, Playwright, Sentry, and more.
• Server: expose VT Code tools to external agents and editors.

Read: MCP Integration.

Agents and editors

• Zed: native ACP support with project-wide indexing.
• VS Code / Copilot: use the vtcode ask CLI or background agent mode.
• Claude Code: VT Code can operate as a subagent under claude.

Read: Zed ACP Guide, VS Code Guide, Claude Code Guide.

Safety model

VT Code runs a read-restricted shell. Every command passes through a sandbox that can block dangerous operations, log activity, and enforce policy.

Read: Safety Architecture, Security Hardening, Threat Model.

Protocols and exports

Development

git clone https://github.com/vinhnx/vtcode.git
cd vtcode
./scripts/run-debug.sh

VT Code uses Rust stable, edition 2024, and MSRV 1.88. The dev profile disables incremental compilation (sccache). Set CARGO_INCREMENTAL=1 to override.

Local checks:

./scripts/check-dev.sh             # fast gate (clippy, fmt, check)
./scripts/check-dev.sh --test      # + unit and integration tests
./scripts/check-dev.sh --workspace # + all workspace crates
./scripts/check-dev.sh --lints     # + additional lints

Running tests:

cargo nextest run                   # parallel runner (preferred)
cargo nextest run -p vtcode-core    # single crate
cargo nextest run test_name         # single test by name

Launching VT Code:

./scripts/run-debug.sh   # debug build + launch
./scripts/run.sh         # release build + launch

Both auto-bootstrap the Ghostty VT runtime. Without it, PTY snapshots fall back to legacy_vt100.

Read: Development Setup, Testing, CI/CD.

Contributing

Contributions are welcome -- typos, docs, bugs, code, ideas. Start with open issues or good first issues. For AI agents, read AGENTS.md first. Humans should also read CONTRIBUTING.md.

Support

VT Code is built in my spare time and shared freely with the community. If it helps you ship code, learn, experiment with agents, or save a few hours, a small donation helps me keep improving it.

Sponsor

Current sponsors

Thank you to the sponsors who support ongoing development:

Star History

If you find VT Code useful, please consider starring the repository. It helps more developers discover the project and gives the community a visible signal that the work is valuable.

License

This repository is licensed under the MIT License.