Neuron Companion by SADATA (v1.48.0)

Use Neuron directly inside VS Code. Ask questions, understand your project, choose how Neuron works, and keep an eye on your usage — without leaving your editor.

Get started

1. Install Neuron Companion from the VS Code Marketplace.
2. Select the Neuron icon in the Activity Bar.
3. Choose Login with Neuron and finish signing in in your browser.
4. Open Neuron Chat in the secondary side bar (or run Neuron: Focus Chat), choose a model, and start asking questions.

You do not need to copy an API key into VS Code. Your sign-in is managed securely by VS Code and is removed when you log out.

Use Neuron memory

Neuron Companion provides Neuron+ Cloud Memory as a native Model Context Protocol (MCP) server in VS Code. It is served by Neuron Hub and uses the same sign-in as chat: there is no separate registration and no second key. Every device and desktop app signed in to your Neuron account shares one long-term memory.

Neuron memory is the primary long-term memory Neuron uses. In Neuron's own chat view the editor's local memory tool is withheld, so what Neuron learns is written to one shared store rather than split between a local file and the cloud. Neuron recalls relevant context when a task starts (context, search, recent) and stores durable facts — decisions, root causes, project conventions — when one is settled (remember, update, forget).

Ask and Plan modes can read memory but never write it.

Chat with Neuron

Neuron Chat sits in VS Code's secondary side bar, so you can ask questions while you work. Responses appear as they are generated, and Neuron can use the tools available in VS Code. The model list is based on the models available to your Neuron account, so it can be different for each person, and it is kept up to date in the background while you are signed in.

Neuron models run in Neuron Chat by default and are hidden from VS Code's own Chat. To keep using them there too, set neuronChat.nativeChatModels to available.

Each step carries a short name and a few plain words on what it is for, names the file it is working on, and shows one short fact in a small label: the lines it read, how many matches a search found, or how far a task list has come. A command that failed says how it ended; one that worked does not. A change shows how many lines it added and removed and opens on the changed lines themselves. Images you attach appear as small pictures in one row; other attachments show their name with an icon for what they are, and a long paste becomes a "Pasted" tile that the model still reads in full.

If the service is busy or your connection drops for a moment, Neuron tries the request again on its own, up to three times. If a reply still stops, Try Again continues from where it stopped instead of starting over.

By default Neuron Chat offers VS Code's editor tools, Neuron's own tools and Neuron+ Cloud Memory. To also offer the tools of your own MCP servers, turn on neuronChat.chatViewMcpTools.

Making long conversations cheaper

The largest saving comes from not paying twice for the same text. Everything that repeats on every turn — the instruction preamble, the tool list, the skills index, and the conversation so far — is sent in a byte-identical form each time, which is what lets the service charge a fraction of the normal rate for it. Neuron keeps that part stable on purpose: the tool list is ordered deterministically, and recalled memory is appended once rather than re-inserted, because a single byte moving would undo the discount for everything behind it. It also marks the end of the conversation as a cache point itself on every request, so the history is read back at the reduced rate however many instruction blocks the service adds in front of it.

Codebase search results are excerpts rather than whole chunks, for the same reason they cite a file and line range: they are pointers to open, not the file itself.

When a long conversation fills the model's context window, Neuron summarizes the older turns, including tool calls and results. That summary stays in the conversation; if Neuron cannot create it, the request falls back to trimming older turns. Choose how early this happens with neuronChat.compactMode (early, normal, or late), or type /compact in Neuron Chat to summarize now, optionally followed by what the summary must keep.

Built for long sessions

Neuron is designed to stay responsive during long working sessions:

• Streaming text is delivered in small batches to reduce rendering and extension-host overhead.
• Prompt preparation reuses local context and model work instead of repeatedly scanning the same data.
• Automatic indexing yields between batches, pauses while a prompt is active, and resumes only when there is pending workspace work.
• Sidebar polling and gateway checks pause when VS Code is unfocused or the panel is hidden. Endpoint health checks also stop while you have an endpoint pinned, because there is no route left to choose.
• Timers, watchers, network requests, and background embedding work are cancelled when their panel, request, or extension lifecycle ends.
• Model catalogs and runtime caches avoid duplicate updates and remain bounded during long-running sessions.

Neuron+ Adaptive Instructions

Before a Neuron model answers a new request, Neuron restates it as a short spec — goal, scope, constraints, and what "done" means — and sends it after your own words, which travel with it unchanged so Neuron always knows what you actually asked. Your words win where the two disagree. The answer opens with a short card showing that spec and the context that went with it: a matching skill and what you attached. Questions, slash commands, and prompts already written as specs are sent as typed.

It adds one quick request per new prompt (up to 10 seconds) and is always on. To review a restated prompt before sending it, run Neuron: Improve Prompt; the result goes into the Chat input for you to edit.

Customize what your agents know

Open Neuron: Customize to manage three things in one place. Memory lists what Neuron remembers on this machine and in Neuron+ Cloud Memory, and lets you edit, delete or forget it. Skills lists every skill with a switch to turn it off, lets you write your own, and has a Discover tab for the public skills directory. Knowledge installs up-to-date library documentation for your agents to search before they write code.

Skills Neuron already knows

Neuron ships with a library of expert playbooks — backend architecture, code review, refactoring, documentation, testing, security, cloud, and DevOps. They are active as soon as the extension is installed, with nothing to configure.

You do not need to name one. When your request matches a playbook, Neuron reads it and follows it; the rest stay out of the way. Because only a short index of the available skills travels with each request, having many of them does not slow your conversations down.

Ask Neuron to install one for you, for example: “Install the skill from owner/repo.” The install_skill tool fetches it, checks its SKILL.md, and installs it into Neuron's own skills folder, so it works from the next message. To add your own by hand, create a folder per skill under .neuron/skills/ in your project, each with a SKILL.md describing what it is for and when to use it. A skill you write replaces a built-in one with the same name. Reload the window after adding one.

Understand your project

Neuron can search your project by meaning, not only by exact words. It can also research current information on the web and search GitHub for code, repositories, issues, and pull requests. This makes it easier to ask questions such as:

“Where is the login flow handled?”

“Find the VS Code API docs for language model tools.”

“Search facebook/react for the implementation of createRoot.”

Search documents too

Word, Excel, PowerPoint, OpenDocument and Jupyter notebook files are converted to text and indexed beside your source, so "where is the Q3 revenue table" can find it in a spreadsheet. A search hit opens at the same line numbers everywhere, because one conversion serves the index and your assistant. PDFs are listed and can be opened by path; their text is not searched.

Research the web and GitHub

In Chat, Neuron can search the web and read relevant pages. Search snippets are previews; Neuron can fetch the page for the readable text. Fetched pages are untrusted content, and the fetch tool blocks private, local, and cloud metadata addresses, including after redirects.

The github_search tool searches code, repositories, issues, and pull requests using your GitHub sign-in in VS Code. Code searches need a repository, organization, or user scope, for example repo:microsoft/vscode. If VS Code asks for permission to use your GitHub account, allow it to enable search.

Generate images

Ask Neuron to draw an image, for example: “Generate a flat logo for a coffee shop.” The generate_image tool uses an image model from your Neuron account, tries the next one if a model fails, saves the image under .neuron/images/ in your workspace, and shows it in the reply.

Analyze workspace images

Ask Neuron to read an image in your workspace, for example: “Use analyze_image to read media/error.png.” Neuron sends the image to a vision-capable model in your Neuron account and returns a report with visible text and layout details. Images must be inside the workspace and in PNG, JPG/JPEG, GIF, or WebP format.

Precise date and time calculations

Ask date, time, and calendar questions without model guessing, for example: “How many business days between now and the end of the month in Asia/Jakarta?” The datetime_utils tool calculates exact current time (now), time-zone conversions (convert), duration and calendar/business days (diff), and calendar arithmetic (add).

Interactive charts

Ask Neuron to visualize comparisons or trends, for example: “Draw a bar chart comparing Q1-Q4 revenue.” The render_chart tool validates the data and saves clean SVG charts (bar, line, pie) to .neuron/charts/ in your workspace, displaying them directly in the conversation.

How it works

• A project index is prepared automatically after you open a workspace and sign in. The first pass always runs to completion; later refreshes step aside while you are chatting.
• The index updates after your files change, so you can keep working without rebuilding it manually.
• The Codebase Index row near the bottom of the Neuron sidebar shows the current status.
• Run Neuron: Index Workspace (Semantic Search) from the Command Palette whenever you want to start an immediate refresh.
• You can ask Neuron to find relevant parts of your project directly from Chat.

The automatic index is created on your device by default. If you manually start an index and on-device processing is unavailable, Neuron may use its embedding service as a fallback. In that case, the selected source excerpts are sent to Neuron for processing. Automatic indexing is always on.

Personalize how Neuron works

Open the Neuron sidebar to adjust the experience. Endpoint settings remain in the Options tab; the active reasoning setting is now shown above Context Window in the status card.

Reasoning Effort

Choose how much time Neuron should spend thinking from the Reasoning Effort control above Context Window:

• Smart Adaptive — Neuron chooses automatically for each question.
• Low — faster answers for simple requests.
• Medium — a balanced setting for everyday work.
• High — more careful reasoning for complex questions.
• XHigh — strong reasoning for demanding problems.
• Max — the deepest available reasoning.

Smart Adaptive works the way the Neuron desktop app does. It settles one level per request you type, and every step of that reply (tool calls included) uses the same level:

1. System One. Your account's System One model reads the request together with the previous request and reply, so a short follow-up like "go ahead" is judged by what it refers to. It runs alongside Neuron+ Adaptive Instructions and adds at most 3.5 seconds.
2. Your project. Without a System One answer, Neuron+ Adaptive Instructions' suggestion is used, kept within one level of what the request names in your project index: real files and folders raise the level, and words in any language count the same. A short message that names nothing stays light.
3. What happened. When a reply runs out of room, the next two requests start one level higher.

The response budget scales with the level and never exceeds the model's output limit.

Models that do not support reasoning are skipped entirely. Neuron reads this from its own model list, so no thinking tier is sent to a model that cannot use one, and such a model keeps its full response length instead of being shortened to match a setting it never honours.

Context Window

Neuron follows each model's own context window, so there is nothing to configure. VS Code manages the conversation history it sends. If an over-long conversation still reaches Neuron, Neuron summarizes older turns before dropping them; if summarization is unavailable, it trims history so the request can fit. Models with larger windows use their full advertised capacity, and Neuron reports that same figure to VS Code — so VS Code does not build a prompt larger than Neuron will actually send.

The Context Window row near the bottom of the sidebar, alongside Codebase Index, shows how much of the usable prompt space your latest request consumed. The bar reads left to right: a striped block for space Neuron holds back on purpose — room for the reply, tool and request overhead, and a small estimation safety margin — then a solid segment for what your last request actually used, then whatever is still free. A thin marker inside the used region shows the session's highest usage for that model, so a single large request no longer leaves the reading pinned at 100%.

Hover the row for the exact breakdown, including the current prompt, the session peak, each protected segment, and whether older turns were trimmed. The row stays visible when you switch between tabs and remembers the last value when you close and reopen the sidebar. The value is available for requests sent through a Neuron model; VS Code does not expose token usage from other providers such as Copilot models.

Explore / Subagent Model

Choose which model should handle work delegated by VS Code’s Explore or subagent experience. Auto [VS Code] uses VS Code’s own model selection; Neuron+ Agent lets Neuron choose automatically. The remaining choices pin a specific Neuron model.

Planner Model

Choose which model should be used by VS Code’s built-in Plan experience. Auto [VS Code] uses VS Code’s own model selection; Neuron+ Agent lets Neuron choose automatically. The available choices depend on the models supported by your account.

Background models

In the Models tab, choose how Neuron handles images and long-chat summaries:

• Images to a vision model — Always lets analyze_image send workspace images to a vision model, Ask each time requests confirmation, and Never prevents image analysis.
• Vision model — choose a specific vision-capable model, or leave Automatic to use the first compatible model in your account.
• Summary model — choose the model used to summarize older chat turns, or leave Same as chat to use the current chat model.

The image and summary calls are side tasks, not chat turns; they are excluded from the Hub audit transcript. Images selected for analysis are sent to Neuron Hub.

Endpoint

Neuron currently runs on a single endpoint, so there is nothing to choose between and the picker is not shown. Requests go straight there, and no endpoint health checks run in the background. The picker and Neuron+ Smart Adaptive routing return when more endpoints are available.

Audit Transcripts

Neuron Hub records Chat conversations for the company audit trail when your account's profile has audit turned on. VS Code adds the one thing Neuron Hub cannot see, what tools returned, and sends it in the background without delaying chat responses. Prompts VS Code writes on its own, such as chat titles, are never recorded.

See your usage

The Neuron sidebar includes four tabs:

• Limits — see your current limits, how much is left in each time window, and use available reset credits to instantly restore your quota on demand.
• Tokens — see today’s, last 7 days’, and all-time usage, plus your most-used models.
• Models — choose models for Explore/subagent work, the Planner, image analysis, and long-chat summaries; set the image analysis policy.
• Options — customize reasoning and endpoint behavior.

The Reasoning Effort, Context Window, Codebase Index, and Cloud Memory rows sit together near the bottom of the sidebar, so the active reasoning mode, prompt usage, indexing state, and memory connection stay easy to check while you work.

The dashboard refreshes automatically while you are signed in. You can also refresh it manually. Hover over a usage percentage to see the exact count when that detail is available. Limits that reset every minute or less show no reset time, because it would be out of date almost as soon as it appeared.

Updates and helpful shortcuts

• When a newer Neuron Companion version is available, the sidebar shows an update indicator and the panel displays an update notice.
• The update notice includes a button that opens the extension’s update page in VS Code.
• The Web Panel button opens the Neuron web panel in your browser.
• The Status button opens the current Neuron model and service status page.
• A What’s New page opens after an update, and you can reopen it anytime from the Command Palette.

Commands

Open the VS Code Command Palette with ⇧⌘P on macOS or Ctrl+Shift+P on Windows and Linux.

Privacy at a glance

• Chat messages are sent to Neuron so Neuron can answer your questions. With Neuron+ Adaptive Instructions on, each new prompt is also sent once to Neuron to be restated, together with the names (not contents) of matching project files and attachments.
• When your account's profile has audit turned on, Neuron Hub records Chat conversations and VS Code adds tool results in the background.
• Unexpected errors in Neuron's own code may be sent to Sentry for reliability monitoring, with the error message and stack trace. Cancelled requests, network and server errors, errors from other extensions, and problems with your own files are not sent. Prompt content, workspace files and paths, request bodies, user identity, credentials, and tool data are removed before reporting. This monitoring is independent of VS Code's telemetry setting.
• Automatic project indexing is performed on your device by default.
• Manual indexing can use Neuron’s embedding service as a fallback when local processing is unavailable; only the selected source excerpts needed for that process are sent.
• Your sign-in is stored by VS Code and is removed when you choose Log out.

Network hosts

If your network uses an allowlist, Neuron needs two hosts:

Requirements

• Visual Studio Code 1.125 or newer.
• A Neuron account.
• An active internet connection for sign-in, Chat responses, usage information, and model/service status.

Build and publish an update to the VS Code Marketplace

For extension maintainers with access to the sadatech Marketplace publisher:

1. Choose the next version in package.json using semantic versioning. Keep the root package version in package-lock.json in sync, and add the release date and user-facing notes at the top of CHANGELOG.md. Update the version in this README too.
2. Run npm run vsix. This cleans previous build outputs, runs lint and tests, builds all extension bundles, runs the activation smoke test, and packages dist/neuron-chat.vsix. The repository's script passes --no-dependencies; keep using it because the extension bundles its runtime code.
3. Optionally install the package locally and check it in VS Code: code --install-extension dist/neuron-chat.vsix --force. This replaces the installed extension for the current VS Code profile.
4. Publish that exact, verified package with npx vsce publish --packagePath dist/neuron-chat.vsix. Set VSCE_PAT in the environment first using an approved secure credential store. Do not put the token in source files, shell history, command arguments, or commit it. Publishing requires permission for the sadatech publisher and makes the version available on the Marketplace.
5. Confirm the new version appears on the Neuron Companion Marketplace page, then push the release commit and its version tag according to the team's release process.

Do not publish an unchanged version: the Marketplace uses the extension version as the release identifier. This repository's npm run vsix builds a VSIX but does not publish it.

Feedback and support

If something does not work as expected, open an issue on GitHub Issues or contact SADATA Helpdesk.