Install the extension from the Visual Studio Marketplace or Open VSX, run Dirac in any terminal with the CLI, or use it from ACP-compatible editors such as JetBrains IDEs and Zed. Your provider configuration stays with Dirac across these interfaces.

Start an interactive CLI session with /goal <objective>. Dirac can keep working toward the same objective for hours or days without drifting, autonomously creating and coordinating tasks until the goal is achieved. It pauses when it needs your input, and you can check in, steer, pause, resume, or stop it at any time.

Use /new-tool <description> to build a tool tailored to your workflow while you work. Dirac turns the requirements into a typed tool, compiles it, validates it, and smoke-tests it. Task-scoped tools are available immediately; persistent workspace and global tools appear in the Tools tab and can be enabled without starting a new conversation.

Tool creation must be enabled. Smoke commands follow your configured approval policy.

Models do not need to narrate every routine step. Enable Low-verbosity responses to keep progress and final answers concise while preserving decisions, caveats, failures, and verification results.

If something occurs to you after a task starts, send another message at any time. Dirac queues it and delivers it to the model with the next tool response, updating the work without cancelling or restarting the task.

Route context compaction, new-task handoffs, commit-message generation, and permission decisions to a separate, cheaper model so the main model can stay focused on implementation. In our context-compaction case study, this model arbitrage reduced cost by more than 80%: Sol vs. Luna: token arbitrage for AI agents.

Configure the Utility model as the first pass for permission requests and give it an explicit natural-language policy. It approves requests that satisfy the policy and escalates unsafe or uncertain requests to you. Every automatic approval remains visible in the transcript with its reason.

Dirac uses a custom stable line-anchor protocol instead of brittle search-and-replace blocks. The model can identify an exact source range by its anchors and replace only that range, even after nearby lines move. This reduces edit payloads, ambiguity, and retries. Read how hash anchors and Myers diff make editing more efficient.

Dirac uses the codebase's syntax trees to inspect structure without reading entire files. The model can request outlines of many files or retrieve one exact implementation and its references:

inspect_ast(operation: "outline", paths: ["utils/db.py"])
inspect_ast(operation: "implementation", paths: ["utils/db.py"], symbols: ["DBManager.init_db"])

Structural results depend on parser and index coverage. Dynamic references require separate verification.

Structural edits operate on symbols rather than approximate text matches. Dirac can replace one complete function or rename hundreds of indexed references in one call:

edit_ast(operation: "replace", targets: [{ path: "utils/db.py", symbol: "DBManager.init_db", replacement: "..." }])
edit_ast(operation: "rename", targets: [{ path: "src/", symbol: "old_name", replacement: "new_name" }])

Every Dirac build ships with its source. Use /askDirac <question> to ask how the installed version works; Dirac receives read-only access to its own functional source so it can answer against the build you are running.

Dirac's tool protocol lets models batch independent reads, searches, edits, and commands in one response. Coordinated changes across multiple files happen together instead of requiring a separate model round trip for every operation.

When automatic approval is disabled, Dirac groups related changes into a single multi-file diff view. You can review the complete change as one unit instead of opening and approving a sequence of disconnected file edits.

Before the first request reaches the model, Dirac detects likely filenames, directory paths, and symbol names and assembles a bounded context packet. Named symbols receive definition-first context and indexed references.

You can also mention Git changes, workspace diagnostics, terminal output, URLs, text files, PDFs, DOCX files, spreadsheets, notebooks, and images. Applicable AGENTS.md instructions, matching rules, and active skills join the request as repository guidance.

Subagents can research, edit, run commands, and validate work concurrently. Each can receive its own prompt, tools, timeout, and optional parent context. Dirac tracks source freshness and rejects stale edits at write time, allowing independent agents to work safely in the same codebase.

Path-aware instructions, rules, skills, workflows, and hooks carry repository guidance into each task. Permissions are evaluated at tool boundaries, command batches report exit status and bounded output, and Chromium checks return screenshots, console messages, page errors, and the current URL.

Dirac can also isolate work in a Git worktree with integration and cleanup controls. Browser interaction uses screenshots and coordinates; the main-worktree flow expects a clean, single-root Git workspace.

Context condensation preserves decisions, exact paths, failed attempts, and validation state. Separate bounded recovery paths handle transient provider errors, context overflow, empty responses, and interrupted tool loops.

Plan, Act, and Utility work can use separate model configurations. Reviewed handoffs can move remaining work into a fresh task, while task IDs support resuming work across VS Code, the CLI, pipelines, and compatible ACP clients.

The optional completion verifier reviews acceptance criteria and claimed validation in a separate model pass. If a required criterion is missing, it returns concrete follow-up work to the active task. This model-based check does not replace tests or human review.

Checkpoints capture workspace files and operational task state. Restore can apply to the workspace, the task, or both, including queued steering, active skills, task tools, and context tracking.