Features

Your backlog, in your editor.

Every feature is built around one loop: pick an item, let AI work it, review the branch, merge the PR.

Start here

New Project Wizard

Scaffold a project from an empty folder — structure, AGENTS.md brief and git init — and wire it to Azure DevOps in one guided pass.

New

Chat in the Editor Area

Move the conversation out of the sidebar into a full editor tab, side by side with the code it changes.

Fan out

Delegate to Coding Agents

Send a work item to an external agent in its own git worktree; ADO Code commits, pushes and opens the pull request.

One tree view for the whole backlog

Work items render as the real ADO hierarchy — Epic → Feature → User Story → Task — with a visible header toggle between My Work Items, All Work Items and Unassigned. Hierarchy-context rows are tagged, state/type/text filtering is built in, and a green badge marks the item you're working.

  • Parent-chain walk for true nesting, even when parents belong to someone else
  • Assignment cues — blue = you, orange = someone else, grey = unassigned
  • Take Ownership / Reassign right from the tree
  • Open items spawn feature/ADO-<id>-<slug> branches automatically

Agent worktrees

Every delegated run gets its own git worktree under .ado-code/worktrees/ — parallel agents can never collide.

  • Run status, dirty files, ahead/behind at a glance
  • Open in Terminal / Explorer, diff, remove
  • Concurrency guard: no overlapping runs on the same item

Memory that persists

User memory remembers you across sessions; workspace memory keeps project conventions in .ado-code/memory/ — auto-ignored by git & Docker.

  • agent.before / agent.after shell hooks
  • Fuzzy search, import/export

MCP & skills

Plug in external MCP tool servers, or load from a built-in catalog of 10+ skills — Code Review, Security Audit, Testing, Refactoring and more.

  • Skill import from JSON, SKILL.md or archives
  • Community skill registries via TSV

Model-aware by design

Capabilities are detected per model — vision, tool calling, context window — so the UI never offers what your model can't do.

  • Live /models data from OpenRouter or Ollama
  • Per-model overrides when auto-detection is wrong
  • Real token counting in the status bar

Diagrams that render

Fenced ```mermaid blocks become real interactive diagrams — flowcharts, sequence, class, state, ER and Gantt — right in the chat, task details, work-item details and agent summaries.

  • Diagram | Code toggle plus one-click copy
  • Save SVG / Copy SVG for docs and PRs
  • Theme-adaptive, with inline syntax-error fallback

Works without ADO

Pick None (no project) in the project dropdown to run standalone — the assistant, tools, worktrees and PR flow keep working over the local repo, with no board or credential warnings.

  • Re-attach to any project at any time
  • Projects auto-fetch in the background when configured
  • Chat and work items stay in the views you choose

An AI that finishes the job

For delegated runs, ADO Code closes the loop itself: commit → push → open the pull request — never force-pushing, never touching protected branches. Finished runs get an LLM auto-review with a merge recommendation, and after the PR merges, Clean Up After Merge removes the worktree and the branch.

  • commit_worktree → push_worktree → create_pull_request
  • resolve_pr_conflicts lets the AI fix merge conflicts, then re-push
  • Parent delegation covers the whole subtree with a numbered delivery checklist

Feature reference

Everything ADO Code does.

Everything ADO Code does in v0.6.6 — 95 capabilities across 8 areas, straight from the release notes. The list is long, so it stays collapsed until you ask for it.

Show the full feature list 95 features · 8 categories

Grouped by area. Rows marked new · 0.6.1 / new · 0.6.2 / new · 0.6.4 / new · 0.6.5 / new · 0.6.6 landed in the latest releases.

▤Work Items14
Hierarchical treeWork items render as the real ADO hierarchy — Epic → Feature → User Story → Task — with a parent-chain walk, so nesting survives even when parents belong to someone else (hierarchy-context rows tagged “· context”).
View mode toggleOne tree with a visible header: My Work Items / All Work Items / Unassigned — click to switch, remembered per workspace.
Filtering & searchFilter the tree by state, type, or text search with smart parent visibility — collapsed parents stay visible when a child matches.
Take Ownership / ReassignContext-menu actions gated per item, available in every view mode; selected items show a green badge and can be deselected.
Full detail viewRight-click → Show Full Details opens a formatted panel in the editor with the item's full content — including rendered Mermaid diagrams and rich-text images.
Task draft editorWhen the AI calls create_work_item, an editable markdown tab opens for review before anything is created — markdown is converted to HTML for proper ADO rendering.
Generate tasks from stories/generate-tasks has the AI analyze a user story and draft child tasks — with duplicate prevention against existing children.
Project binding & stateWorkspace-to-ADO project binding prevents working items from the wrong project; /status, /comment, /assign and /undo drive the active item.
Rich-text imagesScreenshots inside Description, Acceptance Criteria, Repro Steps and comments are fetched with your PAT and inlined as data: URLs — no more broken images in the detail panel (capped at 10 images / 2 MB each / 8 MB total per field).
Assignment cuesEvery item shows who owns it — blue person = assigned to you, orange = someone else, grey = unassigned — with the type in the row description and the assignee on hover.
Batch work-item readsget_work_item accepts an ids array — fetch up to 20 work items in ONE call (details batch-fetched, discussion threads loaded in parallel) instead of N round-trips.
AI task reviewRight-click → Review Task Detail now binds the work item to the chat and hands it to the AI — it reviews clarity & completeness, risks, dependencies and suggested approach, and judges whether the task is ready to start. The review runs as a normal chat turn (it may read the repo to ground itself but never mutates anything) and streams into the chat next to the detail panel.
One work item per sessionSessions remember which ADO items they processed — shown as #chips in the session-history dropdown. When a session that already worked on another item is asked to process a different one, ADO Code alerts you with one-click Start a New Session / Stay / Cancel — cancel aborts before any ADO state change, branch creation or delegation.
Unattached project modeA None (no project) choice in the chat header's project dropdown runs ADO Code standalone — the work-items tree and board go dormant, stored bindings are cleared without missing-credential warnings, and the assistant works as a plain coding tool over the local repo. When ADO credentials are configured, projects are still fetched in the background so you can re-attach at any time (the setup wizard now offers None as its default initial option).
💬AI Chat & Modes24
Any LLM, one chatOpenAI-compatible APIs (OpenRouter, Ollama, LM Studio…) and Anthropic — bring your own key and model.
Chat / Plan / Act / YOLOClick-to-switch tool modes: Chat (ask + approve), Plan (read-only), Act (auto-approve with allowlist), YOLO (full autonomy) — also cycled from the Status Panel.
Agentic tool loopTool calling with an agentic loop, mode-aware system prompts (role, tools, guidelines, environment) and an iteration budget per turn — 100 by default (configurable up to 1000), where each iteration is one model round-trip that may fire several tools in parallel.
Parallel tool callsIndependent tool calls run concurrently and re-order back to call order; same-file edits serialize through a per-file mutation queue. Mixed batches stay fast too — consent-free calls execute in parallel while approval-gated ones run sequentially, so read-only work never waits on your click.
Batched editsedit_file accepts an edits[] array — several disjoint changes in one call, each verified and applied in order.
Batched terminal commandsrun_terminal_command accepts a commands array — several commands in ONE call, each still checked for shell operators and the Act-mode allowlist, outputs concatenated under $ command headers with a single consent card.
search_files grep toolRegex search across the workspace with path:line hits, per-line truncation, workspace confinement and result caps. LLM-style inline flags ((?i), (?m), (?s), (?i:…)) are detected, stripped and translated — or passed explicitly via the flags argument, with a clear error naming the JS RegExp engine when a pattern won't compile.
Live thinking & tool cardsReasoning streams in-flow — one Thinking block per iteration, sitting directly above the tool batch it introduced — and every tool call appears as a live card (running… → completed/error, arguments & results expandable). A finished turn keeps its whole ordered record visible in the thread — every block and card stays open (collapsible) — followed by the final answer.
Two-sided chat layoutAI answers stay on the left; your messages move to the right as a compact, button-colored bubble (capped at 85% of the panel). The old (AI)/(You) avatar circles are gone — every message already names its author in the header row — so the chat is denser and who-said-what reads at a glance.
Session isolationA chat turn is bound to the session that started it — switching chats, creating or deleting a session, or clearing history stops the in-flight turn cleanly in its own session, so late chunks can never bleed into (or persist into) a different session's thread. Streamed answers buffer and flush safely: an error mid-stream keeps the partial text instead of dropping it.
Turns always concludeNo more bare “agentic loop exceeded N iterations” errors: a turn that exhausts its iteration budget gets one wrap-up round-trip to say it hit the limit and summarize what it accomplished and what remains (a deterministic conclusion takes over if that fails) — and a provider returning an empty final gets a deterministic closer too. A finished turn always ends with an answer.
Privacy togglesHide tool calls entirely (subtle “…” only) and toggle AI thinking on/off — enforced across every streaming path.
AI choice detectionWhen the AI offers options they render as clickable buttons; a fenced ```choice block is the primary path, with regex and an optional cheap-model fallback.
In-chat confirmation cardsTask start, mode switch and every consent prompt render as styled cards inside the chat — destructive operations use danger styling. Cards are collapsible (a −/+ header toggle with an option-count badge) and dismissible (✕), and are stored per session so a pending or closed card can never leak into another chat.
Send Selection / File to ChatRight-click editor selection or an Explorer file to insert it into the chat — selections as fenced code, files as attachment chips.
Slash commands/pick, /delegate, /generate-tasks, /new-project, /skills, /remember, /clear-sessions… with autocomplete and categorized /help.
Working indicatorStatus-bar spinner with live detail (“thinking…”, “tool: edit_file”) — visible even when the chat view is hidden.
Truncated-response guardIf a reply hits the output token limit, tool calls fail with “re-issue” instead of executing possibly-truncated arguments.
Active editor contextThe file you're editing is auto-injected into every chat turn — deduplicated by file/version, oversized selections capped, no copy-paste required.
AGENTS.md in chatThe chat model reads and honors an AGENTS.md at the workspace root on demand — parity with agent handoffs, zero cost when absent.
Batch file readsread_file accepts a paths array — read up to 10 files in ONE call as demarcated === path (N lines) === sections with per-file error resilience. The default window grew from 200 to 400 lines (files ≤ 400 lines come back whole), read tools share a turn-scoped cache so the same file isn't re-read across iterations (invalidated on any mutation), and list_workspace can return per-file sizes via details: true (up to 150 files).
Workspace delete toolA native, cross-platform delete_file tool removes a file or a whole directory tree — confined to the workspace, auto-checkpointed before it runs, with recursive support and read-cache invalidation, so cleanup no longer needs shell workarounds.
Loop circuit breakerDegenerate tool loops are caught before they burn the iteration budget: an identical call signature warns on the 3rd repetition and is blocked on the 4th+, overlapping read_file ranges warn after two and block after three, and when every call in consecutive iterations is blocked the loop trips and forces a concluding reply.
Shell safety & Windows commandsThe terminal guard is now quote-aware — single- and double-quoted literals are stripped before checking for dangerous operators, so git commit -m "feat(scope): msg (note); more" and node -e "..." run instead of being falsely blocked. Windows cmd.exe builtins (dir, copy, move, type, cls, del, rmdir…) are routed through %ComSpec%, fixing spawn del ENOENT.
🤖Agents & Worktrees14
External agent orchestrationDelegate to Claude Code, Codex, OpenCode, Hermes, Pi, DeepSeek Harness (dsh) and more — each declared by binary, supported modes and CLI arguments, with a details panel.
Agent detection — Windows-safeDetection probes what your terminal can actually run: on Windows it walks a fallback chain (.cmd shim → .exe → bare name) and delegation spawns that same binary — native claude.exe installs are detected, npm shims launch through cmd.exe with correct quoting (no ENOENT), and detection re-probes after 15 s so an agent installed while VS Code is open shows up without a reload. The Claude adapter's own runTask/resumeTask resolve the executable the same way instead of hard-coding the bare name.
DeepSeek Harness (dsh)First-class agent support — auto-detected via dsh --version and delegated through the headless profile (prints the final answer, exits 0 on success). Available from chat, /delegate, the work-item context menu and the delegate_to_agent tool.
Worktree isolationEvery delegated run gets its own git worktree under .ado-code/worktrees/ — concurrent agents can never collide on branches.
Worktrees viewDedicated sidebar tree with per-worktree details: run status, agent, dirty/clean files, last commit, ahead/behind — plus Open in Terminal/Explorer, Remove, Show Changes and Show Agent Output.
Reopen agent outputFinished runs keep a ↗ Reopen button and right-click → Show Agent Output — the summary panel is never permanently lost.
Run history & progressRecent Runs (last 10) in the Status Panel with status icons and timestamps; agent progress streams in the chat thread with a live elapsed clock, or into the editor area as a full panel. A delegation is now one evolving run card in the thread — it updates as the run progresses and resolves to succeeded / failed / cancelled with the summary and branch in place, so the chat never looks done while the agent panel is busy (the outcome is persisted into the delegating session's history).
Parent delegationDelegating a parent item runs its whole subtree in ONE worktree — the agent gets a numbered delivery checklist and must sign off with a ## Delivery Report (DONE / BLOCKED / INCOMPLETE).
Auto-complete childrenWith adoCode.agents.autoCompleteChildren, done children transition to their terminal state and the parent closes when all are done — partial success leaves it open with a comment.
AI merge flowThe assistant commits, pushes and opens the ADO PR itself (commit_worktree → push_worktree → create_pull_request), and can resolve merge conflicts (resolve_pr_conflicts) then re-push until the PR is clean.
GuardrailsNever force-pushes, refuses protected branches (main/master), refuses failed runs, blocks concurrent runs on the same item (parent/child included), and warns on stale branches.
Auto-reviewGit diffs are reviewed by the LLM on completion with a merge recommendation; AGENTS.md context is injected into every agent handoff.
Clean Up After MergeRemoves a merged run's worktree and deletes its branch — only when the PR is actually merged — from the view or as an auto-offer.
Summary panelCompletion summaries open in a styled HTML panel with metadata and duration; batch cleanup removes all completed worktrees at once.
⑂Git Workflow5
Branch on pickupAuto-creates feature/ADO-<id>-<slug> branches when a task starts (slugged from the work item title).
Changelog on completionUpdates CHANGELOG.md when a task finishes, with optional auto-commit and posting the entry back to ADO as a comment.
PR on doneOffers to push and open a PR via gh when a task completes; protected-branch checks keep the AI honest.
Worktree diff viewerShow Changes opens the VS Code diff editor for worktree files before you commit.
Safety checksWarns on branch switches with uncommitted changes; refuses to silently discard dirty worktree state (offers Commit & Push, then Remove). Pushing to the remote always asks first — adoCode.yolo.pushApproval (default on) keeps push_worktree and terminal git push approval-gated even in YOLO mode.
🧠Memory6
User memoryAI remembers your preferences across all sessions via /remember and /forget.
Workspace memoryProject conventions in .ado-code/memory/ — conventions, architecture, gotchas, custom — kept out of git/Docker via auto-ignore.
Agent hooksagent.before / agent.after keys run shell commands around every agent invocation (e.g. lint before, tests after), streaming output to the run panel.
Memory injectionUser + workspace memory is injected into the chat system prompt and into every external-agent handoff (“ADO Code Memory — instructions you MUST honor”).
Search & transferFuzzy QuickPick search across all memory entries; move entries between user and workspace scope.
Import / exportExport memories to JSON; import with merge or replace — memory survives reinstallations.
🧩MCP & Skills7
MCP serversModel Context Protocol support for external tool servers — configure in the UI, right-click to disconnect/reconnect/view details.
Skill catalogBrowse, install and manage reusable AI skills — 10+ built-in (Code Review, Documentation, Testing, Refactoring, Security Audit, Performance Profiler, Deployment Checklist, Database Schema Review, Accessibility Audit) with search and enable/disable.
AI skill executionThe AI can discover and run enabled skills mid-conversation via execute_skill; “Execute in Chat” injects the skill prompt and triggers the LLM.
Skill importBring your own skills from JSON, SKILL.md (YAML frontmatter + markdown) or .tar.gz/.zip archives — they persist across restarts.
Skill registriesBrowse community skills from remote TSV registries (slug<TAB>url<TAB>description) — registry skills are badge-marked and imported on install.
Project creation wizardMulti-step wizard for 9 templates — Node.js (TS/JS), Python, React, Next.js, Laravel, .NET Web API/Console, Empty. Creates projects anywhere: the open workspace folder (blank directories included) is used automatically or you pick one; ADO integration creates the work item in your active project, template option defaults pre-fill, the chosen initial branch is honored and invalid project names are rejected up front (/new-project).
File checkpointsAuto-save before AI edits, restore on demand — a safety net for autonomous runs.
✦Model Intelligence & Context11
Capability detectionVision and tool-calling support inferred per model — image attach is disabled for non-vision models, and models without tools get a persistent warning. Three layers: per-model overrides > live gateway data > name heuristic.
Capability overridesadoCode.llm.capabilityOverrides declares vision/tool support per model id when auto-detection is wrong — edited as structured rows in the Configuration page.
Dynamic context windowContext size auto-detected from /models (Ollama n_ctx, OpenRouter context_length…) — live data overrides the built-in table. Known models now match by longest key first with word-boundary guards, so o1-mini resolves to 128k instead of falling through to o1 and unrelated ids containing o1 don't false-match.
Context managementPriority-based truncation replaces a naive turn cutoff, now budgeted against maxTokens − overhead (system prompt + tool schemas) so a large prompt can't overflow the window; content-aware token counting (dense code/JSON ≈ 2.8, prose ≈ 4.5 chars/token, CJK ≈ 1.5 tokens/char); conversation auto-condenses at 75% via LLM summarization.
Native token countingStatus bar uses the provider's own tokenizer (Anthropic count_tokens; OpenAI-compatible usage.prompt_tokens) with local estimates as fallback — forced on for Anthropic, and the count includes the current system prompt. The local heuristic is just as honest: it charges for every block actually sent — tool-call argument JSON, tool-result payloads and image blocks (size-based) — and the host sizes truncation and status-bar overhead from the real system prompt (memory + understanding + work-item context), not a fixed estimate.
Per-mode modelsAdvanced mode assigns different models and reasoning effort (low/medium/high) per mode — { "inline": "gpt-4o", "act": "o3" }.
Token optimizationTool results are capped to a token budget and compacted after the model has seen them; plan mode sends only read-only tool schemas.
Understanding cacheA durable, fingerprinted cache in .ado-code/understanding/ holds repo facts, the selected work item and prior-session knowledge — injected into every chat session and every delegated-agent prompt. Invalidates on git HEAD/branch or config change; the LLM repo summary regenerates async (adoCode.understanding.autoSummarize).
AGENTS.md stays currentThe understanding cache now feeds AGENTS.md: generated when missing, and updated in place when build/test/lint commands, project structure or the refreshed summary drift — only the block between the <!-- ado-code:managed --> markers is rewritten, so your hand-written sections survive every sync. The update offer names the exact drift reasons with a diff Preview, and stops re-asking once you decline a candidate (adoCode.understanding.agentsMdSync; ADO Code: Refresh Repository Understanding re-runs the check).
Structure-first project studyOn an unfamiliar codebase the model orients on directory structure and docs first — the cached Repository Understanding, list_workspace, README / AGENTS.md / docs / package.json — then drills into key files with narrow read_file ranges or search_files, avoiding bulk whole-file reads that stay in the conversation all session. The same guidance reaches the chat system prompt, tool descriptions, delegated-agent handoffs and the cached repo summaries.
Token-accounting overhaulTool output is capped by the content's actual chars-per-token density rather than a flat ratio, so capped payloads don't overshoot their budget; Anthropic native counting serializes tool turns into real tool_use/tool_result blocks (no silent HTTP 400s); and OpenAI reasoning models are skipped instead of probed with a wasteful max_tokens: 1 call.
⚙Configuration & UX14
Configuration pageSettings grouped into sidebar categories — Connection, AI & Modes, Permissions, Workflow, Integrations — each with a setting-count badge; Advanced toggle gates per-mode models, capability overrides, choice detection and native token counting. Model pickers — main model, per-mode rows, choice-detection model and capability overrides — are dropdowns auto-filled from the provider's model list when credentials are saved (type-a-custom-model escape hatch and Refresh buttons included), not bare text fields.
Focused wizard viewsOpening the Configuration page, the project wizard or first-run setup collapses the sibling sidebar views so the wizard gets the full view container — they are restored when it closes, and views you had hidden yourself stay hidden. The chat kebab’s “Configuration…” now opens the in-app Configuration page instead of VS Code’s native settings.
Consent systemWith Auto-approve harmless commands on, read-only terminal commands (git status/diff/log, npm test, ls, grep…) execute instantly — no consent card, no countdown (off = they ask like any other tool). Every consent card and in-chat confirmation shows a live countdown naming what happens on expiry — “Auto-approving in 0:17” / “Auto-denying in 1:59” / “Auto-cancelling” — enforced host-side, and the countdown pauses while you're away: switching views or opening a full-page wizard freezes it and it resumes with the exact time left. Tool auto-approve accepts wildcards (read_*, get_*, edit_file); the Act-mode terminal allowlist supports git *, npm run *.
SessionsAuto-create on first message, /resume to continue, per-project retention caps, and /clear-sessions / “Delete All Sessions” to start completely fresh — persistence keeps only the last 25 message pairs so restores stay slim.
Keyboard shortcutsCtrl+Shift+M (cycle mode), Ctrl+Shift+/ (search memories), Ctrl+Alt+R (refresh status).
Update changelogAfter a version change, a one-time notification offers the new version's changelog in a styled webview panel.
Workspace scaffoldingNew-project wizard generates code, AGENTS.md and git init prompts; workspace-to-ADO binding keeps you in the right project.
DiagnosticsTree expansion counts, raw System.Parent samples and per-refresh tree shapes are logged to Output → ADO Code — a flat tree is instantly diagnosable.
Chat in the editor areaLift the chat out of the sidebar into a normal editor tab — from the chat view's title action or the kebab's Move chat into Editor Area — and send it back with the editor-title button, the sidebar/kebab Return Chat to Side Bar, or simply by closing the tab. History, session state and drafts survive the round trip.
Interactive Mermaid diagramsFenced ```mermaid blocks render as real diagrams — flowcharts, sequence, class, state, ER and Gantt — in the chat, Task Details, Work Item Details and Agent Run Summaries. Each carries a 📊 Diagram | </> Code toggle and a Copy Code button, adapts to light/dark/high-contrast themes, and falls back to code view with an inline error banner when syntax is incomplete.
Mermaid SVG exportSave SVG writes the rendered diagram through a native VS Code save dialog with an auto-detected title, sanitized filename and XML declaration (browser-download fallback); Copy SVG puts the markup straight on the clipboard for docs and PRs.
Branding & secondary sidebarCustom extension and Activity Bar icons replace the generic ones, and the same views are mirrored into a Secondary Side Bar container (“ADO Code (Secondary)”) so the backlog and chat can dock on the right rail.
Header quick actionsFrequent actions sit one click away instead of in the palette: a Refresh Work Items button in the Work Items view title toolbar, plus the adoCode.rerunWizard (re-run setup) and adoCode.openSettings (open configuration) commands.
Per-organization PATsEvery adoCode.organizations entry accepts an optional pat field that overrides the global adoCode.adoPat for that organization — one token per tenant without swapping the global one.