Enum Commands 

pub enum Commands {
    AgentClientProtocol {
        target: AgentClientProtocolTarget,
    },
    Chat,
    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>,
    },
    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>,
    },
    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 {
        output: Option<PathBuf>,
        global: bool,
    },
    Login {
        provider: String,
        device_code: bool,
    },
    Logout {
        provider: String,
    },
    Auth {
        provider: Option<String>,
    },
    ToolPolicy {
        command: ToolPolicyCommands,
    },
    Mcp {
        command: McpCommands,
    },
    A2a {
        command: A2aCommands,
    },
    AppServer {
        listen: String,
    },
    Models {
        command: ModelCommands,
    },
    Pods {
        command: PodsCommands,
    },
    Man {
        command: Option<String>,
        output: Option<PathBuf>,
    },
    Skills(SkillsSubcommand),
    ListSkills {},
    Dependencies(DependenciesSubcommand),
    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,
    },
}

Available commands

Variants

AgentClientProtocol

Start Agent Client Protocol bridge for IDE integrations

Fields

target: AgentClientProtocolTarget

Client to connect over ACP

Chat

Interactive AI coding assistant

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 in read-only dry-run mode (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.

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

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

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 ~/.vtcode/projects/

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 configuration file

Create a vtcode.toml configuration file with default settings. Use –global to create in ~/.vtcode/ or specify an output path.

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

Fields

output: Option<PathBuf>

Output file path

global: bool

Create in user home directory (~/.vtcode/vtcode.toml)

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 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)

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

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

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

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 vtcode update –channel beta

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) -> Commands

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