VT Code

An open-source terminal coding agent built in Rust.

Plan, run, and review coding work from your terminal, with hosted or local models, sandboxed execution, and resumable sessions.

Explore a codebase, plan changes, run tools, and review edits in the interactive TUI, or run vtcode exec headless. Pick your model and set your permissions; the runtime handles context management, tools, and execution policy.

The sections below follow that arc: install, configure, run a first task, then go deeper.

Requirements: macOS, Linux, or Windows/WSL. The Cargo path also needs Rust 1.98.1+ (edition 2024).

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

The installer also sets up ripgrep and ast-grep on macOS/Linux. Or use Homebrew or Cargo:

brew trust vinhnx/tap
brew install vinhnx/tap/vtcode

# Or install with Rust (requires Rust 1.98.1+)
cargo install vtcode

Verify the install with vtcode --version, then see the installation guide for prerequisites, other methods, and the installer script to review before running.

In your project, initialize configuration and instructions, then add provider credentials. For example, with OpenAI:

cd path/to/your/project
vtcode init                # scaffolds config + AGENTS.md; review before committing
vtcode secret add openai   # stores an OpenAI API key in your OS keyring

Replace openai with your provider. Credentials can also come from environment variables or a workspace .env; vtcode login handles supported login flows. See Getting started and Provider guides.

vtcode   # open the interactive TUI in your project

Start with a focused request, such as "Explain how this project handles authentication," then review the diff and test results before committing. See Usage for automation and session commands, or getting started for a guided tour.

Use vtcode to explore, plan, and implement changes in the TUI. For larger tasks, start with read-only planning, then review turn diffs before committing. See the interactive guide for controls.

After a task, /explain reviews outcome, changes, decisions, verification, and review priorities without another model call:

• /explain --details adds evidence.
• /explain diagram shows execution relationships.
• /explain --web opens the browser view with an offline fallback.
• /explain --export html saves a standalone report.

Scopes and report options: explanation usage.

Run tasks without the TUI: ask for a tool-free answer, exec for a tool-enabled coding task, and review for uncommitted changes:

vtcode ask "explain Rc vs Arc"    # one-shot answer, no session, no tools
vtcode exec "refactor main.rs"    # headless task with the full tool loop
vtcode review                     # agent review of uncommitted changes

exec requires [automation.full_auto] plus full_auto workspace trust. Terminals prompt for trust; non-TTY runs fail unless VTCODE_TRUST_WORKSPACE=full-auto is set. The tool allow-list, explicit denies, and execution policy still apply. See exec mode and full automation for trust, output, and configuration details.

For repeatable, environment-checked results, use the eval framework. A completion message alone is not verification.

For recurring work, use scheduled tasks: durable prompt jobs on the same exec runtime.

# Weekly dependency audit (Mondays 09:00)
vtcode schedule create --name "weekly-dep-audit" \
  --cron "0 9 * * 1" \
  --prompt "Check for outdated dependencies and report known vulnerabilities"

Resume or inspect earlier work from the same commands:

# Resume the most recent interactive session
vtcode continue

# Continue the last headless run with a follow-up prompt
vtcode exec resume --last "continue the refactor"

# Inspect the execution log
vtcode trajectory

Use vtcode continue --session-id <id> to fork an earlier session.

Enable these only when you need them; none are required for the quick start.

Guides by task; the full catalog lives in the documentation index, the docs overview, and the Wiki:

graph LR
    BIN[vtcode binary] --> CORE[vtcode-core harness]
    BIN --> EVAL[vtcode-eval]
    CORE --> LLM[vtcode-llm]
    CORE --> SAFETY[vtcode-safety]
    CORE --> EVENTS[vtcode-exec-events]
    CORE --> CONFIG[vtcode-config]
    CORE --> MEMORY[vtcode-memory]
    CORE --> UI[vtcode-ui]

The full 23-crate map lives in the architecture guide. Building requires Rust 1.98.1+ (edition 2024); tests need cargo-nextest:

git clone https://github.com/vinhnx/VTCode.git
cd VTCode
./scripts/run-debug.sh     # build and launch a debug binary
./scripts/check-dev.sh     # fast gate: clippy, fmt, check
cargo nextest run          # tests (requires cargo-nextest)

CI sets RUSTFLAGS="-D warnings" and builds with --locked; match locally with RUSTFLAGS="-D warnings" cargo check --locked. Setup and checks: development overview and the testing guide.

Release binaries and notes: GitHub releases.

Contributions are welcome in every form:

• Code: pick or propose an issue; keep changes surgical and tested.
• Docs: every user-facing feature lands with its documentation.
• Evals: new suites and regression cases are high-leverage; see the eval guide.
• Bug reports: include vtcode trajectory output when possible.

Before a PR, see the contribution guide: Conventional Commits (type(scope): subject), ./scripts/check-dev.sh + cargo nextest run, and a focused diff.

Report vulnerabilities privately via GitHub private vulnerability reporting; never open a public issue. Details: security policy.

Thanks to everyone who builds, tests, and improves VT Code. For partnerships and collaboration, reach the maintainer at vinhnguyen2308 [at] gmail [dot] com; bugs and feature requests belong in GitHub Issues.

Want to see your avatar here? Every bit counts: one-line fixes, bug reports, and feedback are all welcome.

Report a bug · Request a feature · Share feedback · Star the repo · Contribute

• Building VT Code, a year in: harness design, evals, security, and lessons learned.
• Podcast · Video

If VT Code helped you ship something, telling other developers is the easiest way to support it:

Share on X · Share on Hacker News · Share on LinkedIn · Share via Email · Share via SMS

VT Code is maintained in spare time; a sponsorship keeps it independent.

First-party code is MIT OR Apache-2.0 under LICENSE. Third-party code keeps its original licenses, listed in THIRD-PARTY-NOTICES.