Arc — VS Code Terminal Bridge for AI Coding Agents

Arc is a VS Code terminal bridge for AI agents that gives coding assistants like Claude Code, Codex, and Gemini full control over terminal sessions inside Visual Studio Code. In other words, instead of firing commands into a black box and hoping for the best, your AI agent can create terminals, run commands, capture every line of output, and react to results in real time.

Additionally, Arc was built from scratch as a Model Context Protocol (MCP) server. MCP is the open standard that lets AI models use external tools through a unified interface. As a result, any AI agent that supports MCP can use Arc to control VS Code terminals without custom integration code.

Furthermore, the extension is free, open source, and ships as a single VS Code extension with zero external dependencies. Install it, register the MCP server with your agent, and your AI assistant gains terminal superpowers.

What Is a VS Code Terminal Bridge for AI Agents?

AI coding agents are powerful at reading code, suggesting changes, and writing files. However, they hit a wall when they need to interact with the terminal. Specifically, most agents can fire a command but cannot reliably capture what the terminal prints back.

For example, when an agent runs npm run build, it needs to know whether the build succeeded or failed. It needs the exact error message, the file path, and the line number. Without complete output capture, the agent is guessing.

Moreover, interactive terminal applications like Claude Code, Codex, and Gemini CLI require a different approach entirely. These applications expect keyboard input, display updating screens, and manage their own output buffers. A simple “run command and wait” pattern breaks down immediately.

Arc solves both problems. It provides a VS Code terminal bridge for AI agents that handles standard command execution with full output capture and interactive TUI applications with smart input detection. As a result, your agent can run a build, read the output, fix the error, and run the build again — all without human intervention.

How Arc Works

Arc ships as two bundled components inside a single VS Code extension:

  1. VS Code Extension — manages terminal instances and runs a lightweight HTTP server on port 3850. It uses VS Code’s built-in shell integration for reliable exit codes and output streaming.
  2. MCP Server — translates MCP tool calls from your AI agent into HTTP requests to the extension. It communicates via stdio, the standard transport for MCP servers.

In addition, the architecture is intentionally simple:

AI Agent <-stdio-> MCP Server <-HTTP:3850-> VS Code Extension <-API-> Terminals

Specifically, when your agent calls a tool like arc_terminal_execute, the MCP server sends an HTTP request to the extension. The extension runs the command in a VS Code terminal, waits for completion via shell integration, and returns the complete output with the exit code. Consequently, the agent receives structured data it can reason about, not raw terminal noise.

Key Features of the VS Code Terminal Bridge

Arc includes 11 MCP tools that cover every terminal operation an AI agent needs:

  • Full output capture — execute commands and get complete stdout/stderr back with exit codes. No more fire-and-forget.
  • Shell integration — leverages VS Code’s built-in shell integration for reliable command boundaries and streaming output.
  • Terminal lifecycle management — create, focus, list, and kill terminals programmatically. Each terminal gets a unique ID.
  • TUI auto-detection — automatically handles interactive applications like Codex, Claude Code, and Gemini CLI with smart Enter key injection.
  • Pattern matching — set up regex watchers on any terminal and get notifications when patterns match. Monitor for errors, completion signals, or custom triggers.
  • Execution status tracking — check whether a command is still running, get partial output, or retrieve the final result after completion.
  • Zero dependencies — uses Node’s built-in http module for the internal bridge server. No npm packages, no supply chain risk.

Most importantly, Arc adds zero overhead to your VS Code startup. The HTTP server starts only when the extension activates, and it communicates exclusively over localhost.

MCP Tools Reference

The following table lists all 11 tools available through the VS Code terminal bridge for AI agents:

Tool What It Does
arc_terminal_create Create a terminal with a custom ID, name, and working directory
arc_terminal_execute Run a command with full output capture and exit code
arc_terminal_send Send text to a terminal for interactive TUI applications
arc_terminal_focus Bring a specific terminal tab to the front
arc_terminal_kill Close and dispose of a terminal by ID
arc_terminal_list List all managed and unmanaged terminals
arc_terminal_get_output Retrieve the last N lines from a terminal output buffer
arc_terminal_observe Set up regex pattern watchers on terminal output
arc_terminal_exists Check whether a terminal ID exists
arc_terminal_health Verify the extension and HTTP bridge are running
arc_execution_status Check status of a running or completed execution

Setting Up Arc with Claude Code

Getting started takes three steps:

Step 1: Install the Extension

Install Arc directly from the VS Code Marketplace or search for “Arc Terminal Bridge” in the VS Code extensions panel. After installation, the extension activates automatically.

Install Arc — Free on VS Code Marketplace

Step 2: Register the MCP Server

Next, register Arc as an MCP server with Claude Code:

claude mcp add --transport stdio --scope user arc -- \
  node ~/.vscode/extensions/mercurial.arc-terminal-0.7.0/mcp-server.mjs

After that, verify the registration:

claude mcp list

Step 3: Start Using Terminal Tools

Finally, open a Claude Code conversation in VS Code and ask it to run terminal commands. For example, ask Claude to “run the test suite and fix any failures.” As a result, Claude will use Arc’s tools to create a terminal, execute the tests, read the output, and iterate on fixes automatically.

Supported AI Agents

Arc works with any AI agent that supports the Model Context Protocol. Specifically, the following agents have been tested:

  • Claude Code — Anthropic’s agentic coding tool. Arc is the recommended terminal bridge for Claude Code in VS Code.
  • Codex — OpenAI’s coding agent. Arc handles Codex’s interactive TUI mode automatically.
  • Gemini CLI — Google’s coding agent. Arc detects Gemini’s TUI interface and manages input/output accordingly.
  • GitHub Copilot — in agent mode, Copilot can use MCP tools registered in VS Code.
  • Cursor — supports MCP server registration for terminal tools.
  • Cline — the open-source coding agent that runs inside VS Code with full MCP support.

In short, if your agent speaks MCP, it can use Arc.

Built for Developers Who Use AI Agents Daily

Arc was built during daily development sessions using Claude Code and Codex inside VS Code. In fact, Arc was developed using itself — the extension was tested and refined by the same AI agents it was designed to support.

Moreover, the extension follows the same development philosophy behind the Contact Form 7 Mailchimp Extension and the other free WordPress plugins on this site: lightweight code, zero bloat, and one focused purpose.

Additionally, Arc is part of a collection of VS Code extensions built for AI-assisted development:

  • GA4 Analytics MCP — query Google Analytics 4 data directly from your AI agent inside VS Code.
  • Iris for Claude — a Telegram bridge that lets you message Claude Code from your phone.

Common Questions

Does Arc work with VS Code on all platforms?

Yes. Arc works on macOS, Linux, and Windows. However, it requires VS Code 1.96.0 or later and shell integration enabled in your VS Code settings.

Does Arc add overhead to VS Code?

No. The HTTP bridge server starts only when the extension activates and listens exclusively on localhost port 3850. It uses Node’s built-in http module with zero external dependencies.

Can multiple agents use Arc at the same time?

Yes. Each terminal gets a unique ID, so multiple agents can create and manage their own terminals without conflicts. In fact, this is how multi-agent workflows operate — one agent runs tests while another monitors logs.

Requirements

  • Visual Studio Code 1.96.0 or higher
  • Shell integration enabled in VS Code settings
  • Node.js 18+ for the MCP server
  • An AI agent that supports MCP (Claude Code, Codex, Gemini, Copilot, Cursor, Cline)

Getting Started

Arc is a VS Code terminal bridge for AI agents that solves the output capture problem every AI coding assistant faces. As a result, your agent stops guessing and starts reading real terminal output. Whether you use Claude Code, Codex, Gemini, or any other MCP-compatible agent, Arc gives it full terminal control inside VS Code.

Additionally, if you need help with setup or have questions, contact us directly. For more tools built for developers, visit GA4 Analytics MCP and Iris for Claude.

Install Arc — Free on VS Code Marketplace

Built by Renzo Johnson