Visual Assist 2026.5 — 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.
Use Ollama (local), Claude, or a Codex account. You decide where your code goes.
Our take

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

AI was built for the web. The boom tuned tools on JavaScript, Python, and code where "mostly right" is passable. Most AI tools work in the background: suggestions appear, code is indexed, and context is sent to the cloud. Generate, accept, ship, repeat.

It's useful for plenty of work. But it's not the exact fit 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.

With the local model, the input is your selection plus a small surrounding window. In VA Agent, Claude Code or Codex can also work across your project. Either way, nothing is gathered until you invoke a feature. Modern AI tools love to assemble context for you in the background. We made the other choice.

Giving developers control over how AI works with their code.

Run it on your GPU, or on your own Claude or Codex account. The principle hasn't changed: you decide where your code goes. Always.

Some teams may prefer the local Ollama model to keep source code internal. Others already use Claude or Codex for the full capabilities of a larger cloud model.

One isn't necessarily better. You decide where your code goes, when AI runs, and how much it's allowed to change: keep it local when control matters, or use a frontier model for broader context.

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 workflow you reach for when "mostly right" doesn't cut it, and we give you the flexibility to control what code gets used as context. And we're building toward more: Visual Assist's C++ understanding as the context layer for whichever AI model you choose. Visual Assist 2026.5 takes the first step. More on that below.

Read the full position: deterministic by design →

What shipped first

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

Both features follow the same approach: you choose which model runs the work, invoke it yourself, and control how much it changes. Read more below.

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. Open Tools → VA Agent and ask about the code by name: the class, function, or symbol. Ask mode steers it toward answering rather than editing. Edit mode lets it change files directly, and every edit can be undone. It docks on the right like other VA tool windows.

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.

Tools → VA Agent

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.

Visual Assist 2026.5 takes the first step. Connect Claude Code or Codex with your own account and work with it inside Visual Studio through VA Agent. Whichever AI tool you trust, the goal is for Visual Assist to hand it curated, project-aware C++ context while you keep the AI tooling you like.

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 parser provides the context. You choose the model. The output stays focused.

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. Run a local Gemma model through Ollama, or connect Claude Code or Codex with your own account and Visual Assist acts as the context layer. Take a look at the working parts below. Nothing here is arbitrary. Every constraint is one we picked on purpose.

Model
Local Gemma model (open-license) via Ollama, or Claude Code or Codex through your own login.
Because
The model layer should be replaceable as the field evolves. The position shouldn't.
Enablement
Two-step opt-in: install the local model or sign in to your provider's CLI, 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
Local model: 12 GB VRAM minimum, ~9 GB free disk. Claude Code and Codex run on the provider's hardware.
Because
Running locally means a processor doing work on your PC. Choosing a provider moves that work to their hardware, under your account.
Invocation
Shift + Alt + Q → Change Code with AI, or Tools → VA Agent.
Because
A keyboard shortcut is a user action. Inline ambient suggestions aren't.
Network
Local model: no outbound calls for selections, prompts, or output. Claude Code or Codex: calls go to that provider through your account when you invoke a feature.
Because
Your code goes where you tell it to. Nothing leaves the machine unless you've connected a provider and invoked a feature.
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.5 or later — Try Visual Assist →
  2. Choose your model.

    For the local model: Extensions menu → Visual Assist → Intelligence → install language model.

    For Claude Code or Codex: install the provider's CLI (a single console command) and sign in with your own account.

  3. Local model only: 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

What is VA Intelligence?

VA Intelligence is the AI feature set built into Visual Assist, the C++ IDE extension for Microsoft Visual Studio. It runs on a local model through Ollama, or on Claude Code or Codex through your own account. VA acts as the context layer that feeds the model the relevant lines of your C++ project. Visual Assist 2026.5 has two features, both in alpha: VA Agent, a chat window where the AI answers questions or edits your code directly (every edit can be undone), and Change Code with AI, which lets you describe a change to a selection, review the proposed diff, and accept or reject it.

Is VA Intelligence included with my Visual Assist subscription?

Yes. VA Intelligence, including the local model, is installable with every Visual Assist license at no extra charge. You can also install it during the 30-day free trial. To use Claude Code or Codex instead, sign in with your own Anthropic or OpenAI subscription. Whole Tomato doesn't sell or bundle access to those models.

What Visual Studio versions does VA Intelligence support?

VA Intelligence works with all currently supported versions of Visual Assist: Visual Studio 2015, 2017, 2019, 2022, and 2026. While all are supported, we recommend Visual Studio 2026 for the best overall experience and access to the latest IDE improvements.

Does my code leave my machine?

With the local model, no. It runs through Ollama on your GPU, and no upstream call carries source code. With Claude Code or Codex, the context for the feature you invoke goes to that provider through your own account, under your account's data terms. Whole Tomato never receives your code.

Why offer both a local model and cloud providers?

Because the C++ teams we serve have different rules. Game studios, financial systems, regulated enterprise, and defense contractors often have firm limits on where source code can go, and those limits don't bend for AI features. The local model is built for them. Other teams and individuals already pay for Claude or Codex and want a larger model working on their code. With Visual Assist as its context layer, you choose your level of exposure: more control with the local model, more reach with a frontier model on your own account. Use as much or as little as the work calls for.

What model does it use?

Your choice. A local Gemma model served via Ollama (open license), or Claude Code or Codex through your own subscription, with Visual Assist as the context layer. The architecture lets models be swapped or added over time without changing the user-facing flow.

Do I need a GPU?

For the local model, yes: 12 GB VRAM minimum and roughly 9 GB free disk for the model files. Claude Code and Codex run on the provider's hardware, so they don't need one.

Is it on by default?

No. Two-step opt-in: install the local model or sign in to a provider, then enable VA Intelligence in options. Nothing initializes until you've explicitly turned it on. We do not ship AI unless you install a model or log in to a provider.

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

Yes. VA Intelligence is built to coexist with them. Most teams will keep using ambient AI assistants for most of their work.

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?

With Claude Code or Codex in VA Agent, it can work across your project. Change Code with AI still works from your selection plus a window of surrounding context, on any model. Visual Assist's parallel parser already powers navigation and refactoring across full codebases at scale.

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 does VA Intelligence require me to select code and review diffs manually?

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?

Visit the VA Intelligence FAQ for setup, hardware, and feature details. For anything else, send us a note.

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 →