Arc

• File Operations: Read, write, edit, grep, glob, and semantic search.
• LSP Integration: Check workspace diagnostics and identify file-specific problems.
• Notebook Support: Read, write, and execute Jupyter notebook cells with workspace kernel integration.

• Shell Execution: Run (background) commands, manage processes, write to shells, configure custom execution commands, and wait for a fixed delay, a specific time, a background process to finish, or a condition to become true. Arc can also be configured to use your terminal of choice, or integrated directly into VS Code's terminal.
• Lifecycle Hooks: Run shell commands automatically on agent events such as session start, message submission, tool calls, compaction, model handoffs, notifications, task completion, and subagent spawns. Hooks can gate or veto tool calls before they run, inject context, sync external systems, or trigger follow-up automation.
• Web Capabilities: Fetch web page content and search the web.

• Subagents & Handoff: Spawn child agents, query parent agents, and hand off control between instances, with per-file locking to prevent concurrent edit conflicts.
• Testing & Session Management: Run automatically detected test suites, manage custom skills, track session history/traces, and update task progress.
• Checkpoint Management: List, compare, and revert to previous session checkpoints.
• Memory & Rules: Read, list, create, and modify persistent memories and behavioral rules. Optional team stores extend this with shared memory locations.
• User Clarification: Ask clarifying questions.

• Model Context Protocol: Add MCP servers to call custom tools, resources, and prompts with sampling and roots capabilities, or browse and install servers from the official MCP registry in the built-in Marketplace.
• Git Integration: Native stage, commit, push, branch, and PR tools alongside staged/unstaged diffs, branch diffs, changed-file listings, and commit-message generation.
• Playwright Integration: Navigate, click, drag, type, hover, scroll, evaluate scripts, run raw Playwright code, capture screenshots, read page content, read DOM/console/network activity, handle dialogs, manage multiple tabs, intercept network requests, and wait for specific page states.
• Editor Integration: Open inline chats at the cursor (Ctrl+L) to work with Arc from the file.

• Prompt Polishing: Optionally polish prompts before sending, allowing grammar/spelling-only fixes or full rewriting.
• Attention sounds: Optional sounds for task completion, approval requests, and errors.
• Token-optimization: Arc detects tools, MCP servers, skills, rules, and memories that haven't been used for a long time, and suggests unloading them to optimize token usage.

• Prompt-injection protection. Arc detects, optionally quarantines, and stops tool results, remote output, and high-confidence injections from reaching the model in the first place. Memory writes, skill files, and repository instructions are scanned on write to stop memory poisoning.
• Secret scanning at write time. Every file modification runs through a pre-write hook that scans for keys and secrets before anything is ever written.
• Protected config writes. Writes to config files always require explicit user approval, even with auto-approve enabled.
• OS sandboxing for shell commands. Shell execution supports sandbox-exec on macOS, bwrap on Linux, and on Windows a custom, restricted-token sandbox (all privileges dropped, Low mandatory integrity, Job Object cleanup and UI limits).
• Authenticated audit log. Session traces use an HMAC-SHA-256 chain whose head is anchored in VS Code SecretStorage. Arc: Verify Audit Log in the command palette detects anomalous logs, and Arc: Export Audit Log produces a copy for sharing.
• Encrypted chat history. Chat history is stored in Arc's own encrypted, compact ARCX binary format by default, providing better storage efficiency and security than JSON or SQLite.

• Reversible context compression. Oversized tool outputs are compressed before entering history; originals are stored locally by content hash and can be restored on demand.
• EMA-tracked compaction. Arc calculates the exponential moving average of prompt and completion tokens per model. When estimated usage exceeds the model's usable window, it summarizes the conversation midsection, replaces it with a single system message, and keeps the system prompt plus the last six messages intact. The safety margin is configurable per workspace.
• Dual-backend semantic search. The indexing engine supports two backends: hash-based and semantic. The index uses a custom ARCX format for fast loading and saving.

• Content-addressed checkpoints. Reverts stay fast by only storing the files that actually changed. Restoring writes blobs back, deletes newer metadata, and garbage-collects unreferenced blobs.
• Full agent resume. Snapshots preserve browser tabs, MCP connections, and background processes, so sessions resume after VS Code restarts.
• Post-edit verification loop. After each edit, lint and typecheck are automatically run via the LSP, and the agent autonomously fixes up to N times.

• Prompt caching. System prompts and conversation prefixes are structured with cache_control breakpoints to maximize Anthropic and OpenAI cache hits, reducing cost and latency for long-running sessions.
• Granular proxy fallback. Set a proxy per category (provider API calls, web tools, or shell commands) or one global configuration.

• Subagent tier delegation. Subagents spawn one tier below the parent by default so cheap models handle basic work, but can be chosen differently if needed by Arc. The handoff process follows a fixed pattern both ways, and the agent preserves the to-do plan across handoffs so the new model picks up where the last left off.
• Custom modes. Create and edit mode definitions, update the default modes, and configure model binding from the settings panel, without touching config files.

The sizes in the Efficiency section refer to the VSIX size of the extensions, which is the size of the file you download, while the size shown on Arc's extension page is the decompressed size. As Arc improves, the raw size does inevitably increase, but through careful planning and aggressive optimization, we keep the size of what you actually download small.

To some extent. Arc doesn't use proprietary VS Code APIs or platform-specific binaries, so it should work with VS Code forks like VSCodium and Cursor just fine. However, due to VS Code's safety restrictions, Arc may not work in Remote SSH, WSL, or Dev Containers. If you wish to use Arc in these environments, install Arc on the remote when VS Code offers "Install in SSH: ...".

To make sure the limited free resources are available to everyone, we don't disclose our upstream provider, but they promise no data training and zero data retention. However, as free resources are limited, we recommend not relying on the internal provider for long workflows.

ARCX is our custom binary format, used to store vector embeddings, chat histories, and checkpoint data, optimized for each use case. It's fast, secure, and acts as a deterrent for bad actors by looking weird. Your API keys (as well as encryption keys for ARCX files) are stored in VS Code's SecretStorage, which then uses your OS's secret manager.