Agent-Coder

Agent-Coder is a decision-critical, token-efficient AI software-development agent for Visual Studio Code. It helps you understand a real codebase, plan changes, investigate failures, review risks, and safely propose edits—without treating an AI response as authority over your files or project state.

It is built for developers who want AI assistance to be useful in day-to-day coding work while retaining control over what is read, changed, executed, and accepted.

Lite vs Pro — what actually changes

Lite is not a crippled trial. It's the real tool — 90 of Agent-Coder's 170 build phases, covering the entire grounded-editing loop: workspace indexing, architecture graph, planning, decision analysis, call-graph/concurrency/ownership analysis, patch proposals with diff preview and rollback, quality rules, AI-authorship detection, baselines/regression detection, and the full Local Test Laboratory. You can do real, safe, AI-assisted engineering on Lite alone, for free, indefinitely.

What a one-time Pro purchase adds is everything that turns Agent-Coder from "a very disciplined assistant" into a small engineering department working alongside you:

You want to...	On Lite	On Pro
Get a second opinion before trusting an answer	Ask one provider, read one response	Consensus & Debate Mode — every configured provider answers the same question; deterministic agreement scoring, not self-reported confidence
Stress-test a change before it ships	Manual review	Multi-Agent Command Centre — eleven adversarial reviewer roles plus an Engineering Control Centre mission-control view
See where risk actually lives in the codebase	Read the code	Project Map, Project Visual Link Map, Dependency Graph, Technical Debt Dashboard, AI Project Score, Bug Heatmap — deterministic, evidence-cited scoring
See the whole project as one living diagram, not a file tree	Scroll folders	Project Visual Link Map — a standalone, real-time top-down (or Landscape) tree of your entire project with drawn connector lines, cached instantly on open, and a small AI-fill button on every node
Predict what a change will cost or break	Guess, then find out	Digital Twin, Time Machine, Cost Estimator, Change-Impact analysis — Predictive Engineering Intelligence layer
Get one fully-verified answer instead of a raw model response	A single AI reply	AI Answer Orchestrator — routes through consensus, evidence validation, self-critique, and risk assessment before you see it
Keep AI-written code held to a higher bar	Basic AI-authorship detection	SlopGuard: authorship-calibrated scrutiny, routing feedback by provider/model, pre-commit gating, rule refinement — full Slop Control Centre
Reuse what already worked	Nothing persists	Prompt Replay, AI Memory Browser, Prompt Chain & Workflow Builder — save and re-run what you've already proven out
Know which model is actually reliable for you	Pick blind	AI Health Dashboard & Adaptive Provider Routing — real per-provider/model accuracy, hallucination, and failure rates
Turn a session into a shareable artifact	Nothing exported	Engineering Session Recorder — Problem → Evidence → Reasoning → Changes → Validation → Lessons-Learned, exported as Markdown/HTML/PDF
Connect real external tools safely	N/A	Connected AI Platforms & read-only headless MCP — governed native/inbound/outbound MCP with trust, audit, and revoke controls
Let Agent-Coder work with less hand-holding	Fully manual	Controlled autonomy & economy modes — budgeted, checkpointed, failure-classified automation, still under your policy

One purchase, lifetime activation, every future Pro release included — see the purchase box above for the details. If you're already relying on Agent-Coder day to day on Lite, Pro is the upgrade that stops you from doing by hand what the tool can already verify, cross-check, and remember for you.

Lite proves the tool works. Pro is where you actually see what this system is capable of — a live, continuously-updated Project Visual Link Map of your whole codebase you can annotate, question, and steer in real time; a full mission-control layer of deterministic reports (Technical Debt & Project Score, Bug Probability Heatmap, Digital Twin, Time Machine); and every advanced report on top of them. If you're doing this professionally — not just looking for a quick, cheap answer here and there — the Pro tier is the difference between a helpful assistant and a real engineering command centre working alongside you. One purchase, lifetime activation. Activate it from Settings or the status bar when you're ready.

Why Agent-Coder

Click here to see about this agent online

Most "AI coding assistants" are a chat window bolted onto an editor: you paste in a problem, an AI improvises an answer, and you're left to verify whether it actually applies to your project. Agent-Coder is a different category of tool. It is a full systems and software development agent — not a narrow code-completion add-on — built to reason about real engineering problems the way a disciplined senior engineer would: gather evidence first, plan the change, validate every claim against the actual codebase, and only then propose an edit for human approval.

That difference shows up everywhere:

• Grounded, not improvised. Every answer is built from an indexed, evidence-backed model of your actual workspace — architecture, dependencies, call graphs, build/test output, Git state — instead of a plausible-sounding guess from a single prompt.
• A deterministic pipeline sits above the model. Structured-response validation, schema/invariant checks, prompt-injection detection, and project-rule enforcement all run before any AI output reaches your files. The AI proposes; a governed system disposes.
• Engineering discipline, not just code generation. Architecture decision records, technical-debt tracking, provenance, root-cause verification, risk assessment, and a persistent project memory turn one-off answers into an accumulating, auditable engineering record.
• Provider-agnostic and cost-aware. Route work across 14 hosted API-key providers or a fully local model — with token budgets, caching, and adaptive routing so capability scales without runaway cost.
• Safety by construction. File-hash guards, diff previews, backups, rollback, and controlled-autonomy limits mean powerful automation never comes at the cost of losing control of your repository.

The result is a tool built for the entire lifecycle of real-world development — planning, architecture, implementation, debugging, review, validation, and governance — not just the moment of writing a function. Where most assistants stop at "here's some code," Agent-Coder verifies, constrains, and coordinates the work the way production engineering actually demands, which is why it is designed to outperform single-shot, unverified AI coding tools on every measure that matters in a real codebase: correctness, safety, cost, and auditability.

What makes Agent-Coder different

Many AI coding tools begin with a prompt and immediately produce code. Agent-Coder starts with the project:

• It indexes the workspace, detects languages, build systems, frameworks, entry points, dependencies, and source layout.
• It gathers relevant evidence from actual files before asking an AI provider to reason about the task.
• It validates structured AI responses, checks project rules, presents a real diff, and normally requires your approval before a write reaches disk.
• It keeps deterministic local systems responsible for project state, file integrity, policy enforcement, validation, and completion status.

In short: the AI can recommend and generate; Agent-Coder checks, constrains, and coordinates.

How it benefits AI-assisted developers

Agent-Coder is designed to make AI coding more dependable and less wasteful.

When you need to...	Agent-Coder helps by...
Understand an unfamiliar repository	Building a project index, architecture graph, dependency view, semantic search results, and focused context from real source files.
Plan a feature or fix	Breaking the request into dependency-ordered tasks, extracted requirements, assumptions, evidence, alternatives, risks, and confidence.
Diagnose a failure	Combining build/test output, workspace evidence, Git context, debug hypotheses, and root-cause tracking instead of relying on a guess from one error message.
Change code safely	Producing hash-verified patch proposals, checking invariants and quality rules, previewing diffs, backing up files, and supporting rollback.
Keep AI cost and context under control	Selecting relevant files, applying token budgets and ceilings, avoiding unnecessary AI calls, caching appropriate responses, and routing work to suitable models.
Review a change before merging	Providing change-impact, call-graph, concurrency, ownership, accessibility, schema/API, dependency, licence, and technical-debt analysis.
Work across several AI surfaces	Using the sidebar chat, VS Code's native @agent-coder chat participant, Command Palette commands, dashboards, or the optional MCP bridge.

A practical workflow

1. Open a workspace and let Agent-Coder analyse it. A startup scan warms the project index; you can also run Agent-Coder: Analyse Workspace at any time.
2. Ask, search, plan, or analyse before editing. Use ordinary chat language or focused commands such as /plan, /debug, /review, /design, and /security.
3. Request a change. Agent-Coder selects grounded context and creates a patch proposal rather than directly overwriting files.
4. Inspect the real diff. Review validation findings, rule/invariant results, and the exact proposed change.
5. Approve or reject. By default, a proposal is not applied until you explicitly approve it. Applied edits can be rolled back.
6. Build, test, and validate. Use the detected project toolchain and retain the evidence needed to judge whether the task is actually complete.

This workflow deliberately makes the human decision point visible. You can use Agent-Coder for explanation and analysis only, or allow it to help progress through carefully bounded repairs and edits.

Core capabilities

Grounded project understanding

• Workspace discovery, incremental indexing, project snapshots, language/build/framework detection, and generated-code suppression.
• Hybrid and semantic code search, symbol slicing, context manifests, progressive disclosure, and relevance scoring.
• Architecture knowledge graph, dependency visualiser, project map, call-graph analysis, concurrency analysis, and resource-ownership analysis.
• Complete adapter contracts for 117 languages and scripts. TypeScript/JavaScript, Python, C/C++, C#, Go, Rust, Swift, Delphi, Lua, assembly and web assets use bespoke adapters; the other 104 use the same fully executable contract through declarative toolchain profiles rather than the former detection-only generic tier. All 117 receive recursive project detection, indexing and symbol extraction, dependency extraction where the language has imports/includes, safe formatting/tool discovery, lint/live validation, project build discovery (or a bounded project-wide validation fallback), test-entry-point discovery, and normalized diagnostics/results. Missing SDKs or project manifests are reported as tool/environment evidence, never as an unimplemented language adapter. Coverage spans Java/Kotlin and JVM languages, .NET languages, native/functional/scientific/legacy languages, shell scripts, shaders and HDLs, data/config/markup formats, web frameworks, Dockerfile and Makefile, and the complete list in the internal development plan.

AI-assisted reasoning

• Task decomposition and requirements extraction.
• Decision analysis with evidence, assumptions, alternatives, and confidence scoring.
• Architecture, debugging, refactoring, performance, security, comparison, research, and teaching modes.
• Debug hypotheses, diagnostic-artifact analysis, experiment tracking, and root-cause verification.
• Test generation and test-adequacy assessment, with structured-response validation before results are used.
• OpenAI requests use the token-limit field required by each transport: current Chat Completions calls use max_completion_tokens, Responses API calls use max_output_tokens, and third-party/local OpenAI-compatible endpoints retain their established max_tokens contract.
• Sidebar chat history survives switching views and extension-host recreation until Clear Chat is explicitly used. Large text pastes become removable attachments instead of filling the prompt box; pasted PNG, JPEG, GIF, and WebP images become bounded multimodal attachments for OpenAI-compatible and Claude Ask/reasoning requests. Persistent history stores attachment metadata, not raw payloads.
• The Lite Token Budget panel persists provider-reported usage in .agent-coder/token-ledger.json across sessions, records quality passes, schema retries, and failed attempts, and shows recent calls plus the files/context where tokens were spent. Multi-file usage is allocated without inflating the exact provider total; clearing chat does not clear budget history.

Safe editing and validation

• File hashes and guarded paths help prevent a patch from being applied to stale or protected content.
• Patch schemas, semantic checks, patch-granularity checks, quality rules, project invariants, and prompt-injection detection run before an edit is offered.
• Diffs are previewed before approval; backups and rollback support are available after application.
• Multi-file proposals, generated tests, documentation comments, and deterministic formatting cleanup use the same review-and-approval model.
• Build, test, validate, repair, regression, baseline, performance-budget, schema, API-contract, serialisation, and accessibility workflows help verify outcomes.

Engineering governance and learning

• Architecture decision records, project invariants, user preferences, technical-debt tracking, provenance, solution patterns, and documentation-impact analysis.
• Persistent project memory, rejected-approach tracking, corrections, checkpoints, and diagnostic-causality reduction. Verified local records are ranked against the current task using source/file/symbol/diagnostic overlap, freshness, verification strength, historical success, contradictions, and token cost; stale, conflicting, and unverified records are withheld. Retrieval decisions are shown locally and memory content is not automatically transmitted to configured provider endpoints.
• Pro AI Intuition turns user teaching into inactive, structured rule proposals that can be simulated, edited and explicitly approved before use. Scoped rules and named prompt strategies remain local, inspectable, versioned, disableable and reversible. Every tracked provider request is assembled as a source-labelled engineering question with unknowns, acceptance criteria, validation and stop conditions. Strategy learning uses comparable verified outcomes only; provider confidence is never treated as proof, and security/user/invariant/ADR/AUTO policy always outranks learned preferences.
• Git status/diff support, checkpoints, branch and commit-message assistance, plus change-impact awareness.
• Controlled autonomy limits for time, files, commands, repair attempts, token use, and AI requests.

Visibility and optimisation

• Dashboards for project mapping, dependencies, technical debt, project score, AI confidence, token use, memory timeline, workspace/build/memory optimisation, and engineering control.
• Token policies, cost/benefit gates, response caching, resource-pressure handling, model capability routing, and performance acceptance checks.
• Workspace goals, design proposals, refactoring simulation, performance simulation, learning-mode symbol explanations, and AI pair-programmer diagnostics.

Conversation Intelligence Layer

A dedicated layer over every "ask" — grounded in the principle that an AI response is one input to a deterministic pipeline, not the final answer on its own:

• Chat Command Language — /architect, /debug, /review, /refactor, /design, /security, /performance, /compare, and /research each force a specific reasoning scope and context-loading strategy, plus silent prompt/question optimisation on every request.
• Response Quality Modes — pick a reasoning depth (Instant/Standard/Professional, or Pro-only Critical/Scientific/Architecture/Research/Verification) for how much a single answer costs and how hard it tries.
• Context Inspector & Missing-Information Gate — see exactly what context an answer will be built from before it's sent, and a deterministic confidence check that holds back a low-evidence request rather than guessing.
• Evidence Viewer, Answer Verification, Self-Critique & Risk Meter (Pro) — per-paragraph evidence classification, a staged Verifier/Fact Checker/Project Validator pipeline, a bounded self-critique pass, and a five-category risk rating — every rating is either measured or honestly marked "insufficient data," never a freestanding guess.
• Consensus & Debate Mode (Pro) — /consensus asks every configured AI provider the same question and reports a real agreement percentage; /debate runs a bounded two-round argue/rebut exchange between two reviewer roles with a final recommendation.
• Prompt Replay, AI Memory Browser & Prompt Chain/Workflow Builder (Pro) — every successful ask is recorded as a reloadable reasoning chain; a searchable browser reloads its full trace, and a workflow builder lets you save and re-run a named sequence of existing actions. The Prompt Chain, Workflow Builder & Lifecycle panel has a "Clear History" control that deletes saved workflows and clears recorded stage traces, without touching the underlying replay records memory search and the Engineering Session Recorder still rely on.
• AI Health Dashboard & Adaptive Provider Routing (Pro) — a real per-provider/model accuracy, hallucination-rate, and response-time table that also feeds back into model recommendations once enough real samples exist.
• Engineering Session Recorder (Pro) — composes a recorded session into a Problem → Evidence → Reasoning → Changes → Validation → Benchmarks → Lessons-Learned report, exportable as Markdown, HTML, or PDF.
• AI Answer Orchestrator (Pro, capstone) — /orchestrate <question> runs the full pipeline above as a single named entry point (Intent Classifier → Requirement Extractor → Evidence Collector → Context Optimiser → Prompt Optimiser → AI Provider(s) → Consensus Engine → Evidence Validator → Self-Critique → Risk Assessment → Project Rule Validator → Final Engineering Report), replying with a stage-by-stage trace so it's never a black box about what actually ran for a given question.

Choose how you interact with it

Agent-Coder provides several interfaces over the same controller and safety pipeline:

• Agent-Coder sidebar: a persistent conversation view in the VS Code Activity Bar.
• Native VS Code Chat: use @agent-coder with commands such as /ask, /plan, /fix, /implement, /auto, /memory, /validate, /callgraph, /debug, /review, /teach, /consensus, /debate, /orchestrate, /route, and /platforms. /memory <what to remember> is available in Lite and Pro and sends Save to Memory: <what to remember> directly to the active AI provider, then shows its response. /fix <what> is always project-wide: with AUTO and Project-Wide Fix enabled it immediately applies validated changes as one rollback batch, otherwise it opens the normal review-and-approve flow. /implement is a forced Pro action that bypasses Agent-Coder's local token boundaries plus normal edit review; /auto opens the Pro-only workspace rules and task runner.
• Visible sidebar errors: responses beginning with Error: (including markdown-emphasised variants) render in a dedicated card with a red-gradient title bar and dark-maroon body, keeping the complete failure text prominent and copyable.
• Command Palette: use focused commands for workspace analysis, build/test/repair, governance, project analysis, settings, and dashboards.
• MCP bridge: use the standalone agent-coder-mcp server from compatible tools such as Claude Code or Codex CLI while an Agent-Coder-enabled VS Code workspace is open.
• Connected AI Platforms (Pro): manage native VS Code and inbound/outbound MCP attachments, workspace-scoped capabilities, trust, connection lifecycle, real usage/approval counts, audit, and revoke controls.
• Read-only headless MCP (Pro): run agent-coder-headless as a separately licensed/allowlisted process with four bounded read-only analysis tools. Remote-enterprise operation remains disabled.

All of these routes share the same workspace understanding, proposals, approvals, and controller logic—there is no separate “unsafe chat” path.

Every Agent-Coder, VS Code, imported MCP, provider-native, and plugin tool descriptor is evaluated by one Unified Tool Policy Engine. Effects/risk—not a friendly name—drive permissions, timeouts, concurrency and authenticated approval. Tool/model/project content cannot approve itself or expand permissions. Use /route <strategy> <question> for explicit fallback/race/consensus/debate/ specialist/verification/ensemble routing; single-model-first remains the default and performance records stay N/A until enough real samples exist.

[!TIP] 🔑 Purchasing a PRO License

To purchase a PRO license, visit Ultimanium.com and register an account if you haven't already. Account registration is free for all users, but VPN usage on the site is strictly forbidden.

From there, purchase Agent-Coder for a small, one-time fee that helps contribute to the continued development of this agent. There are no subscriptions, no renewals, and no recurring charges — you pay once and that's it.

Immediately after checkout you'll receive a confirmation email acknowledging receipt of your order details. Then log in, and on the side panel you'll be able to view your existing orders. Open the order you purchased to view your serial number. Use this in the Settings of Agent-Coder along with the username and password you used when creating your Ultimanium account, then press Activate — if successful, your registration will be upgraded to the PRO version.

What a one-time purchase gets you:

• Lifetime activation. One payment unlocks PRO forever on your account — no expiry, no re-purchasing to keep features you already have.
• All future upgrades included. Every update released to Agent-Coder's PRO tier from that point on is yours automatically, at no extra cost — you will never be asked to pay again.
• No limitations. The full PRO feature set is unlocked from day one — nothing metered, throttled, or held back behind a further tier.
• Forever support. Ongoing support for your license and installation, for as long as you use Agent-Coder.

Think of it less as a purchase and more as a one-time contribution: a single show of support in return for a lifetime of the tool's full capability. What that capability unlocks is up to how you want to work — PRO is what lets you get the most out of pairing with an AI provider rather than just prompting one. It's built to let you and the model work side by side, sharing real project context back and forth instead of trading disconnected messages, and to let you govern that collaboration through the MCP protocol so the workflow stays disciplined and reliable rather than freeform. From there, how far you take it is really up to your imagination — Agent-Coder gives you multiple ways to work with your AI provider of choice and get dependable feedback, including code feedback, shaped the way you actually need it.

Thank you to all who have purchased and for your support — God Bless!

AI providers and privacy

Choose the provider that suits the task and your environment:

• Anthropic Claude
• OpenAI / ChatGPT
• OpenAI Codex models
• DeepSeek
• Google Gemini
• xAI Grok
• OpenRouter
• Mistral AI
• Groq
• Together AI
• Perplexity
• Cohere
• Cerebras
• Fireworks AI
• A local OpenAI-compatible server such as MasterAI, Ollama, LM Studio, llama.cpp, text-generation-webui, or vLLM

Provider keys entered through the extension are stored independently in VS Code's encrypted SecretStorage, not in project configuration files. Local-server address/model settings are stored as machine-local preferences (not credentials, so not vaulted). For a local server that requires a login (e.g. MasterAI — others such as Ollama or LM Studio typically don't), the Settings panel's Test Connection button logs in on your behalf, exchanges that login for a long-lived API token, and stores the token and username in the same encrypted SecretStorage vault — your password itself is never written anywhere. Saving Settings never rewrites API keys or licence credentials. Replacing a Pro activation is transactional: a failed replacement leaves the active Pro session and its stored credentials intact. Agent-Coder also includes privacy and network-access policies so projects can restrict vendor-provider access when required.

Features

Agent-Coder is available in two tiers. Lite is free and always available — it covers the foundation through security and trust-boundary capabilities (Phases 1–20), plus the Conversation Intelligence Layer's foundational pieces. Pro requires an active licence — verified through the Ultimanium Designs licence server — and adds toolchain/compatibility awareness, Git safety, advanced review/economy features, project memory, debugging intelligence, domain-specific validation, provenance, plugins, autonomy controls, the advanced dashboards, the Predictive Engineering Intelligence layer, and the Conversation Intelligence Layer's advanced pieces (Phases 21–59).

Every command below also works as a Command Palette entry ("Agent-Coder: ...") and, where noted in the app's own Help panel, as plain-English chat text. Each entry is tagged (Lite) or (Pro — Phase N: <phase name>) so you can see exactly what an active licence unlocks.

Chat, Setup & AI Provider

Getting the assistant talking to a model, and controlling what's currently running.

• Open Chat (Lite) — Opens the Agent-Coder sidebar chat panel; every message is keyword-routed to the same controller methods the Command Palette commands use. A 🕘 button in the toolbar opens a browsable history of past conversations (per-workspace, most recent 20), including ones dismissed via Clear Chat. An optional "Show live action feed while tasks run" setting (Settings panel → Chat Panel, off by default) shows a live status line — a pulsing dot while the agent works, solid green when it finishes — reflecting the agent's real internal activity instead of a single static "Thinking..." message.
• Clear Chat (Lite) — Saves the current conversation to chat history, then resets the conversation shown in the chat panel.
• Cancel Current Task (Lite) — Cancels whatever AI request is currently in flight.
• Open Settings (Lite) — Opens the Agent-Coder settings webview for project-level configuration.
• Show Examples (Lite) — A practical guide with worked examples for every command, plus step-by-step startup workflows for new and existing projects.
• Configure AI Provider (Lite) — Choose which AI provider (vendor API or local server) Agent-Coder sends requests to.
• Set API Key (Lite) — Stores an API key for the configured AI provider through VS Code's secret storage.
• Select Model (Lite) — Lists only configured providers, then picks a known or custom model. A successful choice also makes that provider active when Settings currently uses another provider. The same picker is available through /model.
• Set Local AI Server (Lite) — Points Agent-Coder at a local/self-hosted AI server (base URL + model id) instead of a vendor API. For a server with its own model catalog and/or a login requirement (e.g. MasterAI), use the Settings panel's Test Connection button instead — it logs in only if needed, mints and stores an API token in SecretStorage, and lets you pick the model from a dropdown rather than typing its id.
• Clear API Key (Lite) — Removes the stored API key for the configured AI provider.
• Activate Pro Licence (Lite) — Enter your username, password and serial to unlock the Pro tier, verified against the Ultimanium Designs licence server.
• Deactivate Licence (Lite) — Releases the current Pro licence seat and clears stored credentials, reverting to the free Lite tier.
• Show Licence Status (Lite) — Reports the current Lite/Pro tier, activation status, and why Pro is unavailable if applicable.
• Change Language Adapter (Lite) — Overrides the auto-detected language adapter used for build/test/quality-rule commands.
• Recommend Model for Task (Pro — Phase 24: Model Routing, Semantic Caching & Cost Management) — Advisory suggestion for which configured model best fits a described task, based on the active economy mode.

Read-only analysis (no AI calls)

Deterministic scans and graphs — safe to run any time, cost nothing in tokens.

• Analyse Workspace (Lite) — Indexes the workspace (files, languages, hashes); later runs reuse cached hashes for unchanged files.
• Initialise New Project / Initialise Existing Project (Lite; chat: /init new / /init current) — Establishes the base project foundation: Analyse Workspace, capture a build-only foundation baseline, then Build Architecture Graph. Tests are deliberately not run during initialization.
• Build Project (Lite) — Runs the detected language adapter's real compiler and reports diagnostics.
• Run Tests (Lite) — Runs the project's configured real test command and retains exact failure output.
• Validate (Build + Test) (Lite) — Runs Build, then Tests only if the build succeeded; failures report their stage, exit status, diagnostics, count ambiguity, and cleaned raw tool output.
• Build Architecture Graph (Lite) — Expands the workspace index into a real file/symbol/dependency/test graph via import-specifier resolution.
• Open Project Map (Pro — Phase 32: Interactive Project Map & Workspace Heatmap) — Collapsible module-tree webview colour-coded by a deterministic heatmap built from quality rules, technical debt, git recency and test coverage.
• Open Project Visual Link Map (Pro — Phase 172: Project Visual Link Map) — A standalone, real-time interactive tree diagram of the entire project (every nested sub-folder and file, rooted at the workspace folder): top-down by default with a one-click Landscape toggle, every module and file connected by drawn mapping lines and coloured by the same deterministic heatmap. Opens instantly from its own on-disk cache and stays there until you Refresh or Clear Cache. Drag any node to reposition it — the layout is saved and survives reloads (Reset Layout undoes it); zoom with the lower-right controls or Ctrl+scroll wheel on the canvas; a language selector scopes the map to one source language at a time (and controls which files' extracted-symbol breakdown layer shows expanded by default). A node search box jumps straight to any file, folder, or symbol by name. Toggle Execution Flow to overlay the architecture graph's real imports/calls/dependencies as arced connector lines, distinct from the plain containment tree, shown by default only for the node you're hovering or last selected (with a "show all" option). Small 📝 buttons on every node let you pin your own rules/suggestions/ideas/changes/format notes/validation checks; a small ✨ button has AI auto-fill a grounded suggestion for that node; a Source History section shows that node's real git commit history with click-to-view diffs. One file can be flagged 🚩 as the project's entry point — auto-detected where possible, always user-overridable. A Save button exports the whole map as Markdown or a self-contained, clickable HTML5 page.
• Open Dependency Graph (Pro — Phase 33: Live Dependency Visualiser & Architecture Health) — Searchable dependency visualiser plus an architecture health check for cycles and layer violations.
• Open Technical Debt & Project Score Dashboard (Pro — Phase 34: Technical Debt Dashboard & AI Project Score) — Per-module technical-debt table plus an AI Project Score with seven named sub-scores, each citing its real inputs.
• Open AI Transparency Panel (Pro — Phase 35: AI Transparency Panels) — AI Confidence Meter for the last Analyze Decision, live token/cost usage this session, and a workspace memory timeline.
• Open Workspace/Build/Memory Optimisers (Pro — Phase 36: Workspace, Build & Memory Optimisers) — Filterable unreferenced files, high-confidence code-centralisation candidates, and dead-code candidates; C/C++-specific build-time and memory-usage heuristics with their own filters where applicable. Centralisation candidates are substantial exact source blocks aligned to declaration boundaries across files, use compact group/copy/location rows, and exclude documentation, configuration, generated files, tests, webview templates, shared-helper callers, schemas, and routine lifecycle/request scaffolding. Always advisory.
• Open Search & Teaching Chat (Pro — Phase 37: Semantic Search, Teaching Chat & Learning Mode) — Natural-language code search plus a system-level teaching chat grounded in real project files.
• Explain Symbol (Learning Mode) (Pro — Phase 37: Semantic Search, Teaching Chat & Learning Mode) — Grounded explanation (what/why/alternatives/performance/history/mistakes/best practices) for the symbol under the cursor.
• Open Design & Simulation (Pro — Phase 38: Design Mode, Refactoring Simulator & Performance Simulation) — Pre-code design proposals, a zero-AI Refactoring Simulator, and a zero-AI relative performance comparison of saved vs. unsaved text.
• Open Multi-Agent Command Centre (Pro — Phase 40: Multi-Agent Command Centre & Engineering Control Centre) — Eleven named adversarial-reviewer roles, each backed by a real specialization and deterministic activation signal; also shows recent Consensus/Debate/Orchestrator results.
• Open Engineering Control Centre (Pro — Phase 40: Multi-Agent Command Centre & Engineering Control Centre) — Mission-control webview composing every dashboard panel plus active agent roles, pending approvals, and the last risk classification.
• Open AI Memory Browser (Pro — Phase 50: Prompt Replay System & AI Memory Browser) — Searches successful prompt replays and validated project-memory records; expands a replay to show its complete reasoning trace.
• Open Prompt Chain & Workflow Builder (Pro — Phase 51: Prompt Chain Visualiser, Multi-Step Workflow Builder & Conversation State Machine) — Visualises the real pipeline stages each recorded answer passed through, and lets you save/re-run a named sequence of existing actions.
• Open AI Health Dashboard (Pro — Phase 52: AI Health Dashboard & Adaptive Provider Routing) — Per-provider/model table of real accuracy, hallucination, and failure rates, plus average response time and tokens.
• Open Engineering Session Recorder (Pro — Phase 53: Engineering Session Recorder) — Composes a recorded session into a Problem → Evidence → Reasoning → Changes → Validation → Benchmarks → Lessons-Learned report, exportable as Markdown, HTML, or PDF.
• Capture Baseline (Lite) — Snapshots current build/test/git state for later comparison.
• Detect Regression (Lite) — Deterministic comparison between two captured baselines.
• Check Quality Rules (Current File) (Lite) — Deterministic heuristics against .agent-coder/quality-rules.json.
• Detect AI-Generated Code (Current File) (Lite) — Flags whether the open file was likely AI-written, via commit-trailer scan plus a comment-style heuristic.
• Detect AI-Generated Code (Project-Wide) (Lite) — The same AI-authorship detection run across every file in the project.
• Check Performance Budgets (Lite) — Evaluates recorded performance budgets against the most recent validation run's real timings.
• Recommend Validation Level (Lite) — Deterministic V0–V5 escalation ladder from real git diff/status, dependency-graph edges and change-set size; a failed run reports exact failure evidence.
• Open Validation System (Lite) — Configures the project-owned minimum validation level, strict build/test-tool and failure policy, and completed-command reporting. Persisted health distinguishes historical observations from latest-per-file outcomes and names active failure/tool-gap paths and diagnostics.
• Search Project (Lite) — Combines exact-symbol lookup, call/reference search, dependency-graph relationships and text matching. No AI call.
• Open Project Metadata Analyzer (Lite) — Multi-layered workspace analysis: direct/transitive dependency stats and circular-dependency detection, configuration-file inventory and validation (50+ recognised types, including .github/workflows), compiler/runtime info, code metrics (LOC, complexity score, code-to-test ratio, TODO/FIXME markers), and classification tags (high-complexity, no-tests, typescript, etc.). Persists to .metadata-cache.json for fast reloads.

AI-backed, read-only

Asks the configured model for an answer, but never writes to disk.

• Ask About Current File (Lite) — Open a file, then ask a question about it; falls back to project-wide context if no editor is open. Captures a live editor snapshot (active symbol + bounded caller/callee/dependent/test/config neighbourhood, Phases 105-106) so the answer reasons about the real live buffer, including unsaved edits.
• Ask About Selection / Explain Selection (Lite — Phases 105-106: Live Engineering Context System) — Right-click a text selection → Agent-Coder submenu. Treats the highlighted code as the question's content; Explain Selection asks a fixed "what does this do, and what are the risks" question with no prompt needed.
• Propose Fix for Selection (Lite — Phases 105-106) — Same right-click submenu. Reuses the full Propose Fix pipeline (real full-file content, diff preview, approval) but constrains the AI's instruction to the selected line range.
• Plan Task (Lite) — Decomposes a feature request into a dependency-ordered task list and explicit requirements.
• Analyze Decision (Lite) — Scrutinizes a conclusion or proposed fix: assumptions, evidence checked against real files, confidence score, and scored alternatives.
• Explain Last Decision (Pro — Phase 28: Provenance, Reuse & Documentation) — Re-explains the most recent Analyze Decision result in plain language.
• Analyze Call Graph (Lite) — Grounded in real textual call-site search. Run Build Architecture Graph first.
• Analyze Concurrency (Lite) — Thread-safety/race-condition analysis for the current file or a described scope.
• Analyze Resource Ownership (Lite) — Who owns/releases a resource (file handles, locks, connections), grounded in real call-site evidence.
• Analyze Change Impact (Lite) — Describe a proposed change; returns related systems, required tests, build targets and public-API/schema impact.
• Analyze UI Accessibility (Pro — Phase 27: Domain-Specific Validation) — Reviews UI code for accessibility gaps grounded in the real file content.
• Generate Tests (Lite) — Proposes new test code grounded in the real file content; goes through the diff/approval flow.
• Analyze Test Adequacy (Lite) — Reports untested branches/error paths/boundaries and unexercised concurrency.
• Toggle AI Pair Programmer Mode (Pro — Phase 39: AI Pair Programmer & Workspace Goals) — Runs deterministic checks on every debounced buffer edit; an AI review only fires when a function/block just closed, surfaced as Problems-panel diagnostics.

Debugging Intelligence

Turning a bug report or crash artifact into ranked, falsifiable hypotheses.

• Generate Debug Hypotheses (Pro — Phase 26: Debugging Intelligence) — Describe a bug/failure; returns 2–5 competing hypotheses with probability, evidence and a cheap next diagnostic experiment.
• Analyze Crash/Failure Artifact (Pro — Phase 26: Debugging Intelligence) — Pick a stack trace, build log, HAR trace, heap snapshot or crash report; parsed deterministically first.
• View Debug Sessions (Pro — Phase 26: Debugging Intelligence) — Lists recorded debug sessions, ranked hypotheses, tracked experiments, and root-cause verification.
• Record Root-Cause Verification (Pro — Phase 26: Debugging Intelligence) — Answer six yes/no questions about a fix; classifies it as verified, probable, or symptom suppression.
• Propose Observability Instrumentation (Pro — Phase 26: Debugging Intelligence) — Proposes structured-logging/correlation-ID instrumentation for a file, through the diff/approval flow.

Governance

Standing rules and decisions that get folded into every later AI-backed request automatically.

• Add Project Invariant (Lite) — Records a standing rule (optionally with a regex validator); "critical" severity invariants block any violating patch.
• List Project Invariants (Lite) — Lists recorded project invariants.
• Create Architecture Decision Record (Lite) — Writes a real markdown ADR with sequential numbering.
• List Architecture Decision Records (Lite) — Lists recorded architecture decision records.
• Add User Preference (Lite) — Records a standing preference composed into every AI-backed request's PROJECT RULES context.
• List User Preferences (Lite) — Lists recorded user preferences.
• Add Performance Budget (Lite) — Records a threshold (e.g. max build time) checked by Check Performance Budgets.
• Record Correction (Pro — Phase 25: Persistent Project Memory, Learning & Diagnostic Reduction) — Type free-text feedback; classified and routed automatically to a preference, invariant, rejected-approach memory, or verified fact.
• View Project Memory (Pro — Phase 25: Persistent Project Memory, Learning & Diagnostic Reduction) — Lists everything promoted into persistent memory plus repair approaches already tried and rejected.
• List Technical Debt (Lite) — Reads back recorded technical-debt entries; no AI call.

AI Slop Control Centre (SlopGuard)

Deterministic detection of duplicated/reinvented code, unjustified complexity, unsupported claims, and quality/security findings — before and after AI-backed changes, reusing this project's own governance/ architecture/approval pipeline rather than a second engine.

• Open AI Slop Control Centre (Pro) — Scan a file or the whole workspace for duplication, oversized files, exact duplicate code blocks, and quality-rule violations; each finding is labelled confirmed or inferred and can be marked False Positive/Accept Risk/Resolved. Includes a disclosed 0-100 score per category, baseline capture/compare, live monitoring on the active buffer, a status-bar summary, an editor-selection submenu (Check Selection for AI Slop, Explain/Refine Finding, Add to Technical Debt, Propose Minimal Cleanup), a Markdown report, and a full /slop chat namespace.
• Provider/Model Routing Feedback (Pro) — Real SlopGuard findings are attributed back to the provider/model most likely to have generated them; a provider/model with a confirmed pattern of findings is deprioritized — never hard-blocked — in future AI model routing decisions.
• Show Pre-Commit/Pre-PR SlopGuard Summary (Pro) — A GO/CAUTION/NO-GO verdict scoped to your currently staged git files, composed from the real staged-file list and already-persisted findings.
• Authorship-Calibrated Scrutiny (Pro) — Files Agent-Coder has never generated or modified (no recorded provenance) have findings downgraded to informational/non-blocking, so a pre-existing legacy codebase's style isn't re-litigated on day one; AI-authored files keep full-strength scoring.
• Rule Refinement Suggestions (Pro) — A rule marked "false positive" three or more times is surfaced as a candidate to suppress or narrow, backed by a durable false-positive ledger.
• Scan Ignores (Pro) — Add, edit, or remove glob patterns (runtime/**, **/vendor/**, …) from the Policy panel to exclude a captured third-party tree or vendored fixture directory from every scan and live-monitoring pass entirely, instead of it being scanned as project source and flooding your findings and score with noise. Changes save immediately and apply to the next scan.

AI-backed, writes files (with approval)

Every one of these ends in a real VS Code diff view and an Apply/Reject modal before anything touches disk.

• Propose Fix (Lite) — Open and save a file first; asks for a minimal patch to that one file, shown as a diff with an Apply/Reject modal.
• Propose Project-Wide Fix (Lite) — No open file required; auto-selects relevant files and may propose edits across several at once, one approval for the whole batch.
• Repair Build/Test Failures (Lite) — Re-validates, proposes a fix per broken file with the same diff+approval prompt, and re-validates again, up to a configured attempt limit.
• Propose Fix (Pair Programmer Finding) (Pro — Phase 39: AI Pair Programmer & Workspace Goals) — Reached via the "Propose Fix…" link on an AI Pair Programmer diagnostic; same diff+Apply/Reject pipeline as Propose Fix.
• Generate Doc Comments (Lite) — Adds explanatory doc comments to exported/public declarations, matching existing comment style; never touches logic.
• Pretty (Format Cleanup) (Lite) — Runs each file's real language formatter; zero AI call, but still goes through the same diff-preview/Apply-Reject approval as everything else.

Safety / control

Undo and interrupt.

• AUTO System (Pro) — Workspace UI for immediate, rollback-backed editing. Choose a capability profile, configure independent operation-class policies, and select which supported editable commands may use AUTO. Every run becomes a persisted dependency graph built from declared real operations, with inspectable evidence, risk, provider/token/duration/retry/validation data. Pause waits before the next atomic operation, Resume continues, Cancel aborts active provider/process work and cancels queued nodes, and Rollback restores the complete last batch. Rules are saved to .agent-coder/auto.json; graphs survive panel focus/reload under .agent-coder/operations/auto-graphs.json. /auto, /fix, and MCP autoExecute use the same saved matrix.
• Implement Project-Wide Now (Pro, forced) — WARNING: always bypasses Agent-Coder's project token budget, per-request token ceiling, AI Necessity routing, normal diff review, and Apply/Reject. It writes validated project-wide changes immediately and shows live selecting/generating/validating/applying progress. Provider/model limits, protected paths, stale-file checks, critical invariants, high-severity semantic blockers, capability checks, and Pro licensing remain enforced. Available from /implement <what>, MCP implementProjectWide, the Command Palette, and the Pro-only editor AUTO submenu.
• Rollback Last Edit (Lite) — Restores the latest edit byte-for-byte; one call restores every successfully applied file in the latest /implement or AUTO batch.

Extensibility & plugins

Third-party plugin modules run under an explicit capability allowlist.

• List Plugins (Pro — Phase 29: Extensibility, Permissions & Performance-Safe Plugins) — Lists every discovered plugin, its declared permissions, and its context-contribution token usage against its declared quota.
• Review Plugin Writes (Pro — Phase 29: Extensibility, Permissions & Performance-Safe Plugins) — Plugins never write to disk directly; see pending plugin writes and Apply/Reject each one.
• Show Privacy & Network Status (Pro — Phase 29: Extensibility, Permissions & Performance-Safe Plugins) — Prints the currently active privacy mode and network-access policy.

Controlled autonomy & economy modes

Governs Repair Build/Test Failures, the one genuinely multi-step autonomous task in the codebase.

• Show Autonomy & Economy Status (Pro — Phase 30: Controlled Autonomy & Economy Modes) — Prints the resolved autonomous task budget, token policy and economy mode.
• Set Economy Mode (Pro — Phase 30: Controlled Autonomy & Economy Modes) — Sets economy mode to economy, balanced, or maximum-assurance; never disables approval gating or invariant enforcement.
• Set Response Quality Mode (Lite) — Sets the reasoning depth for ask-family requests. Instant/Standard/Professional are always available; the five Pro modes (Critical/Scientific/Architecture/Research/Verification) only appear with an active Pro licence.
• Open Workspace Goals (Pro — Phase 39: AI Pair Programmer & Workspace Goals) — Define a persisted goal (coverage/performance-budget/project-score/custom); progress is a real measured signal or an honest "not available." Suggested actions are a one-at-a-time approval queue.

Operational readiness & performance testing

Diagnosing the extension and its own token/prompt behaviour, not the target project.

• Run Diagnostics (Pro — Phase 31: Operational Readiness, Performance Testing & Resource Management) — Live probes of this machine/project: Node/VS Code version, tsc/git availability, a read/write test, build-tool availability, AI provider and plugin status.
• Validate Configuration (Pro — Phase 31: Operational Readiness, Performance Testing & Resource Management) — Checks .agent-coder.json for unknown settings, invalid values, unsafe command entries, duplicate invariant ids and a missing AI provider.
• Show Resource Pressure Status (Pro — Phase 31: Operational Readiness, Performance Testing & Resource Management) — A real snapshot of heap usage, CPU load and AI-request rate, and which pressure-relief actions are currently active.
• Run Token Regression Tests (Pro — Phase 31: Operational Readiness, Performance Testing & Resource Management) — A fixed suite of deterministic benchmarks covering indexing cost, cache reuse, diagnostic compression and model escalation.
• Run Prompt Snapshot Tests (Pro — Phase 31: Operational Readiness, Performance Testing & Resource Management) — Builds representative request types and compares their structural hash against a stored baseline.
• Analyze Token Waste (Pro — Phase 31: Operational Readiness, Performance Testing & Resource Management) — Scans the session's token ledger and cache-hit data for ten named waste patterns, each with a concrete recommendation.
• Run Performance Acceptance Criteria (Pro — Phase 31: Operational Readiness, Performance Testing & Resource Management) — Evaluates the plan's fifteen named performance targets as a single pass/fail report.
• Open Token Budget (Lite) — Opens the persistent project usage panel with exact provider-reported input/output totals, estimated cost, configured limits, failed/secondary attempts, recent calls, and per-file/context allocation.
• Show Model Performance History (Pro — Phase 24: Model Routing, Semantic Caching & Cost Management) — Prints recorded per-model performance history.

Git integration

Reads and drives real git state; never rewrites history without a dedicated command.

• Git Status (Pro — Phase 22: Git & Source-Control Safety) — Prints the real git status of the target project.
• Review Staged Changes (Pro — Phase 22: Git & Source-Control Safety) — Summarizes what's currently staged for commit.
• Create Task Branch (Pro — Phase 22: Git & Source-Control Safety) — Creates and checks out a new branch named for the current task.
• Create Git Checkpoint (Pro — Phase 22: Git & Source-Control Safety) — Commits the current working state as a recoverable checkpoint.
• Suggest Commit Message (Pro — Phase 22: Git & Source-Control Safety) — Proposes a commit message from the real staged diff.

Schema, API & compatibility

Cross-cutting-contract checks for changes that ripple beyond one file.

• Analyze Schema Change (Pro — Phase 27: Domain-Specific Validation) — Assesses the impact of a proposed data-schema change.
• Propose Schema Migration (Pro — Phase 27: Domain-Specific Validation) — Proposes a migration for a schema change, through the diff/approval flow.
• Add API Contract (Pro — Phase 27: Domain-Specific Validation) — Records an API's declared contract for later compatibility checks.
• Analyze API Contract Change (Pro — Phase 27: Domain-Specific Validation) — Checks a proposed change against a recorded API contract for breaking changes.
• Analyze Serialization Compatibility (Pro — Phase 27: Domain-Specific Validation) — Checks whether a change breaks wire/on-disk serialization compatibility with existing data.
• Detect Toolchain Profile (Pro — Phase 21: Toolchain & Compatibility Awareness) — Detects the project's real build-toolchain versions and configuration.
• Capture Build Environment (Pro — Phase 21: Toolchain & Compatibility Awareness) — Snapshots the current build environment for later compatibility comparison.
• Add Compatibility Entry (Pro — Phase 21: Toolchain & Compatibility Awareness) — Records a known compatibility fact (e.g. a supported platform/version combination).
• List Compatibility Entries (Pro — Phase 21: Toolchain & Compatibility Awareness) — Lists recorded compatibility entries.
• Check Compatibility (Pro — Phase 21: Toolchain & Compatibility Awareness) — Checks the current build environment against recorded compatibility entries.
• Remove Compatibility Entry (Pro — Phase 21: Toolchain & Compatibility Awareness) — Removes a recorded compatibility entry.

Solution library, provenance & supply chain

Reuse of past fixes, and trust in where code (and its dependencies) came from.

• Promote Solution Pattern (Pro — Phase 28: Provenance, Reuse & Documentation) — Saves a validated fix as a reusable solution pattern for similar future problems.
• List Reusable Solution Patterns (Pro — Phase 28: Provenance, Reuse & Documentation) — Lists promoted solution patterns.
• Remove Solution Pattern (Pro — Phase 28: Provenance, Reuse & Documentation) — Removes a promoted solution pattern.
• List Code Generation Provenance (Pro — Phase 28: Provenance, Reuse & Documentation) — Lists which code in the project was AI-generated, by which command/model, and when.
• Analyze Supply Chain (Lite) — Checks the project's dependencies for known supply-chain risk signals.
• Analyze License Compliance (Lite) — Checks dependency licenses against the project's compliance policy.
• Validate In Sandbox (Lite) — Runs validation in an isolated sandbox rather than the live workspace.

Predictive Engineering Intelligence

A persisted semantic model of the project that later features read/write instead of re-scanning source.

• Open Project Digital Twin (Pro — Phase 55: Project Digital Twin) — Builds and persists a semantic model of the project: module-level complexity/debt/risk, module-to-module dependency edges, and an approximate exported-API-surface count.
• Open Project Time Machine (Pro — Phase 56: Project Time Machine) — Builds an engineering-history timeline from real git commits — rationale, AI-vs-human authorship signal, risk level, and files changed per commit.
• Open Bug Probability Heatmap (Pro — Phase 57: AI Bug Probability Heatmap) — A per-function defect-probability score computed deterministically from complexity, git churn/bugfix-commit frequency, ownership heuristics, and test-coverage presence.
• Open Engineering Cost Estimator (Pro — Phase 58: Engineering Cost Estimator) — A deterministic implementation/testing/documentation/maintenance hour estimate for a freeform change description, mapped through your configured hourly rate/currency.
• Open Knowledge Preservation Engine (Pro — Phase 59: Knowledge Preservation Engine) — A persisted, searchable knowledge base of architecture decisions, debugging discoveries, performance tuning notes, limitations, and common mistakes.
• Open Intelligent Project Health Forecast (Pro — Phase 60: Intelligent Project Health Forecast) — An early-warning trend (improving/degrading/stable) computed from persisted project-score, commit-velocity, and bug-probability-risk snapshots recorded over time, with an early-warning banner when score is flat/declining while bug risk rises.
• Open Architecture Evolution Simulator (Pro — Phase 61: Architecture Evolution Simulator) — Sketch a proposed architectural change (add/remove a dependency, move a module between layers) and see its simulated before/after impact on coupling, layering, and complexity, computed over the real dependency graph before any code is written.
• Open Intelligent Naming Advisor (Pro — Phase 62: Intelligent Naming Advisor) — Flags class/function/interface names that don't match the project's own dominant naming convention per kind, with a suggested rename for each, plus unclear/placeholder names, computed deterministically over the real architecture graph.
• Open API Evolution Tracker (Pro — Phase 63: API Evolution Tracker) — Extends Phase 27's point-in-time API contract checking into a longitudinal view: record a release-over-release snapshot against a stored contract and see the breaking vs additive change history and trend over time.
• Open Smart Release Readiness (Pro — Phase 64: Smart Release Readiness) — A single deterministic go/caution/no-go readiness verdict for a release candidate, aggregating the Project Score, Bug Probability Heatmap, Technical Debt Dashboard, Health Forecast, and Architecture Health signals other phases already compute — no new metric.
• Open Documentation Drift Detector (Pro — Phase 65: Documentation Drift Detector) — Flags JSDoc @param comments that no longer match a function's real current signature, and README/docs code-block references to symbols no longer found in the real architecture graph — grounded in real diffs, not an AI guess.
• Open Workspace Documenter (Lite local core; optional configured-provider overview) — Persists the exact indexed files and additional grounded AI instructions a project document must consider, then creates an evidence-backed HTML/JS, Markdown, Rich Text (RTF), ASCII text, or PDF document under docs/. Live stages and file counts show what generation is doing, and Stop cancels before a new output write. Every output includes a deterministic file inventory, hashes, sizes, line/declaration evidence, and explicit metadata-only warnings; AI overview failure never prevents the local document from being created. Also reachable as /documenter.
• Open AI Architecture Mentor (Pro — Phase 66: AI Architecture Mentor) — An on-demand architectural reasoning partner: ask a free-form question and get an answer grounded strictly in the real, already-built architecture graph — hub nodes, layers, cycles, and layer violations — never invented structure.
• Open Legacy Code Rescue Mode (Pro — Phase 67: Legacy Code Rescue Mode) — A guided, bounded checklist for safely approaching one unfamiliar or poorly-documented file, built from real bug-probability, technical-debt, blast-radius, and test-coverage signals.
• Open AI Code Archaeologist (Pro — Phase 68: AI Code Archaeologist) — Reconstructs the likely reasoning and history behind one file from its real, filtered commit history when no other documentation exists — inference always marked as inference, never asserted as fact.
• Toggle Live Coding Coach (Pro — Phase 69: Live Coding Coach) — Extends AI Pair Programmer Mode toward more continuous guidance: an advisory suggestion is offered on a disclosed cooldown whenever the buffer has genuinely changed, rather than only after a function/block closes — still never auto-applying an edit.
• Open Engineering KPI Dashboard (Pro — Phase 70: Engineering KPI Dashboard) — A single dashboard of real engineering metrics — project score, testing score, unresolved technical-debt items, commit velocity, and real edit-review-turnaround time — with trends computed deterministically from persisted snapshot history.
• Open Refactor Confidence Simulator (Pro — Phase 71: Refactor Confidence Simulator) — A real 0-100 confidence score plus rule-selected precautions for a proposed refactor, grounded in real test-coverage presence, dependency-graph blast radius, and bug-probability signal, before the refactor is attempted.
• Open Feature Completion Predictor (Pro — Phase 72: Feature Completion Predictor) — A deterministic completion percentage for a described in-progress feature, scoring Phase 8's real task decomposition against real file-existence and test-coverage evidence — never a fabricated number when there's no file-level evidence to score against.
• Open Plugin Marketplace (Pro — Phase 73: Plugin Marketplace) — Discover and install third-party plugins from a real, project-local marketplace source directory, using the same manifest validation and compatibility check the Phase 29 plugin loader itself uses.
• Open Industry Compliance Packs (Pro — Phase 74: Industry Compliance Packs) — Pre-built OWASP ASVS/SOC 2/HIPAA/PCI-DSS baseline requirement checklists evaluated against your project's real declared invariants and security-scan findings — a baseline heuristic, never a certified audit.
• Open Engineering Intelligence Network (Pro — Phase 75: Engineering Intelligence Network) — Opt-in, privacy-preserving sharing of an anonymized, aggregated snapshot of bug-pattern and technical-debt signals (never raw source code) to a real local shared directory, plus a real aggregate view across every project/team member that has opted in.
• Open Autonomous Engineering Roadmap (Pro — Phase 76: Autonomous Engineering Roadmap) — A deterministic, ranked "what to work on next" list built from real Release Readiness, Technical Debt, Bug Probability, and Workspace Goal signals — never a fabricated priority score.
• Open Personal Engineering Profile (Pro — Phase 77: Personal Engineering Profile) — A real, local-only summary of your own recorded corrections and debug sessions — never shared anywhere except through the separate, explicit Engineering Intelligence Network opt-in.
• Open AI Innovation Assistant (Pro — Phase 78: AI Innovation Assistant) — A bounded, explicitly speculative brainstorming mode for new feature/architecture ideas, clearly separated from every other panel's grounded-in-evidence discipline.
• Professional Command Framework (Lite — Phase 79: Professional Command Infrastructure) — A deterministic /namespace action command parser with aliases (/status, /ready, /reindex, /regraph, /checkpoint, /handover, /impact) plus the context-sensitive /validate matrix route, /help <namespace-or-command>, and /commands search <term>. Missing required arguments and unknown explicit slash commands return usage/errors without falling through to Ask.
• Project, Developer & Analyst Command Namespaces (Lite base, several Pro leaves — Phases 80-82) — Real behaviour for /project, /code, /analyse, /test, /build, /docs, /security, /performance, /architect, /task, /focus, /change, /config, /decision, /risk, /investigate, /requirements, /debug, /session, /report, and /git — every response a markdown table, wherever possible reusing a real existing deterministic pipeline rather than a new one.
• Safe Reset Foundation & Advanced Project Restoration (Lite base, Pro/advanced levels — Phases 83-84) — /reset from low-risk (conversation/active-task/pending-edits/indexes/graph/caches/diagnostics/session-state) up through Pro/advanced levels (agent-state/configuration/project-metadata/generated-files/source-to-checkpoint/source-to-git/full wizard), every destructive action preview-only until an explicit --confirm, with a real /reset history/show/undo audit trail carrying an honestly-scoped recovery mechanism (git checkpoint, prior configuration, or a preserved diff) per action. /git restore-preview shows a preview-only diff that never executes.
• Command Workflow Pipelines (Lite for list/preview, Pro for run/resume/cancel — Phase 85: Command Workflow Pipelines) — /workflow list|preview|run|resume|cancel, a chat surface over the existing Multi-Step Workflow Builder engine, stopping automatically at any step that needs approval and resuming from exactly where it paused.
• Open Local Test Laboratory (Pro — Phases 86-93: Local Test Laboratory) — Create, preview, execute, and retain unit/integration/regression/boundary/error-path/concurrency/stress/performance/security/compatibility/reproduction/diagnostic-probe/smoke/property/fuzz/build/runtime/environment-verification scripts across isolation levels (current process through git worktree/container/Windows Sandbox), with a real verification verdict (never just an exit code), flaky-test repetition analysis, safe trash-then-purge deletion, and persisted execution history — every create/run gated by a seven-option approval dialog.
• Solve Problem (/solve) (Lite — Phases 94-99: Problem-Solving Command Container) — A coordinating entry point for a free-text problem: deterministic classification (category/complexity/risk/uncertainty, a recommended mode from 14 and strategy from 12), missing-information gating that blocks only when a gap is genuinely high-impact and required for the next step, candidate evidence extraction, competing-hypothesis/diagnostic-experiment tracking, an approval-gated controlled command runner (Phase 97, isolation selected per Phase 88's L0-L6 ladder), a fix proposed and applied through the real propose→approve pipeline followed by validation/regression checks and a 6-condition root-cause-fix verdict (Phase 98), and a Workflow Builder-driven run plus a full Markdown session report (Phase 99) — all for a persisted, resumable session.
• Problem Solver Panel & Pro Intelligence (Pro — Phase 100: Problem-Solving Command Container capstone) — Multi-provider consensus/debate (Phase 48) applied to a session's problem, --quality <mode> as a per-request Response Quality Mode override (Phase 46), deterministic cross-session solution matching against other sessions with a verified/probable fix, HTML/PDF report export (reusing Phase 53's real exporter), and the consolidated "Agent-Coder Problem Solver" panel (Overview/Evidence/Hypotheses/Validation) with propose/approve/consensus/debate/match/export actions.
• Live Engineering Context & Validation (Lite deterministic core; Pro professional intelligence — Phases 104-110) — Tracks the unsaved active buffer, resolves the current symbol and bounded callers/callees/dependents/tests, validates every registered language through an intrinsic parser, safe native tool, or explicit toolchain/configuration outcome, and publishes current findings to Problems. Clicking the Live AI Ready status captures the referenced source document before the Live Context webview takes focus, so the panel shows that document's snapshot rather than attempting to inspect itself. Open Live Context or use /context status|refresh|show|callers|callees|tests|diagnostics|validate|toolchain|tokens. Pro adds persisted stability/toolchain-drift evidence, boundary/ownership/API risk candidates, provenance, fix-readiness gating, and system self-diagnostics.
• Native Editor Integration for Live Context (Lite core; Pro enhancements — Phases 111-119) — CodeLens above the live-resolved active symbol (caller count/validation state Lite; stability badge/Propose Fix Pro), lightbulb quick fixes at a live diagnostic's own range (Explain Lite; Propose Fix/impact analysis Pro), an optional Live Context section on the existing Learning Mode hover, a native "Live Context" sidebar tree view alongside Chat, opt-out validation gutter glyphs plus Pro stability end-of-line badges (agentCoder.liveContext.showDecorations), four icon-only editor/title quick-action buttons shown only while Live Context is active for the open document, a Rename Impact Preview that surfaces caller/public-API/cross-language-boundary impact before a rename runs (never performing the edit itself), clickable file-path links in the "Agent-Coder" Output channel, and independent agentCoder.liveContext.editorIntegrations.{codeLens,treeView,titleBarIcons} toggles. Every renderer reuses data Phases 104-110 already computed — no new analysis.
• Editor Selection Submenu Expansion (Lite core; Pro review/provenance entries) — Fourteen more right-click "Agent-Coder" submenu entries, each scoping an existing engine to exactly the highlighted range: Refactor Selection and Extract Selection to Function (fixed-instruction variants of Propose Fix for Selection), Pretty (Format Cleanup) for Current File (the same zero-AI-call deterministic formatter as the command-palette Pretty command, pre-targeted at the selection's file since formatting always applies to the whole file), Generate Tests for Selection and Add Doc Comment for Selection (only shown when the selection resolves to exactly one whole declared symbol via a new Live Symbol Resolver gate), Show Context for Selection (opens Live Context pre-scoped to the selection), Validate Selection (filters Validate Current Buffer's real-toolchain result to the selected lines), Pro-tier Security/Performance/Impact Review for Selection (the same grounded review call Explain Selection makes, with a specialty instruction), Show Public API Risk for Selection (deterministic — composes the public-API-candidate scanner, real call-site scanner, and API Evolution history store), Compare Selection Across History (opens Time Machine for commit-level context plus a real diff of the file against a chosen git ref), Add Selection as /solve Evidence (attaches the selection into an active /solve session's evidence set, tagged "inferred"), and Pro-tier Show Provenance for Selection (opens AI Transparency and reports the most recent recorded AI-authored edit to the file).
• Invariant Control Centre & PLAN Control Centre (Pro) — The professional layer for teams who need proof, not just promises. The Invariant Control Centre turns a project rule into something that's actually enforced: full lifecycle (draft → active → deprecated), structured deterministic validators (regex/path/dependency/architecture/build/test rules — zero AI call), test cases you can run on demand to prove a rule actually catches what it's meant to, and per-file validation with an honest pass/violated/not-evaluable verdict for every check. An active rule with "patch proposal" as an enforcement point is enforced automatically the moment code changes — no separate review step to forget. The PLAN Control Centre turns your implementation plan into a real, dependency-aware project plan instead of an informal checklist: a full phase list with status/risk/dependencies, a real dependency graph (so you always know what's actually unblocked and ready), and a five-condition completion gate — dependencies satisfied, acceptance criteria satisfied, build verified, tests verified, no active critical rule violation — that always shows you exactly which conditions passed and which didn't, never a vague "trust me". A phase only becomes "completed" when every condition genuinely passes and you've given a reason, so status can't drift out of sync with reality. The plan lives as clean, readable Markdown at docs/PLAN.md — hand-edit it, have an AI help draft new phases, or sync it back in, and everything you or the AI touches is still validated deterministically before it's ever saved. Every action is also available as a fast /plan chat command for teams who live in the chat panel.
• Toolchain Control Centre (Lite) — Stop guessing whether a missing compiler or build tool is why something failed. This panel shows, live, exactly what your project's own detected languages need and whether it's actually on your machine: a green check for every compiler, build system, package manager and formatter that's installed, a red cross plus a direct download link and a ready-to-run install command for anything that's missing, and an honest amber question mark — never a fabricated status — for a language Agent-Coder doesn't yet track a requirement for. If a language you're using isn't currently installed on your system, this is where you go to sort it out. One click also installs the project's own canonical VS Code extension for a detected language (never a general marketplace browse — strictly scoped to what your project actually uses), and a combined Test & Build Systems view lines up your detected build systems, your registered Local Test Lab assets, and the captured build environment side by side so you can tell a source-code bug from an environment problem at a glance. Agent-Coder stays in full command of systems development against every language it knows, instead of failing silently against a toolchain gap.

Conversation Intelligence Layer

A dedicated layer over every "ask" — see the Conversation Intelligence Layer section above for the full description of each piece. In summary:

• Chat Command Language & prompt/question optimisation (Lite) — /architect, /debug, /review, /refactor, /design, /security, /performance, /compare, /research, plus silent prompt/question optimisation on every request.
• Response Quality Modes (base three) (Lite) — Instant/Standard/Professional reasoning depth.
• Context Inspector & Missing-Information Gate (Lite) — See exactly what context an answer will be built from, and a confidence check that holds back a low-evidence request.
• Next Steps File Follow-Up (Lite) — When an answer's "Next Steps" section names files, resolves each against the real workspace, shows a found/missing wanted-file list, and makes one automatic follow-up ask with the found files attached as context so the final answer is concrete.
• Response Quality Modes (advanced five) (Pro — Phase 46: Response Quality Modes & Context Inspector) — Critical/Scientific/Architecture/Research/Verification modes.
• Evidence Viewer, Answer Verification, Self-Critique & Risk Meter (Pro — Phase 49: Answer Verification Pipeline, Self-Critique & Risk Meter) — Per-paragraph evidence classification, a staged verification pipeline, a bounded self-critique pass, and a five-category risk rating.
• Consensus & Debate Mode (Pro — Phase 48: AI Consensus Mode & Debate Mode) — /consensus asks every configured AI provider the same question and reports a real agreement percentage; /debate runs a bounded two-round argue/rebut exchange.
• Prompt Replay & AI Memory Browser (Pro — Phase 50: Prompt Replay System & AI Memory Browser) — Every successful ask is recorded as a reloadable reasoning chain, searchable in a dedicated browser.
• Prompt Chain Visualiser & Workflow Builder (Pro — Phase 51: Prompt Chain Visualiser, Multi-Step Workflow Builder & Conversation State Machine) — Visualise pipeline stages, save/re-run a named sequence of existing actions.
• AI Health Dashboard & Adaptive Provider Routing (Pro — Phase 52: AI Health Dashboard & Adaptive Provider Routing) — Real per-provider/model accuracy, hallucination-rate, and response-time table that feeds back into model recommendations.
• Engineering Session Recorder (Pro — Phase 53: Engineering Session Recorder) — Composes a recorded session into a full report, exportable as Markdown, HTML, or PDF.
• AI Answer Orchestrator (capstone) (Pro — Phase 54: AI Answer Orchestrator) — /orchestrate <question> runs the full pipeline above as a single named entry point, replying with a stage-by-stage trace.

The UI identifies locked features wherever they appear — a locked command names its Pro phase and offers a direct path to activation — and provides licence activation and status commands (Activate Pro Licence, Deactivate Licence, Show Licence Status). An active licence is stored securely through VS Code rather than in the workspace.

Bug reports and project support

Please submit bug reports on the Ultimanium forum board and register a free account. Agent-Coder is actively developed, and one developer cannot see every issue or workflow at once. Your extra eyes, reproducible reports, and feedback are greatly welcomed and help support the project's continued development. Thank you for your support.

---

AGENT-Coder by Daniel J. Hobson of Ultimanium Designs 2026-2027 Copyright (C) by Daniel J. Hobson, Australia, 2026-2027 Website: https://ultimanium.com/ License Type: Lite/Pro