Visual Assist 2026.3 — Just Released VA Intelligence

AI for C++. Compiles isn't correct.

VA Intelligence is AI for C++ engineers who still want to be C++ engineers. You scope what the model sees. You write the prompt. You review the diff. The model doesn't ship code — you do. C++ is the wrong language to vibe-code, and we built the workflow that takes that seriously.

Try Visual Assist → Read the position →
Architecture schematic: VA Intelligence context layer sits between your codebase and AI models, all inside a 'your machine' boundary. No outbound paths from source code.
Runs on your machine. Your code goes nowhere.
Our take

C++ is the wrong language to vibe-code.

The AI tooling boom was built for the web. Tuned on JavaScript, Python, and the kind of code where "mostly right" ships fine. The default UX followed: ambient inline completions, always-on indexing, context quietly assembled and sent to a vendor cloud. Generate, accept, ship, repeat.

That's a real category, and a useful one for plenty of work. It is not the right shape for C++.

Compiles isn't correct.

AI generates C++ that compiles. You're still the one who has to guarantee it's actually correct.

We don't pretend the model closes the gap between passing the compiler and being correct. On a serious C++ codebase, that gap is where reputations get tested. We built the workflow that lets the developer close it — and lets the AI earn its place inside that workflow.

The workflow makes you think.

Select. Prompt. Review. Accept or reject. Every step is a decision you make deliberately.

VA Intelligence is invoked, not ambient. If that sounds like more friction than inline completion, it is — and it's the point. We are not interested in helping developers ship code they didn't read. The friction isn't a flaw. The friction is the design.

You scope what the model sees.

The model gets what you hand it. Nothing assembled behind your back, nothing sent without your say.

Your selection, plus a small surrounding window — that's the input. Modern AI tools love to assemble context for you; that's also the path to your code being read, embedded, logged, and trained on by people who weren't invited. We made the other choice. The output is auditable.

Local is the current manifestation, not the thesis.

Today it runs on your GPU. The principle underneath is simpler: you decide where your code goes. Always.

No outbound calls carry source code. That matters — it's the only configuration the teams we serve are actually allowed to run. But "local" is the how, not the why. The thesis is that the developer decides where their code goes, and the developer stays the engineer.

VA Intelligence isn't here to replace Copilot, Cursor, or whatever AI tools you already use. Most teams will keep using those tools for most work, and that's fine — they're good at what they do. We're the AI you reach for when those tools shouldn't be in the room, and we're the workflow you reach for when "mostly right" isn't a shipping standard. And we're building toward something more: a context layer that lets you bring Visual Assist's C++ understanding to whichever AI tool you trust, without ever handing those tools the raw codebase. More on that below.

What shipped first

Two features today. The shape of the system isn't done.

Both features run from a code selection. Both reflect the position above — invoked, scoped, local. Treat what's below as the smallest visible part of where this is going.

Explain with AI

Visual Studio context menu open over a selected symbol, with 'Explain logger_ with AI' highlighted.

Highlight a function, a macro chain, or a block you don't recognize. Hit Shift + Alt + Q and pick Explain with AI. VA streams a plain-language explanation back into the editor.

Best for the moment you've been dropped into unfamiliar code and want a fast read-out before you start touching anything. Useful for onboarding, code review of unfamiliar modules, or picking up legacy code nobody's touched in years.

Shift + Alt + Q → Explain with AI

Change Code with AI

VA Intelligence prompt panel — describe the change, review the proposed diff, then accept or reject.

Select code, describe the change in plain language, review the proposed diff, accept or reject. Nothing is applied to your file until you say so.

Works for optimizations, rename-for-clarity, small refactors, adding error handling, pattern conversions — the long tail of small-but-tedious changes that pile up. The AI proposes; the developer disposes.

Shift + Alt + Q → Change Code with AI
Selection in. Diff out. Nothing applied until you say so.
Where this is going

The model isn't the product. The context layer is.

The hard problem in AI for C++ isn't the model. Models keep getting better, and the open-license ones we run today will be replaced by better ones tomorrow — the same way you upgrade compilers without rebuilding your engineering culture around them. The hard problem is context: getting the model to understand a million-line, multi-decade C++ codebase well enough to be useful without being dangerous.

Visual Assist already understands C++ projects at that scale. Our parallel parser powers navigation, refactoring, and code understanding across some of the largest C++ codebases on earth. The next phase is exposing that parser as a local context layer for the model — real project awareness, code stays on your machine.

The phase after that is the one we'll say the least about until it's real: the same context layer doesn't have to stop at our model. Whichever AI tool you trust — Copilot, Cursor, whatever the field looks like by then — let Visual Assist be the one that hands it curated, project-aware context. You keep the AI tooling you like. Your raw source stays out of someone else's pipeline. No promises on dates. Just direction.

Annotated context layer architecture diagram: VA Intelligence parser, scope & select, and context window modules sit between the codebase and AI models. Curated context flows to the vendor cloud; a red X blocks raw code from leaving the machine boundary.
The architecture — parser as context layer, curated output, raw code stays inside.

Your feedback shapes what comes next — the workflows you're wrestling with, the refactor patterns that don't get enough tooling, the frustrations with current AI that nobody's tackled. We read everything.

Tell us what you need →
Under the hood

How VA Intelligence runs today.

VA Intelligence ships through the Extensions menu and runs a local Gemma model through Ollama. Here's the parts list, plus the why behind each piece. Nothing here is arbitrary. Every constraint is one we picked on purpose.

Model
Local Gemma model (open-license), served via Ollama.
Because
The model layer should be replaceable as the field evolves. The position shouldn't.
Enablement
Two-step opt-in: install the model, then enable VA Intelligence in VA options.
Because
We do not ship AI you didn't ask for. Two deliberate steps, never on by accident.
Hardware
12 GB VRAM minimum, ~9 GB free disk for model files.
Because
Local execution is the point — and that means real silicon doing real work, on your box.
Invocation
Shift + Alt + Q → pick the feature.
Because
A keyboard shortcut is a user action. Inline ambient suggestions aren't.
Network
No outbound calls for selections, prompts, or generated output.
Because
Your code goes where you tell it to. Default off-device is non-negotiable for the teams we serve.
Schematic: code editor selection feeds a local model node inside a 'your machine' boundary frame. A ghosted cloud outside the frame is crossed out.

This is the floor, not the ceiling. The architecture is built so the model layer can be swapped, and so the context feeding the model can grow far beyond a single selection.

Setup

Get it running.

  1. Install Visual Assist 2026.3 or later — Try Visual Assist →
  2. Install the VA Intelligence model. Extensions menu → Visual Assist → Intelligence → install language model.
  3. Confirm hardware. 12 GB VRAM minimum, ~9 GB free disk.
  4. Enable VA Intelligence in Visual Assist options. Trigger via Shift + Alt + Q on any selection.
Read the setup guide →
FAQ

Frequently asked questions

Does my code leave my machine?

No. VA Intelligence runs the model locally through Ollama. Selections, prompts, and context are processed on the developer's GPU. No upstream call carries source code.

Why local? Why not just use a hosted model like every other AI tool?

Because the C++ teams we serve — game studios, financial systems, regulated enterprise, defense contractors — already have firm rules about where source code is allowed to go, and those rules don't bend for AI features. Local execution is what gets VA Intelligence into the room. It's also the configuration we'd want even if the rules didn't exist.

What model does it use?

A local Gemma model, served via Ollama. Open license. The architecture is designed so models can be swapped or added over time without changing the user-facing flow — when better local models ship, we ride them.

Do I need a GPU?

Yes. 12 GB VRAM minimum and roughly 9 GB free disk for the model files.

Is it on by default?

No. Two-step opt-in: install the model, then enable VA Intelligence in options. Nothing runs until you've explicitly turned it on. We do not ship AI you didn't ask for.

Does it work alongside Copilot, Cursor, or other AI tools?

Yes. VA Intelligence is built to coexist, not replace. Most teams will keep using ambient AI assistants for most of their work; VA Intelligence is for the codebases and situations where those tools shouldn't be in the room — and it works alongside them where they can be.

Can it generate new code from a prompt?

The current flow is built around modifying existing selections — select, prompt, review a diff, accept or reject. Generation-from-scratch works but the experience is rougher. Improvements are in progress.

Does it understand my whole project?

Not yet — today VA Intelligence reasons about your selection plus a window of surrounding context. Project-wide reasoning is the next phase. Visual Assist's parallel parser already powers navigation and refactoring across full codebases at scale; the next step is letting it serve as the local context layer for the model. Your code stays on your machine. The model gains project awareness.

Why doesn't it just suggest things inline?

Because non-deterministic AI in your peripheral vision is noise on a real C++ codebase. We'd rather you invoke a feature when you want one than have the model guessing what you might need.

Aren't you just being precious about AI? Other tools ship inline completion fine.

Other tools also ship to languages where "mostly right" is the bar. C++ isn't that language. A confidently wrong inline completion in JavaScript is a unit test failure. A confidently wrong inline completion in C++ is a memory bug shipped to production. The line we draw is intentional, not nostalgic.

Why all the friction? Isn't AI supposed to be effortless?

Effortless AI is great when "good enough" is good enough. C++ is not that environment. Every step in the VA Intelligence workflow — scoping the selection, writing the prompt, reading the diff, accepting or rejecting — exists because the alternative is shipping code into a codebase that won't forgive you for it. The friction is the feature. We're building leverage for developers who still want to be the engineers, not auto-pilot for developers who don't.

Where do I go for help?

Documentation or send us feedback — we read everything.

Stay current

VA Intelligence ships with every Visual Assist release.

The What's New page tracks every release — VA Intelligence updates land there first.

See what's new →