A desktop app that runs a fleet of agents. Graph everything you know into local memory, give Cortex an objective and let it split the work across agents that iterate rather than stopping at the first attempt, and keep every byte on the computer in front of you. Free is out now as a very early beta.
Concretely: you download an application and install it, the same as any other desktop program. It opens on a dashboard. One of its tabs is a chat with Cortex, the assistant that runs the place, and the rest are the screens where the actual work happens.
Underneath that, it graphs what you know, holds what it learned last week, and dispatches sub-agents to do the jobs you hand off. All of it on the machine in front of you.
Cortex assigns the work and everything reports back up to it, so nothing runs unwatched and you are only asked when the decision is actually yours. They all read from memory and save to it, which is why what one run works out is there for the next. Nothing here leaves your computer unless you connect an outside model and allow it to.
Memory is only useful if reaching into it is free. These are measured numbers from the search benchmark in the NeuralVault source, run over a real vault of 3,479 notes, not a demo corpus built to flatter the index.
Stated honestly, because you will find this out yourself: semantic search also has to embed your query first, and that round trip to the model costs more than the index lookup does. The numbers above are the part NeuralVault controls.
Every note is a node and every link between them an edge, laid out so you can see the shape of what you have written rather than scrolling a folder tree. Answers cite the note they came from.
Hand a job off and the agent taking it decides whether it needs breaking up, then spawns sub-agents for the pieces. You see which tools each may touch and get the diff back for approval, not a fait accompli.
Agents get a defined set of things they may touch and nothing outside it. You decide what is on that list before anything runs.
What ran, when, and why it decided to. When something changes unexpectedly, there is a trail rather than a shrug.
What it learned about your stack last week is still there this week. It gets sharper the longer you run it, without manual retraining.
Use an outside API while you evaluate it, then move the model onto your own hardware and cut the last thing that leaves the machine.
It makes the change, runs the suite, reads what actually failed and goes again, up to a bounded number of rounds. You get the result of a loop rather than a first draft, and it stops on its own rather than running away with your machine.
This is the part that makes it a harness rather than a chat window. You are not managing a list of bots. You brief one controller, it works out who does what, and the results come back up to it rather than landing in your lap piece by piece.
The assistant in the chat tab is also the controller. You give it the objective, it decides which agents the job needs, hands them their share of it and watches what comes back. You are talking to the thing in charge rather than to one worker among many.
An agent is a Markdown note: its standing instructions, the tools it may call, the folders it may touch, when it runs and what it may spend. Write a new one in your editor and it joins the fleet. There is no hidden config and no opaque registry, so an agent that behaves oddly is a file you open and read.
Delegation is a tool an agent can call, so an agent handed something large breaks it up and hands the pieces down to sub-agents of its own. Each inherits a narrower scope than its parent, never a wider one, and reports its result back up the chain rather than off to the side.
Decisions climb the same chain the work came down. A sub-agent that needs a call asks the agent that gave it the job. That agent settles what it can and passes up only what it cannot. Cortex does the same, and puts something in front of you when the answer is genuinely yours: an executive call, a judgement it should not be making alone, or a case where it is simply not sure. The point of the hierarchy is that you are the last resort rather than the first interruption.
Underneath all of it: every agent is held to the tools and folders it was given, every call it makes is written to an audit log and a run ledger, and files are snapshotted before any agent writes to them so a bad run rewinds byte for byte. Agents can even propose edits to their own instructions, and those proposals wait in a review queue for you rather than taking effect.
You are not locked to one model, and you are not limited to one at a time. Run any Ollama model locally, point it at any OpenAI-compatible endpoint, or add an API key for any cloud provider at all, then choose per role which model does what. There is no approved list: if it has an API, it can take a seat.
That is what makes checking possible across vendors rather than within one. Put a frontier model from one lab against a frontier model from another, or either against something running on your own hardware, and have them mark each other. A model checking its own work is the weakest check there is, and this is the way around it.
Whichever model you assigned the role does the work and gives its answer.
Not the conversation, not the reasoning behind it: the answer on its own, and one instruction, find what is wrong with it. Unsupported claims, plain errors, parts of the task it skipped, anything that would break if you acted on it.
The answer and the critique together, so you can judge the check as well as the work.
Not a feature list. This is the loop you are in most days, and every step of it happens without your code leaving the machine.
It graphs them into local memory: every note a node, every link an edge. Nothing is uploaded; the index lives beside the files.
Not "explain this file" but "where does this break". It answers from the graph, with paths and call sites you can open.
Not "change this line" but "fix every call site and get the suite green". Cortex assigns it, the agent splits it across sub-agents, and it works through what failed rather than stopping at the first attempt.
Nothing lands without you. Reject it and the correction goes into memory, so the next attempt is better.
Personal is not a code assistant with extras bolted on. It is the whole application, and the repository work above is one of the things you can point it at. These are the other screens, all of them included, none of them an upgrade.
nv: the same fleet, headless, all twelve command surfaces beyond run. Part of Personal, not a separate purchase.
If you have spent months tuning standing instructions, skills and slash commands for another agent, none of that is wasted. Point NeuralVault at the same folder and it picks them up untouched. No migration, no second file to maintain, nothing to rewrite in a proprietary format.
CLAUDE.mdStanding instructions read as written, up to 12,000 characters, and exactly one file per directory so nothing is injected twice.
AGENTS.mdThe same idea in the format every other harness uses. A project set up for one of those runs here with no second file to maintain.
*/SKILL.mdSkills discovered in the standard folder layout. The ones you have already written are found and read, not re-declared.
.claude/commands/Slash commands picked up from the same place they already live, right beside your skills.
MCP serversConnect the servers you already run. Their tools arrive as tools, inside the same permission model as everything else.
CORTEX.mdThe one that is not optional. It is what tells the model how NeuralVault itself works, and it gets its own section below.
Your instructions, your skills, your commands, your MCP servers. What changes is underneath them: memory that survives the session, permissions on every action, and a record of what ran.
A CLAUDE.md by another name, after the assistant that reads it. The difference is what goes in it. Instructions for a coding agent say how you like your code. This says how NeuralVault works, and it is what turns whatever model you point at it into something that can operate the place.
Edit it freely, that is the point. Just do not delete the core sections: they are what tell the model these capabilities exist. Strip them and you keep the features while losing the thing that knows how to use them.
You are most of the way there. NeuralVault reads Claude Code's CLAUDE.md as written, so a project you have already tuned works on day one. It just works better converted, because a CLAUDE.md says nothing about NeuralVault: it was never written for it. Left as-is, your rules get followed by a model that does not know the board or the approvals queue exist.
The conversion is one instruction: ask Cortex to read your CLAUDE.md and write it out as a CORTEX.md, keeping your rules and adding the core sections.
Exactly one instruction file is read per directory and CORTEX.md is checked first, so adding one does not stack on your CLAUDE.md, it replaces it.
Convert rather than copy, or rules you spent months on quietly stop being read.
Not two products, and not a trade. Business is this same application with the company parts switched on. Nothing here is removed or held back: every screen, every agent and every capability on this page is in Business too. What it adds on top matters the moment other people start depending on your output.
The whole harness. Agents, persistent memory, the board, workflows, approvals and the audit trail. Local models, the plugin API, sync across your own devices, and six connectors (Shopify, YouTube, Meta Ads, Search Console, GitHub and RSS) coming soon.
So the question is not which product fits. It is whether you need that layer yet. If you do, go to NeuralVault Business. If you do not, nothing on this page is a compromise.
One price for the software, and a choice about where the model calls come from. Pay the £20, bring your own API keys or run a model on your own hardware, and that is the whole bill: it is a permanent way to use NeuralVault, not a starter arrangement.
Free, Personal and Business are the same application with a subscription between them, so the machine needs the same things whichever one you end up on.
Windows 10 or 11, 64-bit. There is no macOS build, no Linux build and no ARM build.
About 115 MB, and it installs for your user account only, so Windows never asks you for an administrator password.
The light way to run it. The model does its thinking on your provider’s hardware, so your machine only has to run the app.
Much heavier, and worth knowing before you start. Ollama holds the whole model in memory for as long as it stays loaded.
The one local-model number worth having in advance: the model our getting-started guide suggests, qwen3.5:9b, is a 6.6 GB download, and a smaller model costs you proportionally less. We do not publish a minimum memory figure, because with a cloud provider the app is the only thing running on your machine and with a local model it is the model that decides, not us. The app carries its own browser engine, so setup fetches nothing else, and the first run needs a connection only to sign in.
NeuralVault has no AI inside it, on any edition. What you are paying for is the software: the memory, the agents, the permissions and the record of what ran. Model usage is not part of it. Personal starts at £20 a month excluding VAT for that licence, and before anything answers you, you point the app at a model and that half is billed by whoever runs it.
Install one locally through Ollama and it runs on the machine in front of you. No provider is involved, so nothing is billed per message. What it costs you instead is the hardware above.
Connect Anthropic, OpenAI or another provider on an account you hold. They bill you directly at their own rates, and the licence stays the whole of what we charge you.
Managed credit, where you pick a model from a list and pay us for the usage, is its own purchase on top of the licence rather than something the licence includes. It is not on sale yet.
That choice is the reason the requirements above matter. On your own API key the model does its thinking somewhere else and your machine only has to run the app. On a local model your machine does both, so the model you pick, rather than the licence you bought, is what decides the real cost of the work.
The software licence, and only that. The app contains no AI: you run a local model or bring your own API key, and that half is billed by whoever runs it.
Everything on this page, and then
Not on sale yet. What you buy here is the application. Model usage is not included and is billed by your own provider, or costs you nothing beyond the hardware if you run the model locally. Excludes VAT, which is calculated at checkout. The terms are the software licence.
Add API credit and the software drops from £20 to £15 a month, on top of the credit itself. Today you connect your own provider account or run a local model, and nothing you type reaches us. When managed routing arrives you will be able to pick a model from a list instead, and pay for the calls through us.
Run out mid-month and upgrading costs only the difference, not a second full month. From the next billing date it renews at the new rate. Running out of credit is the worst possible moment to be charged twice, so we do not.
Buying usage from us is not on sale yet. The rules it counts by are worth publishing early anyway, because they are the part of a usage meter you are normally asked to take on faith. When it opens, this is what it does, and every line below is something you can hold us to.
Flat, with no invented currency and no conversion to work out. A balance of 31.5 credits reads as 31.5, never rounded up to a tidier 32.
Prices are quoted before the service fee and before tax. Both arrive as separate lines on Stripe’s own checkout page, so neither is folded into a rate where you cannot see it.
Nothing is estimated. The provider reports the cost of that exact message and that is what comes off, converted at a published European Central Bank reference rate rather than one we set ourselves.
It sits in the corner of the app the whole time you work, with a ring at the top that fills as credits go. Nobody should have to open a billing page to find out where they stand.
None of this touches you while you are on your own API key or a local model, because then there is nothing of yours for us to meter: your provider bills you directly and your messages never reach us. It matters only if you decide the convenience of buying the calls from us is worth it.
Install it on every machine you own. Devices are unlimited, so a new laptop or a reinstall never costs you a slot.
Unlimited devices, but only one session runs at once. Start a second and you can end the first right there, no need to be standing at it.
The same vault on every machine you own, without a server in the middle.
Free is the same application with the paid capabilities locked, so trying it costs nothing and moving up is a subscription rather than a reinstall. Running a company rather than a codebase? NeuralVault Business is priced to the size of the deployment and quoted after a free consultation. Weighing the three of them up? See all three editions side by side.
A release list, not a newsletter. The only thing that is ever sent is news of a build: the first download when it is ready, and after that the releases and feature changes big enough to be worth your attention.
It is in active development and the interface is still moving. That is the reason to be early rather than a reason to wait: the people who get in first are the ones whose friction decides what ships.
Be first to the build.The download lands in your inbox the day it is ready. After that you only hear from us when something genuinely changes what the app does. Never a patch note, and your address goes nowhere else.
Thanks. You are on the list. We will be in touch when the first build lands.
Takes about four seconds. No account, no card.
Welcome aboard.You would be joining while the edges are still rough, which is the point: what you find gets fixed first.
No spam, no drip sequence. Pick what you want to hear about and nothing else.