Enum Commands 

pub enum Commands {
    AgentClientProtocol {
        target: AgentClientProtocolTarget,
    },
    SessionStore {
        command: SessionStoreCommand,
    },
    Chat,
    Continue,
    Ask {
        prompt: Option<String>,
        output_format: Option<AskOutputFormat>,
    },
    Exec {
        json: bool,
        dry_run: bool,
        events: Option<PathBuf>,
        last_message_file: Option<PathBuf>,
        command: Option<ExecSubcommand>,
        prompt: Option<String>,
    },
    Eval(ExecEvalArgs),
    Schedule {
        command: ScheduleSubcommand,
    },
    BackgroundSubagent(BackgroundSubagentArgs),
    Review(ReviewArgs),
    Schema {
        command: SchemaCommands,
    },
    ChatVerbose,
    Analyze {
        analysis_type: String,
    },
    Trajectory {
        file: Option<PathBuf>,
        top: usize,
    },
    Notify {
        title: Option<String>,
        message: String,
    },
    Benchmark {
        task_file: Option<PathBuf>,
        task: Option<String>,
        output: Option<PathBuf>,
        max_tasks: Option<usize>,
    },
    BenchAllocator(BenchAllocatorArgs),
    CreateProject {
        name: String,
        features: Vec<String>,
    },
    Revert {
        turn: usize,
        partial: Option<String>,
    },
    Snapshots,
    CleanupSnapshots {
        max: usize,
    },
    Init {
        force: bool,
    },
    InitProject {
        name: Option<String>,
        force: bool,
        migrate: bool,
    },
    Config {
        command: Option<ConfigCommand>,
        output: Option<PathBuf>,
        global: bool,
    },
    Login {
        provider: String,
        device_code: bool,
        from_codex: bool,
    },
    Logout {
        provider: String,
    },
    Auth {
        provider: Option<String>,
    },
    ToolPolicy {
        command: ToolPolicyCommands,
    },
    Mcp {
        command: McpCommands,
    },
    A2a {
        command: A2aCommands,
    },
    Webmcp {
        command: WebmcpCommand,
    },
    AppServer {
        listen: String,
    },
    Models {
        command: ModelCommands,
    },
    Pods {
        command: PodsCommands,
    },
    Man {
        command: Option<String>,
        output: Option<PathBuf>,
    },
    Skills(SkillsSubcommand),
    Plugins(PluginsSubcommand),
    ListSkills {},
    Dependencies(DependenciesSubcommand),
    Secret(SecretArgs),
    Check {
        command: CheckSubcommand,
    },
    Update {
        check: bool,
        force: bool,
        list: bool,
        limit: usize,
        pin: Option<String>,
        unpin: bool,
        channel: Option<String>,
        show_config: bool,
    },
    AnthropicApi {
        port: u16,
        host: String,
    },
}

Variants

AgentClientProtocol

Start Agent Client Protocol bridge for IDE integrations

Fields

target: AgentClientProtocolTarget

Client to connect over ACP

SessionStore

Unified per-session state store (single source of truth for state, context, and history). Consolidates the legacy checkpoints/, logs/, and history/ stores.

Fields

command: SessionStoreCommand

Chat

Interactive AI coding assistant

Continue

Resume the most recent conversation automatically

Equivalent to vtcode --continue. Loads the latest archived session in the current workspace (or across all workspaces with --all) and resumes it without showing the interactive picker.

Examples: vtcode continue vtcode continue –all vtcode continue –session-id my-fork # fork latest into a new session

Ask

Single prompt mode - prints model reply without tools

Send a single prompt to the model and print the response. No tools are invoked, no session is created, and the process exits after replying.

Examples: vtcode ask “what is a monad?” echo “summarize this” | vtcode ask vtcode ask –output-format json “explain ownership in Rust”

Fields

prompt: Option<String>

Prompt to ask. Use - to force reading from stdin.

output_format: Option<AskOutputFormat>

Format the response using a structured representation.

Exec

Headless execution mode

Run the agent in non-interactive mode. The agent executes the prompt, runs tools, and exits when done. Ideal for CI/CD, scripting, and agent-to-agent workflows.

Examples: vtcode exec “explain this codebase” vtcode exec –json “fix the failing test” vtcode exec –dry-run “refactor auth module” cat file.rs | vtcode exec “review this code” vtcode exec resume –last

Fields

json: bool

Emit structured JSON events to stdout (one per line)

dry_run: bool

Run a read-only dry-run execution (blocks mutating tool calls)

events: Option<PathBuf>

Optional path to write the JSONL transcript

last_message_file: Option<PathBuf>

Write the last agent message to this file

command: Option<ExecSubcommand>

Optional exec subcommand

prompt: Option<String>

Prompt to execute. Use - to force reading from stdin.

Eval(ExecEvalArgs)

Run an evaluation suite (shorthand for vtcode exec eval)

Executes each task in the suite autonomously in an isolated worktree, verifies the outcome with environment probes, and aggregates pass@k / pass^k metrics into a markdown or JSON report.

Examples: vtcode eval –suite suite.json vtcode eval –suite suite.json –format json –output report.json

Schedule

Manage durable scheduled tasks

Create, list, and delete scheduled tasks that run on a recurring or one-shot basis. Tasks are stored persistently and survive restarts when paired with vtcode schedule install-service.

Examples: vtcode schedule create –name “daily-review” –cron “0 9 * * 1-5” –prompt “review recent changes” vtcode schedule create –name “reminder” –reminder “standup in 10 minutes” –at “09:50” vtcode schedule list vtcode schedule delete <task-id>

Fields

command: ScheduleSubcommand

BackgroundSubagent(BackgroundSubagentArgs)

Internal VT Code background subagent runner

Review(ReviewArgs)

Headless code review for the current diff, selected files, or a custom git target

Schema

Runtime schema introspection for built-in tools

Fields

command: SchemaCommands

ChatVerbose

Verbose interactive chat with debug output

Analyze

Analyze workspace (structure, security, performance)

Fields

analysis_type: String

Type of analysis to perform

Trajectory

Pretty-print trajectory logs

Fields

file: Option<PathBuf>

Optional path to trajectory JSONL file

top: usize

Number of top entries to show

Notify

Send a VT Code notification using the built-in notification system

Fields

title: Option<String>

Optional notification title

message: String

Notification message

Benchmark

Benchmark against SWE-bench evaluation framework

Fields

task_file: Option<PathBuf>

Path to a JSON benchmark specification

task: Option<String>

Inline JSON specification for quick experiments

output: Option<PathBuf>

Optional path to write the structured benchmark report

max_tasks: Option<usize>

Limit the number of tasks executed

BenchAllocator(BenchAllocatorArgs)

Measure allocator RSS behavior under a bursty/sparse Tokio workload

Reproduces the mimalloc-vs-jemalloc analysis pattern: many short-lived tasks allocated across Tokio worker threads, with idle gaps between bursts. Reports the RSS trajectory so you can see whether the global allocator returns memory to the OS (jemalloc) or pins it (mimalloc/glibc). Build with --features allocator-jemalloc to compare allocators.

CreateProject

Create complete Rust project

Fields

name: String

features: Vec<String>

Revert

Revert agent to a previous snapshot

Fields

turn: usize

Turn number to revert to

partial: Option<String>

Scope of revert operation: conversation, code, full

Snapshots

List all available snapshots

CleanupSnapshots

Clean up old snapshots

Features: • Remove snapshots beyond limit • Configurable retention policy • Safe deletion with confirmation

Examples: vtcode cleanup-snapshots vtcode cleanup-snapshots –max 20

Fields

max: usize

Maximum number of snapshots to keep

Default: 50 Example: –max 20

Init

Initialize project guidance and workspace scaffolding

Bootstrap a workspace for use with VT Code. Creates vtcode.toml, AGENTS.md, and other scaffolding. Run this once per project.

Examples: vtcode init vtcode init –force

Fields

force: bool

Overwrite an existing AGENTS.md without prompting

InitProject

Initialize project in the user state directory’s projects/ path.

Create a new project entry in the VT Code projects directory. This is separate from vtcode init which bootstraps a workspace.

Examples: vtcode init-project vtcode init-project –name my-project vtcode init-project –force –migrate

Fields

name: Option<String>

Project name - defaults to current directory name

force: bool

Force initialization - overwrite existing project structure

migrate: bool

Migrate existing files - move existing config/cache files to new structure

Config

Generate or manage configuration files

Create a vtcode.toml configuration file with default settings, or use reset to clear one configuration layer. Use –global to create in the canonical user config directory or specify an output path.

Examples: vtcode config vtcode config –global vtcode config –output ./my-vtcode.toml vtcode config reset vtcode config reset –global vtcode config reset –project

Fields

command: Option<ConfigCommand>

output: Option<PathBuf>

Output file path

global: bool

Create in the canonical user config directory.

Login

Authenticate with a supported provider

Start an OAuth or API-key login flow for the given provider. Credentials are stored securely in the OS keychain.

Examples: vtcode login openai vtcode login openai –from-codex vtcode login openrouter vtcode login codex vtcode login codex –device-code

Fields

provider: String

Provider name (openai, openrouter, copilot, or codex)

device_code: bool

Use device-code login when the provider supports it (currently codex only)

from_codex: bool

Import ChatGPT credentials from Codex’s ~/.codex/auth.json instead of running the browser OAuth flow (currently openai only)

Logout

Clear stored authentication credentials for a provider

Remove stored OAuth tokens or API keys for the given provider.

Examples: vtcode logout openai vtcode logout openrouter

Fields

provider: String

Provider name (openai, openrouter, copilot, or codex)

Auth

Show authentication status for one provider or all supported providers

Display whether each provider is authenticated, which credential type is in use, and token/session metadata when available.

Examples: vtcode auth vtcode auth openai vtcode auth openrouter

Fields

provider: Option<String>

Optional provider name (openai, openrouter, copilot, or codex)

ToolPolicy

Manage tool execution policies

Fields

command: ToolPolicyCommands

Mcp

Manage Model Context Protocol providers

Fields

command: McpCommands

A2a

Agent2Agent (A2A) Protocol

Fields

command: A2aCommands

Webmcp

Authenticated browser editor bridge

Fields

command: WebmcpCommand

AppServer

Proxy to the official Codex app-server

Fields

listen: String

Transport listen target passed through to codex app-server

Models

Manage models and providers

Fields

command: ModelCommands

Pods

Manage GPU pod deployments

Fields

command: PodsCommands

Man

Generate or display man pages

Fields

command: Option<String>

Command name to generate man page for (optional)

output: Option<PathBuf>

Output file path to save man page

Skills(SkillsSubcommand)

Manage Agent Skills

Skills are reusable instruction sets that extend the agent’s capabilities. Each skill is a directory containing a SKILL.md manifest and optional scripts.

Examples: vtcode skills list vtcode skills create my-skill vtcode skills load my-skill vtcode skills info my-skill vtcode skills validate ./path/to/skill

Plugins(PluginsSubcommand)

Manage Agent Plugins

Agent Plugins are portable packages that bundle Agent Skills and MCP servers under a root plugin.json manifest, following the Agent Plugins spec.

Examples: vtcode plugins list vtcode plugins info my-plugin vtcode plugins validate ./path/to/plugin vtcode plugins add https://github.com/example/plugin vtcode plugins remove my-plugin

ListSkills

List available skills (alias for vtcode skills list)

Dependencies(DependenciesSubcommand)

Manage optional VT Code dependencies

Install, update, or check the status of optional tools that VT Code can use (ripgrep, ast-grep, search-tools bundle).

Examples: vtcode dependencies status vtcode dependencies install search-tools vtcode deps install ripgrep

Secret(SecretArgs)

Manage API keys in secure storage (OS keyring or encrypted file)

Store, inspect, and delete provider API keys without exposing them in shell history or workspace files.

Examples: vtcode secret vtcode secret list vtcode secret status openai vtcode secret add openai vtcode secret delete openai

Check

Run built-in repository checks

Execute repository-level checks such as ast-grep rule tests and scans.

Examples: vtcode check ast-grep

Fields

command: CheckSubcommand

Update

Check for and install binary updates from GitHub Releases

Manage VT Code binary updates. By default checks for a new version and offers to install it. Use flags to customize behavior.

Examples: vtcode update vtcode update –check vtcode update –force vtcode update –list vtcode update –pin 0.120.0 vtcode update –unpin

Fields

check: bool

Check for updates without installing

force: bool

Force update even if on latest version

list: bool

List available versions

limit: usize

Number of versions to list (default: 10)

pin: Option<String>

Pin to a specific version

unpin: bool

Unpin version

channel: Option<String>

Set release channel (stable, beta, nightly)

show_config: bool

Show current update configuration

AnthropicApi

Start Anthropic API compatibility server

Fields

port: u16

Port to run the server on

host: String

Host address to bind to

Trait Implementations

impl Clone for Commands

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Commands

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Commands

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Commands

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand