Skip to content
| Marketplace
Sign in
Visual Studio Code>AI>AgenturaNew to Visual Studio Code? Get it now.
Agentura

Agentura

fosteev

|
5 installs
| (2) | Free
Claude chat in VS Code: context, cost, cache and limits gauges
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

Agentura

English · Русский

Claude chat for VS Code that shows what Claude Code keeps out of sight: context in tokens, cost per turn, cache, subscription limits, which subagents are running and what they edited. It runs on the Claude Agent SDK, the same engine as Claude Code, through your installed claude and its login. Codex CLI is available as a second engine (see Codex).

Sidebar with limits and sessions, chat tab with a finished turn and the changes panel

Personal project, not on the Marketplace. Install it from a .vsix (see Install).

New in 0.23 — Antigravity ACP, subagents graph and /compact. Native agy acp sessions with live subagent timelines and transcripts, clickable conversation:// links, / slash commands, MCP server chips, context window gauge, /compact, bypassPermissions inheritance and /usage quota diagnostics. See Antigravity engine.

0.22 — redesigned session settings. Provider cards, grouped model and permission controls, advanced settings, and engine logos in chats. Codex chats attached to Jira tasks now start correctly.

0.21 — Cursor engine. Run Cursor CLI (agent acp) in a chat tab, with streaming replies, tool permissions, plan approval, Stop and session resume. See Cursor for limitations.

0.20 — native Codex planning and session controls. Planning, approval policy and sandbox have separate controls for the current session. Manual /compact, native skills selected by path and Jira tools in new chats are also available. See Codex for scope and remaining limits.

0.11 — MCP servers and skills in view. MCP calls carry a server chip in the feed, a skill call is a strip with "open SKILL.md", and an "mcp N/M" button by the input box (plus an "mcp" tab in the right panel) shows which servers are up. See MCP servers and skills.

0.10 — a "task" tab beside the chat. A chat on a Jira issue gets "chat | task" tabs: the full issue card (description, fields, comments, history, worklogs) and the live change feed, and you can change status, comment and log work right there. Since 0.9: chats grouped by Jira issue; one tab per task with its chats inside; Jira connected in Agentura or through Jiraffe 0.8; and Claude can comment, change status and log work on the issue, asking before anything but a short comment. See Jira tasks.

Features

  • Engines. Claude (default), Codex, Antigravity or Cursor, picked per tab in the "agent" menu under the input box.
  • Chat in editor tabs. One session per tab. Cmd/Ctrl+Alt+A opens a chat, Cmd/Ctrl+Shift+N starts a new session.
  • Gauges by the input box. Context with yellow and orange thresholds, cost and tokens per turn, cache TTL and hit rate, 5-hour and 7-day limits.
  • Permissions. Tool approval, agent questions and plan review (ExitPlanMode) are cards in the feed. Edits open in the native diff.
  • Remote Control. Keep driving a Claude session from claude.ai/code or the Claude mobile app: rc under the input box or /rc. See Remote Control.
  • MCP and skills. A server chip on every MCP call, a strip for each skill, an "mcp N/M" button and an "mcp" tab with server status. See MCP servers and skills.
  • Jira tasks. Chats grouped by Jira issue, a "task" tab with the full card and change feed beside the chat, and Claude can comment, change status and log work on the issue. See Jira tasks.
  • Sidebar. The project's sessions: search, resume, rename. Account and limits are shown above the list — for every installed engine (Claude, Codex, Antigravity), in one of five layouts.
  • Right panel.
    • changes lists files the session touched.
    • git is a working tree view where you stage, commit and push. Files the agent edited are marked.
    • agents shows the turn's subagents.
  • Agents graph. Opens in its own editor tab: who started whom, the prompt each agent got and the summary it returned, plus its live calls and canvas zoom (⌘/Ctrl + wheel, pinch, fit).
  • Attachments. Paste screenshots with ⌘V. Attach files with "+" or by dragging them in with ⇧ held. Text and PDF are sent as documents.
  • Look. Four feed styles, six input layouts, five agent views, three git layouts, three session list densities, your own fonts (bundled, installed or Google Fonts), separate text sizes for the feed and the rest of the interface.
  • English and Russian interface.

Feed styles

agentura.feed.style: journal, folded, replies, cards.

Four feed styles of the same turn

Input layouts

agentura.composer.layout: classic, card, statusline, gauges, minimal, shell. Keys and behavior are the same in all of them; only the arrangement changes. While a turn runs the field shows "↵ queue" and a stop button.

Six input layouts

Agents

agentura.agents.view: list, tree, lanes, cards. With graph the agent map opens in an editor tab.

Agent panel views: list, tree, lanes, cards

Agents graph in an editor tab

Git tab

agentura.git.layout controls the layout when the workspace has several repositories:

  • stack gives each repository its own section.
  • picker puts the repository list on top.
  • unified shows one list and makes one commit across the repositories you tick.

agentura.git.hideClean hides repositories with nothing to commit or push. Drag the top edge of the commit box to make the description taller.

The ✦ button asks Sonnet to write the commit message from the staged diff.

Git tab layouts: stack, picker, unified

Sidebar and settings

agentura.sessionList.view: detailed, compact, dense. With more than one engine installed, agentura.sidebar.limits lays out their limits: active (default — the current tab's engine expanded), stack, switch, table, header. agentura.sidebar.limitsHidden lists engines whose limits the sidebar hides (and stops polling). agentura.ui.animations turns subtle interface transitions and micro-animations on or off (prefers-reduced-motion always disables them). All settings are also on a settings tab (⚙ in the sidebar), with live previews.

Session list views

Settings tab, Appearance page

Install

You need:

  • VS Code 1.100 or newer.
  • Claude Code 2.1.285 or newer, installed and logged in (claude, then /login).
  • Optional, for the Codex engine: Codex CLI, installed and logged in (codex login).
  • Optional, for the Cursor engine: Cursor CLI, installed and logged in (agent login).

The extension does not ship the engine binary (200+ MB). It finds the system claude in PATH, ~/.local/bin, ~/.claude/local or Homebrew (on Windows it looks for claude.exe). To point it somewhere else, set agentura.claudeExecutable.

code --install-extension agentura-0.23.0.vsix

To build from source:

npm ci
npm run check      # types, lint, unit tests, build
npm run package    # agentura-0.23.0.vsix

Codex

Pick Codex in the "agent" menu of an empty tab, or set agentura.defaultProvider (the menu writes it, so the next new tab opens on the same engine). A tab keeps its engine for the whole session. Agentura starts codex app-server per tab and talks to it over stdio, the same way it runs claude. Approval policy and sandbox come from your ~/.codex/config.toml initially. The separate planning, approval and sandbox controls apply only to the current session; Agentura does not write the global configuration.

The MCP panel can enable or disable individual Codex servers for the chat's working folder. It updates only enabled in that folder's .codex/config.toml and reloads MCP for the current chat. Other chats pick up the change after MCP reload; tools change from the next turn. Codex must trust the project for project configuration to apply. Plugin-managed servers have no switch.

In Settings → New session, Claude and Codex have separate model and permission defaults. Cursor has one model field (agentura.cursor.defaultModel): an ACP model id from a live session’s model menu, for example composer-2.5[fast=true]; empty leaves the engine’s choice. Claude uses the existing model, mode and effort fields. Codex has a model list from the installed CLI, an effort list for the selected model, approval policy and sandbox. Changing the model clears an incompatible effort. Empty Codex fields inherit the CLI configuration. These defaults apply to new chats; resumed sessions keep their settings. Read-only and workspace-write presets disable network access. Full access requires agentura.allowBypassPermissions.

Supported: streaming replies, Stop, the model and effort pickers, command, file-change and permission approvals, agent questions, images in a message, tool rows, the changes and agents tabs (subagent graph, status, and summary), the context size next to the input box (after the first turn: until Codex reports its window, there is no gauge), and session history: the sidebar lists the recent Codex threads of the project folder, up to 500 (including ones started in the Codex CLI), and you can resume and rename them. When codex is installed, the sidebar starts a short codex app-server to read that list (at most every 30 seconds); a thread started in the CLI shows up on the next refresh.

Also supported: manual /compact with queue/Stop handling; native skills listed by the CLI, explicit selection by path and opening the matching SKILL.md; Jira comment/transition/worklog host tools in new chats. Jira writes keep Agentura's approval rules. Resumed chats and changed Jira bindings/tool settings require a new chat for Jira tools. Native planning has its own default / plan picker, /plan and Shift-Tab; it never changes permissions. Plans stream into the feed as text. Continue by selecting default and sending an instruction; no synthetic plan approval card is created. The approval and sandbox pickers become available after the thread opens and can be changed while idle with no pending requests. Menus show the complete current policies. Selecting the current sandbox preserves its exact roots, network and temporary-directory settings. New read-only/workspace-write presets disable network. Workspace-write also excludes implicit temporary write roots; these flags do not restrict reading temporary files. Full access requires an explicit choice and agentura.allowBypassPermissions. Pending changes wait for the server; errors keep the last confirmed state.

New Codex chats offer agentura_record_agent_launch, asking the main agent to record the exact task and parameters before spawning a direct child. The panel and graph show this separately as “Task recorded by parent”; it does not verify the actual Codex request. If the agent skips registration, no record is shown. Records include the full text and persist outside the project in ~/.local/share/agentura/agent-launches, including across history reloads. Deleting this directory removes only these records. Existing chats do not acquire the new tool retroactively.

Remaining limits:

  • Codex has no native plan-acceptance callback equivalent to Claude ExitPlanMode; approval/refine/deny plan cards remain Claude-only.
  • Live input/output/cache-read counts appear in turn summaries; USD cost, cache TTL and Claude auto-compact thresholds are unavailable. Subscription limits remain in the sidebar. Restored per-turn usage is unknown.
  • Text attachments are included in the prompt. Images are supported; PDF/document blocks are not.
  • Subagent status and summary are available; individual Stop/transcript actions are not implemented and are hidden.
  • MCP supports reload-all; per-server reconnect/toggle is unavailable. Browser changes apply to a new Codex chat.
  • “Always” on a command approval writes a permanent rule to ~/.codex/rules; the card says so.
  • Diffs show changed fragments, not reliable whole-file before/after snapshots. Remote Control is not integrated.

The app-server protocol is experimental. Schema checks and handshake were run with codex-cli 0.166.0; new feature flows have automated adapter/UI tests, but live model turns were not run for this change. See docs/codex-protocol.md before updating.

Cursor

An empty tab can run on the Cursor CLI: pick Cursor in the engine menu, or set agentura.defaultProvider to cursor. Install the CLI and sign in with agent login. Agentura starts agent acp per tab (stdio, one JSON-RPC message per line) and accepts the agent binary only when agent --version or agent about reports a Cursor build. Point agentura.cursorExecutable at another path on the same settings page as Codex (⚙ → Engine, with a check button).

v1 has no cost gauge, no context ring, no MCP toggle, no subagents, and no auto-accept of edits. acceptEdits is the same as the default agent mode: permission cards still ask. bypassPermissions is downgraded unless agentura.allowBypassPermissions is on. Stop sends session/cancel and leaves the process running. The sidebar lists the folder's Cursor sessions by session id; opening one resumes it. If the binary is missing, the tab says it was not found and the Claude and Codex lists stay.

Antigravity engine (experimental)

A chat tab can also run on Google's Antigravity CLI (agy): pick it in the engine menu of an empty tab, or set agentura.defaultProvider to antigravity. Models inside agy include Gemini, Claude and GPT.

Agentura requires agy >= 1.5.0 (standard: 1.5.6+) and connects via the official ACP protocol (agy acp, JSON-RPC 2.0 over stdio). Agentura finds the binary in PATH, ~/.local/bin or Homebrew; agentura.antigravityExecutable points elsewhere (⚙ → "Engine" has a check button). When signed out, the sidebar offers interactive sign-in via agy acp --login.

In Settings → New session, Antigravity has default model and reasoning effort settings (agentura.antigravity.defaultModel, agentura.antigravity.defaultEffort), populated live from agy models. Changing the model adjusts supported effort levels (low, medium, high); models without effort levels (such as gpt-oss-120b-medium) disable the selector. These defaults apply to new chats; resumed sessions keep their settings.

Supported features:

  • Streaming replies, API retry badges and Stop: text and reasoning blocks stream in real time, transient Cloud Code retries (⚠ API error (attempt N)) collapse into compact api_retry badges instead of polluting the reply text, and Stop sends session/cancel while leaving the process alive for subsequent turns.
  • Slash command autocomplete (/): server-advertised commands (available_commands_update) populate the / menu in the composer on session start and resume.
  • Live permissions: file edits and bash commands prompt for approval in the feed (Allow, Deny, or Allow edits) without restarting the process.
  • Native modes and subagent permission inheritance: switch between default (ask per action), accept-edits (auto-approve workspace file edits), and plan (text planning), while preserving server-side auto mode on resume. bypassPermissions (when agentura.allowBypassPermissions is enabled) runs agy acp --dangerously-skip-permissions so child subagents and worktrees inherit auto-approval, transparently rotating the worker via session/resume when toggled.
  • Subagents graph, transcripts and conversation:// links: live subagent tree (AgentsGraph), inline AgentGroup cards, the agents tab (including nested subagents, background bash tasks, waiting_for_input detection, and send_message reopening), history reconstruction, read-only Markdown transcripts, and clickable conversation://<uuid> links that open the referenced session in an Agentura chat tab.
  • Images: image attachments in messages are sent as ACP image blocks.
  • Interactive questions: ask_question renders interactive single- and multi-choice cards (elicitation/create) with answers returned to the agent in the same turn.
  • Diffs, MCP chips and orchestration tools: tool calls render native cards (Bash, Read, Edit, Write, WebSearch, Agent), eager and lazy MCP calls render server chips resolved against <dataDir>/mcp, orchestration tools (manage_subagents, send_message, define_subagent, manage_task, schedule, swarm) have structured feed labels, and file diffs are extracted directly from ACP updates without writing to ~/.gemini.
  • Session history: the sidebar lists project conversations via session/list (filtered by workspace folder), resuming uses session/resume, opening past threads replays history via session/load, and late server-generated titles (session_info_update) update automatically. Session renaming works via Agentura's index.
  • Account quota diagnostics and manual refresh: quota pools from agy -p "/usage" (general Gemini 5h/7d, Claude/GPT 5h/7d, and dedicated model pools such as Gemini 4 Argon / Gemini 4 Carbon; polled every 10 minutes with a 60s error cooldown) show in the compact HUD and in the limits panel, surfacing Eligibility check failed / network errors while preserving cached rings and supporting manual refresh.
  • Context window gauge and /compact: tracks used and available context window tokens (1M for Gemini, 200k for Claude, 128k for gpt-oss-120b; reading the transcript.jsonl tail with single-step ACP fallback), recalculates the remaining window immediately on model switch in active chats without losing history, and supports manual context compression via /compact.

Remaining limits:

  • No USD cost estimation (ACP does not report token prices).
  • No native plan acceptance card (plans stream as text).
  • No PDF/document attachment blocks.
  • No per-subagent stop button in the UI (agentStop: false — ACP has no client RPC to cancel a single child conversationId).

Jira tasks

Chats on the same Jira issue are grouped under it in the sidebar (agentura.tasks.sidebar: groups or section). Start one with "Agentura: Chat for Issue…" (a key or a link), "Open in Agentura" in the Jiraffe extension, or bind an existing tab with "Bind to Issue…".

  • Source. agentura.jira.source: auto (default), jiraffe, own, off. Own connections are made with "Agentura: Connect Jira…" (Data Center or Cloud; the token goes to SecretStorage, per workspace). The Jiraffe integration needs Jiraffe 0.8.0. Everything is on the "Integrations" settings page.
  • Task strip and "chat | task" tabs. A strip with the issue above the feed carries the tabs. "Task" shows the whole card: description, attachments, fields, time and the task's chats, with sub-tabs Comments, History, Worklog and Changes (status, comments, worklogs; the agent's comments are highlighted, a comment from a person made during a turn shows a "send to agent?" notice). Status, a comment and a worklog are written from the card on your behalf, without a confirmation dialog; "to chat" attaches the task as a file. While "task" is open, "chat" shows a spinner or a dot when the agent works or waits for you. agentura.tasks.card: tab (default) or split (Jiraffe's card beside the chat, Jiraffe source only); the old panel and strip read as tab.
  • A tab per task. agentura.tasks.tab=task keeps one editor tab per task with its chats as inner tabs.
  • Agent tools (Claude). The in-process MCP server agentura_jira gives comment, transition and worklog on the chat's task, on your behalf. A short comment on that task is posted without asking; a status change, a worklog, a long or secret-looking comment, or anything on another task goes through the permission card, in every mode. agentura.jira.agentTools switches each tool off. The worklog carries this chat's token usage as AI Tokens (a Tempo attribute through Jiraffe, "(AI Tokens: N)" in the comment otherwise): input, output and cache writes of the main turns, without cache reads and subagents.
  • What reaches the model. The task's key and connection name; the issue card only when "Chat for Issue…" (or Jiraffe's "Open in Agentura") puts it into the prompt box and you send it; a person's comment only when you move it to the chat. The card and the change feed are polled by the extension and are not sent anywhere else.

Jira tasks: a task group in the sidebar, the "chat | task" tabs with the full issue card

Task code tab

The third tab of the task strip, chat | task | code N, collects everything the task produced in git: the repositories the task's chats worked in, the task branch against the base (origin/develop, main…), commits, and the files agents edited but have not committed yet (with the chats that touched them). Click a commit to see its files, click a file (or "commit diff", "branch diff") to open the diff in the same tab: inline | split, j/k for the next/previous file, Esc or × to go back to the list. "to chat ↳" puts the commit into the input box. The tab is read-only: committing stays in the git tab.

How commits are found ("how do we search?" in the tab shows these with your key and base, each with a copy button):

git log --all -i --grep='NEWMFC-1482' --format='%h %an %s'      # commits with the key in the message, all branches
git branch -a --list '*NEWMFC-1482*'                            # branches with the key in the name
git log --oneline origin/develop..feature/NEWMFC-1482           # commits of such a branch not in the base yet

A commit is found only if the key is in its message (NEWMFC-1482: …) or on a branch whose name has it (feature/NEWMFC-1482). "Uncommitted" is not read from git status alone: it is the files agents edited in the task's chats, so hand edits made without an agent are not listed.

New chats inside a task

With agentura.tasks.tab=chat the task strip shows the task's chats as chips: engine mark, title, a dot for a chat that is working, waiting for you or failed (a click opens it). The current chat keeps its turn indicators; with more than four chats the current one and the three latest stay, the rest are under "N more". A chat you no longer need goes to the archive: × on hover over its chip or "N more" row, or "Archive" in its right-click menu (a notification offers "Undo"; "Archive" in the sidebar brings it back). Archived chats leave the chips and "Chats for this task"; the chat of this tab stays. Three ways to start another chat on the same task:

  • "+ chat" (or "+" among the inner tabs with tasks.tab=task) opens a popover: the first message (optional), the engine (claude, codex, antigravity), what to carry over, where it works, and "create" or "beside" (next to this tab). Alt+click skips the questions: a new chat on this tab's engine with the task context.
  • /new [engine] [text] in the input box of a task chat: the first word may be claude, codex, agy or antigravity; the text becomes the first message and is sent by itself.
  • /fork [text]: the same on this chat's engine, plus a summary of this chat. Both commands exist only in task chats.

What goes to the new chat, each as a text attachment you can remove with the chip's ×: the task context (<KEY>.md, as in "Chat for Issue…"), a summary of this chat (<KEY>-handoff.md: goal, what is done, what is left, decisions, next steps; written by Claude whatever the source engine) and the task changes (<KEY>-changes.md: commits and uncommitted files from the "code" tab). Codex and Antigravity do not take files, so for them the attachments go into the message's context block (the feed does not show it). If the summary or the changes cannot be prepared, the chat opens without them and says so in a notification.

"Own worktree" runs git worktree add -b feature/<KEY>-<n> <repo>-<KEY>-<n> HEAD next to the repository and opens the chat there, so two agents do not edit the same files. Uncommitted changes of the source chat do not move over. The branch name carries the key, so the "code" tab finds it. Agentura never deletes the worktree; when the work is merged, run git worktree remove <path> (and git branch -d feature/<KEY>-<n>) yourself. A chat in a worktree keeps its folder after Reload Window.

The engine of the new chat is not saved to agentura.defaultProvider. Outside editors cannot start such a chat: agentura.openWithContext ignores a working folder and auto-send, and agentura.chatForTask ignores the summary, changes, worktree and "beside" options.

MCP servers and skills

What the agent reaches for is visible without opening /mcp.

  • In the feed. An MCP call shows a chip with its server before the tool name, red when the server is down; a Skill call is a strip "skill · invoked by agent" with "open SKILL.md" (for skills found in the project's or your .claude/skills). The turn summary adds mcp N and skill N when they are not zero.
  • "mcp N/M" by the input box. A popover with every server: status, version, tools, calls in this session, the skills used, and "retry" (Claude) or "reload all" (Codex). A yellow dot means a server failed or needs sign-in; Agentura only shows how to sign in (/mcp in Claude Code, codex mcp login <name>), it does not do it.
  • Turn a server off. Each server (except the built-in one) has a switch in the popover and in the "mcp" tab, with a source chip (user, project, claude.ai…). It turns the server off for the project (the chat's folder): its tools leave the context from the next turn, and it stays off for every chat in that folder and in Claude Code (disabledMcpServers in ~/.claude.json). Claude only; Codex has no per-server switch.
  • "mcp" tab. In the right panel: servers with their calls by tool, the session's skills and all available skills.
  • A line in the feed when a server fails to start or drops.
  • Where to turn it off. Settings, "Appearance", "MCP and skills": agentura.mcp.feedLabels, agentura.mcp.composerButton, agentura.mcp.panelTab, agentura.mcp.feedStatus (failures, start, off). Server status is for Claude and Codex; Antigravity reports none, so the button, the tab and the status line are hidden for it.

MCP and skills: server chips and a skill strip in the feed, the "mcp" tab with server status

Remote Control

A Claude tab can be mirrored to claude.ai: the session shows up in claude.ai/code and in the Claude mobile app, and you can continue it from there. Turn it on with rc under the input box (or /rc, /remote-control); the rc menu has a QR code for the phone, the link and a copy button. agentura.remoteControl turns it on for every Claude tab, and the rc choice in a tab overrides it for that tab (it survives /clear).

  • Turns still run on this machine: files, commands and approvals happen here. From claude.ai you can send messages, answer approval cards, agent questions and plans (whoever answers first wins), stop a turn, and change the model or permission mode (bypassPermissions only with agentura.allowBypassPermissions).
  • Messages typed there are marked "from phone" / "from claude.ai" in the feed.
  • It uses the Claude Code login (~/.claude/.credentials.json or the macOS Keychain), read when you turn it on, regardless of agentura.limits.readKeychain.
  • Closing the tab disconnects; the session stays in the claude.ai list. Each time you turn it on, a new claude.ai session is created and earlier turns of the tab are not copied there.
  • The engine's own --remote-control does not work in the headless mode Agentura uses, so the bridge is built on the Agent SDK's alpha bridge API. It may break on an SDK update.

Settings

Everything is under agentura.*. You can change it in the Settings UI or on the settings tab. These settings are read from user settings only, so a cloned repository can't change them through its .vscode/settings.json:

Setting Default Meaning
agentura.claudeExecutable empty Path to claude; empty means auto-detect
agentura.codexExecutable empty Path to codex; empty means auto-detect
agentura.antigravityExecutable empty Path to agy; empty means auto-detect
agentura.cursorExecutable empty Path to Cursor agent; empty means auto-detect
agentura.defaultProvider claude Engine for new tabs: claude, codex, antigravity or cursor
agentura.allowBypassPermissions false Allow bypassPermissions (Claude, Antigravity, Cursor) and explicit Codex full-access sandbox selection
agentura.remoteControl false Remote Control for every Claude tab
agentura.remoteControlNamePrefix empty Session name prefix on claude.ai; empty means the machine name

If agentura.defaultPermissionMode is set to bypassPermissions while bypass is not allowed, new sessions start in manual mode.

Known limitations

  • Login and ToS. Anthropic does not allow third-party products to offer claude.ai login without approval. Agentura has no login of its own and uses the CLI's login. That is fine for personal use, but publishing it would need either approval or API keys.
  • Limits come from an undocumented endpoint (/api/oauth/usage) and may break. If they do, the extension falls back to the engine's rate_limit_event, which doesn't say which window the limit belongs to.
  • Transcripts (~/.claude/projects/*.jsonl) use an internal format. Session totals are parsed from them and can drift after a CLI update.
  • Codex support is new and was tried on macOS arm64 only. The model list comes from your Codex account (model/list when the session starts).
  • Remote Control uses the Agent SDK's alpha bridge API and was tried against SDK 0.3.285 only. Approval requests opened before it was turned on are not sent to claude.ai.
  • Cost is an estimate. Your subscription bill is the source of truth.
  • Each chat tab runs its own claude (or codex app-server) process.
  • Subagents have no separate cost or token counts because the engine does not report them. Prompt and summary sizes are estimated from text length.
  • Tested only on macOS arm64. CI runs on macOS and Ubuntu, but nobody has used it by hand on Windows or Linux.

Development

npm run watch              # rebuild extension and webviews
npm test                   # unit tests (vitest)
npm run test:integration   # integration test in a downloaded VS Code
node scripts/vsix-verify.mjs [--live]    # check the built .vsix; --live runs one Haiku turn
node scripts/readme-shots/run.mjs        # re-render the screenshots above (needs npm run build)

Where things are:

  • src/agent is the SDK adapter.
  • src/data covers sessions, limits and prices.
  • src/extension is the extension host.
  • src/webview is the Preact UI.
  • prototype/ is the reference markup.

Agentura: Show State (debug) opens state fixtures without the engine. The scripts/*-smoke.mjs scripts run the live engine and spend tokens. The plan and decision log are in docs/roadmap/ (in Russian).

License

MIT

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft