Autohand Code for VS Code

Unleash any LLM raw power directly in your terminal. Search million-line codebases instantly. Turn hours-long workflows into a single command. Your tools. Your workflow. Your codebase, evolving at thought speed.

• Powerful intelligence: Use the latest Open-source models like Claude Sonnet, or connect to your own local LLMs with Ollama or Llama.cpp. Autohand supports any model with an API, so you can choose the best one for your needs.
• Works for you: Autohand Code autonomously explores your codebase, reads and writes code, and runs Terminal commands with your permission. New, friendlier interface that makes it easier than ever to get started
• Integrated with the editor: Autohand Code knows about your current file and text selection, and proposes changes directly inside your editor window we built this extension taking advantage of the native api supported by VS Code.
• Powerful agentic features: Like subagents, custom slash commands. You can configure directly into your VSCode settings panel.

🚀 Quick Start

1. Install Extension

Download from VSCode marketplace:

code --install-extension AutohandAI.vscode-autohand

Alternatively, you can install a specific version:

code --install-extension AutohandAI.vscode-autohand@0.1.5

2. CLI (Bundled by Default)

Marketplace and release VSIX builds bundle the Autohand CLI for:

• macOS: arm64, x64
• Linux: arm64, x64
• Windows: x64

For most users, no separate CLI installation is required.

Fallback behavior remains available:

• If bundled CLI is unavailable, the extension tries autohand from your PATH.
• If not found, the extension provides guided install options in chat.

Optional manual install:

Via npm:

npm install -g autohand-cli

Via curl (Mac/Linux):

curl -fsSL https://autohand.ai/install.sh | bash

Via PowerShell (Windows):

iwr -useb https://autohand.ai/install.ps1 | iex

3. Configure

Create your account and configure your extension.

✨ Key Features

🤖 AI-Powered Assistant

• Natural Language Chat: Conversational coding assistance
• Agentic Execution: Multi-step task automation
• Real-time Visualization: Watch AI tools execute in real-time
• Context Awareness: Understands your codebase structure

🔧 Smart Code Actions

• CodeLens: Refactor, test, document, and fix functions
• Quick Fixes: "Fix with Autohand" for diagnostics
• Inline Actions: Right-click menu for selected code
• Diff Preview: Review changes before applying

🔒 Security & Permissions

• Interactive Approval: Confirm risky operations
• Project Permissions: Local whitelist/blacklist control
• Provider Credentials: Keep provider API keys alongside your Autohand account configuration
• Shared CLI Configuration: Credentials use the CLI configuration file; extension writes restrict file permissions where supported

Auto-mode and measured research

Open Chat actions → Auto-mode, or run Autohand: Auto-mode, to start a task with an iteration limit. The same controls pause, resume, or cancel the loop. Changes stay in the chat's workspace. The progress view contains events captured by this chat process.

Open Chat actions → Auto-research, or run Autohand: Auto-research, to run measured experiments. Describe the objective and choose an iteration limit; the agent helps establish the benchmark, metric, and files in scope. Research runs benchmark commands, commits accepted changes, and reverts rejected experiments. A new benchmark requires a clean Git working tree, and the start dialog explains these changes before execution.

Research state and its .auto/ files belong to the workspace. Continuing research keeps the saved objective, benchmark, iteration limit, and history. Running means this chat is executing research; Ready to continue means the saved research is enabled but this chat is idle. Pause and the chat's Stop button interrupt this chat's research turn and preserve its state.

Research controls also show history, replay benchmarks with their original or current evaluator, rescore saved measurements, compare attempts, show the Pareto frontier, and pin artifacts. Artifact cleanup opens a preview and requires explicit confirmation before deletion. Typed /autoresearch starts retain the CLI's benchmark, sampling, retention, and delegation flags. /autoresearch off pauses immediately; the other research subcommands remain available through the CLI.

MCP servers

Use the MCP status indicator's Manage servers button, /mcp manage, or Autohand: Manage MCP Servers to enable, disable, reconnect, inspect tools, or remove a saved server. Status is reported for each server, including servers that connect successfully with zero tools.

Configuration changes restart the originating idle chat and restore its saved conversation. Other chats use the changed configuration on their next restart. The optional VS Code MCP provider exposes enabled stdio and HTTP servers using their saved environment variables or headers. It requires workspace trust and both autohand.mcp.bridgeEnabled and autohand.mcp.exposeCliToolsToVscode; legacy SSE entries are excluded from this provider.

Persistent goals and queue

Open Chat actions → Goals and queue, run Autohand: Goals and Queue, or type /goal to open native goal controls. If the CLI's goal feature is disabled, the controls offer to enable it and restart the idle chat. Queue an objective with its completion criteria, then choose Start / resume. /goal <objective> starts directly. Draft a goal with the agent helps define a goal before you approve its creation.

Each chat owns its own goal. The backlog and completed history are shared by the workspace; the goal view lists other sessions separately. A running goal continues across agent turns and advances to queued work after completion. Goals explicitly created by the agent during chat also continue automatically. Stop or Pause goal interrupts the current turn and preserves a paused goal. Starting a goal preserves this chat's selected permission and plan modes.

The controls support editing objectives, marking verified work complete, clearing the current goal, and inspecting templates, limits, queue entries, and history. Queue additions and edits made while a goal runs apply between turns; Stop cancels changes that have not yet applied. Budget and completion-floor fields supplied through CLI goal tools are retained. Usage reflects the CLI's reported accounting. Opening a saved chat displays its goal without automatically resuming it.

Account and usage

Chat actions shows your email and the plan reported by your Autohand account. Manage account opens the console, and Usage opens your usage page. An unavailable plan is shown as unavailable rather than guessed.

Conversation branches

Use Fork into a new conversation below a completed response to open a separate chat containing the history through that answer. Your original chat remains available. Forking waits until the chat is idle and proposed edits have been reviewed.

Workspace folders

In a workspace with several folders, a new chat uses the active file's folder, falling back to the first folder when no file is active. Each chat retains that folder for file context, Git worktrees, project memory, and conversation history. Saved panels restore their folder, and forks open in their source conversation's folder. Opening a saved conversation from another workspace folder creates a separate editor chat.

Autohand runs on the workspace extension host and requires a trusted filesystem workspace. Virtual repositories without a filesystem checkout are unsupported. File context searches respect Git ignores and run asynchronously.

Reviewing proposed edits

Both sidebar chats and editor panels show the CLI's staged file edits. Select a file to open a native diff of its original and proposed contents, including new files and deletions. Viewing the diff does not write to the workspace. Accept All, Accept Selected, and Reject All send your decision to the CLI; accepting selected files discards the other proposals in that batch.

The review remains visible until the CLI confirms the decision. Failed applications retain their details and proposed contents for inspection. New prompts and goal continuations wait for pending reviews, and model/session changes are blocked until the review is resolved. A disconnected CLI leaves the old proposals visible for reference; they cannot be applied through the expired review.

Changing the running chat

Fresh configurations use Autohand AI with Auto model selection. Existing saved provider and model choices are retained. Shared configuration changes refresh silently; active chats keep their running settings, and new chats use the latest saved configuration.

The provider picker also includes enabled custom endpoints from the CLI's customProviders configuration and saved runtime providers from extensionProviders. Custom endpoints show their configured model list and support manual model IDs. Configure or install these providers through the CLI first; runtime extensions still require the CLI's normal trust and loading checks. Model and reasoning changes preserve nested provider credentials and settings.

The model picker retains the originating chat's conversation when switching models. Reasoning effort, permission mode, auto mode, and plan mode apply through an idle restart of that chat. Controls show the confirmed running settings; busy chats must be stopped before changing them. Reasoning effort is stored with the active provider, whose model support determines how it is used. Entering plan mode turns off unrestricted auto mode.

🌍 Multi-Language Support

• 15 Languages: Full localization support
• Auto-Detection: Uses your VS Code display language
• Easy Switching: Configure in settings

📋 Supported Languages

Language	Code	Language	Code
English	en	Japanese	ja
Chinese (Simplified)	zh-cn	Korean	ko
Chinese (Traditional)	zh-tw	Russian	ru
French	fr	Turkish	tr
German	de	Polish	pl
Italian	it	Czech	cs
Spanish	es	Hungarian	hu
Portuguese (Brazil)	pt-br

🏗️ Architecture

┌─────────────────────────────────────────────────────────────┐
│                    VS Code Extension                       │
├─────────────────────┬───────────────────────────────────────┤
│   Extension Host    │           Webview Panel               │
│   (RPC Client)      │     (Chat UI - HTML/CSS/TS)           │
│                     │                                        │
│ • CLI Manager       │ • Chat Interface                      │
│ • Auth Service      │ • Real-time Updates                   │
│ • Permission System │ • Session Management                  │
│ • Diff Provider     │ • Code Actions                       │
└─────────┬───────────┴───────────────────────────────────────┘
          │ JSON-RPC (stdio)
          ▼
┌─────────────────────────────────────────────────────────────┐
│                    Autohand CLI                            │
│                  (Agent Engine)                            │
│                                                             │
│ • Tool Execution   • LLM Integration   • State Management   │
│ • Permission Control   • Error Handling   • Logging       │
└─────────┬───────────────────────────────────────────────────┘
          │ API Calls
          ▼
┌─────────────────────────────────────────────────────────────┐
│                   LLM Provider                            │
│            (OpenRouter, OpenAI, Ollama, etc.)             │
└─────────────────────────────────────────────────────────────┘

📦 Installation

From VS Code Marketplace

1. Open VS Code
2. Go to Extensions (Ctrl+Shift+X)
3. Search for "Autohand"
4. Click "Install"

For Development

# From this extension checkout
npm ci
npm run compile
# Press F5 in VS Code to launch an isolated Extension Development Host.

🔧 Configuration

Basic Settings

Access via: File > Preferences > Settings > Autohand

Setting	Default	Description
autohand.cliPath	autohand	Path to Autohand CLI
autohand.provider	openrouter	LLM provider
autohand.model	anthropic/claude-sonnet-4	Model to use
autohand.permissionMode	interactive	Permission mode
autohand.showThinking	true	Show agent reasoning
autohand.autoScroll	true	Auto-scroll chat

Permission Modes

• Interactive: Prompts for approval (recommended)
• Unrestricted: Auto-approves all operations
• Restricted: Blocks risky operations

Project-Specific Permissions

Create .autohand/settings.local.json in your workspace:

{
  "permissions": {
    "whitelist": ["run_command:npm *", "read_file:*.ts", "edit_file:src/**"],
    "blacklist": ["run_command:rm -rf *", "edit_file:*.env"]
  },
  "version": 1
}

🎯 Usage

Opening Chat

• Activity Bar: Click Autohand icon
• Status Bar: Click Autohand item
• Keyboard: Cmd+Shift+A / Ctrl+Shift+A
• Command: Autohand: Open Chat

Common Tasks

Ask About Code

# Select code and right-click
# Choose "Ask Autohand About Selection"
# OR use shortcut: Cmd+Shift+E / Ctrl+Shift+E

Refactor Functions

# Hover over function to see CodeLens
# Click "Refactor with AI"

Quick Fixes

# See lightbulb on diagnostics
# Click "Fix with Autohand"

Multi-File Changes

# Request changes across files
# Use "Preview Changes" to review
# Selectively apply modifications

Keyboard Shortcuts

Shortcut	Command
Cmd+Shift+A / Ctrl+Shift+A	Open Chat
Cmd+Shift+E / Ctrl+Shift+E	Ask About Selection
Ctrl+Alt+I / Ctrl+Cmd+I	Ask in Chat
Ctrl+Shift+K / Cmd+Shift+K	Quick Actions

🔑 Authentication

Autohand Account (Recommended)

autohand login

• Device flow via browser
• Account management at https://autohand.ai
• Cross-device sync

API Key Configuration

The current CLI requires an Autohand account even when inference uses a provider API key. Sign in through the extension or autohand login, then configure your provider. Existing device credentials are preserved when changing providers.

The extension follows AUTOHAND_HOME and AUTOHAND_CONFIG. It reads CLI JSON, TOML, or YAML configuration and preserves unrelated settings when saving changes.

// ~/.autohand/config.json
{
  "provider": "openrouter",
  "openrouter": {
    "apiKey": "your-key-here"
  }
}

Use the model picker to select a provider and model. Its catalog includes the current CLI's built-in providers, including Autohand AI, Anthropic, OpenAI, OpenRouter, Bedrock, and local providers. Provider catalogs remain separate, and you can enter a custom model ID.

🛠️ Development

Setup

# Install dependencies
npm ci

# Compile TypeScript
npm run compile

# Watch mode (recommended)
npm run watch

# Run tests
npm test

# Build the production extension bundle
npm run package

Scripts

Script	Description
npm run compile	Compile TypeScript
npm run watch	Watch mode for development
npm test	Run unit tests
npm run test:coverage	Run tests with coverage
npm run test:integration	Run integration tests
npm run package	Build the production bundle
npm run check-types	Check TypeScript
npm run lint	Run typed ESLint checks
npm run test:cli	Run compiled/source CLI scenarios with isolated local fixtures
npm run test:webview	Test both chat surfaces in Chromium
npm run test:packaging	Test binary verification and replacement
npm run ship	Build and verify CLI binaries, run checks, and create a VSIX
npm run test:vsix	Verify an exact VSIX in an isolated VS Code host
npm run go	Build, package, and install

ship reads the sibling ../cli-3 checkout. Clean release builds reject uncommitted CLI inputs; --allow-dirty records a local development snapshot. Use AUTOHAND_CLI_PATH for an explicit CLI test binary, PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH for an installed Chromium browser, and AUTOHAND_VSIX_PATH with test:vsix to select a package. Shipping and package verification do not install into your normal VS Code profile or publish to the Marketplace.

Project Structure

vscode-autohand/
├── src/
│   ├── extension.ts          # Extension entry point
│   ├── core/
│   │   ├── cli-manager.ts    # CLI process lifecycle
│   │   ├── rpc-client.ts     # JSON-RPC communication
│   │   └── store.ts          # State management
│   ├── providers/
│   │   ├── chat-provider.ts  # Webview provider
│   │   └── chat-panel.ts     # Editor panel provider
│   ├── views/webview/        # Chat UI (HTML/CSS/TS)
│   └── types/                # TypeScript interfaces
├── l10n/                     # Localization files
├── docs/                     # Documentation
├── package.json              # Extension manifest
└── tsconfig.json             # TypeScript config

🐛 Troubleshooting

Quick Debug Checklist

1. Check CLI: which autohand or autohand --version
2. Check Logs: Output panel → "Autohand" channel
3. Enable Debug: Set autohand.debug: true
4. Verify Auth: autohand login or check config
5. Test Connection: Try a simple message

Common Issues

Extension Won't Activate

• Verify VS Code >= 1.136.0
• Check Output panel for errors
• Verify CLI installation: which autohand

CLI Connection Failed

• Check autohand.cliPath setting
• Test CLI: autohand --help
• Review ~/.autohand/config.json

Permission Issues

• Check autohand.permissionMode setting
• Review local permissions in .autohand/settings.local.json
• Check extension logs for permission decisions

Webview Problems

1. Open Developer Tools (Cmd+Shift+I in webview)
2. Check console for JavaScript errors
3. Look for CSP (Content Security Policy) errors
4. Verify network requests

API/Authentication Errors

• Verify API key configuration
• Check provider settings
• Test with: autohand login
• Review network timeout settings

Getting Help

1. Enable Debug Mode: autohand.debug: true
2. Check Logs: Output panel → "Autohand"
3. Update CLI: Update the extension for its bundled CLI, or use npm update -g autohand-cli if you explicitly use the global CLI
4. Report Issues: GitHub with debug logs

🤝 Contributing

We welcome contributions! visit our code-cli repository for more details on how to contribute to this project. https://github.com/autohandai/code-cli

Development Workflow

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Run tests: npm test
5. Submit a pull request

Code Style

• ESLint + Prettier configured
• TypeScript strict mode
• VS Code extension guidelines
• Conventional commits

📄 License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

🌐 Links

• Homepage: https://github.com/autohandai/code-cli
• Issues: https://github.com/autohandai/code-cli/issues
• Discord: https://discord.gg/MWTNudaj8E
• Autohand CLI: https://github.com/autohand/cli
• Documentation: docs/

---

🎉 That's all folks! Happy coding with Autohand! 🚀