Most AI agents have a terrible memory. They can answer a question brilliantly in one session and then start completely from scratch in the next, with no record of what worked, what failed, or how ideas connect. RuVector is built to fix exactly that problem. Launched commercially on October 20, 2026, by San Francisco company Cognitum One, RuVector is an open-source Rust engine that combines vector search, graph relationships, and self-learning memory for AI agents in a single system. In this guide, we explain what RuVector is, how its memory actually works, what its headline performance claims mean in plain language, and who should and should not try it.
Table of Contents
- What Is RuVector?
- Why AI Agents Forget and Why That Costs You
- How RuVector Works
- RuVector Performance Claims, Honestly Explained
- RuVector vs Traditional Vector Databases
- Who Should Use RuVector and Who Should Not
- How to Get Started With RuVector
- RuVector Pricing and Licensing
- RuVector Limitations and Open Questions
- The Bigger Picture: Memory Is the Next AI Agent Battleground
- Final Verdict: Is RuVector Worth Trying?
- Frequently Asked Questions

What Is RuVector?
RuVector is a database engine designed for a world in which software is increasingly built from AI agents rather than simple programs. Traditional databases store facts. RuVector stores something richer: the meaning of information as vectors, the relationships between pieces of information as a knowledge graph, and a record of which answers actually proved useful and it uses that record to get better over time.
The project comes from Cognitum One, a company building what it calls a sovereign agentic platform. Inside that platform, each piece has a distinct job. Ruflo coordinates teams of agents. ruOS gives those agents governed computers to work on. And RuVector is what they remember. As founder and Chief AI Officer Reuven Cohen put it at launch: Agents are only as good as what they remember. Most vector stores, he argued, can tell an agent what looks similar. It also tells it how things are connected and which answers worked before.
It is written in Rust, a language prized for speed and safety, and it runs in three places that matter to different kinds of teams: on a server, inside PostgreSQL, and in the browser or at the edge on small devices. That flexibility is one of its main selling points: memory can sit wherever an organization’s data and agents already are, rather than forcing everything into a hosted cloud service.
The numbers behind the launch are striking, though they come from the company itself and should be read that way. As of September 30, 2026, the project was seeing more than 500,000 downloads a month across its npm and crates.io packages, with more than 4,400 GitHub stars and 580 forks. For an open-source infrastructure project, that is a serious developer base and it is the traction evidence behind the commercial launch, not just a press release.
Why AI Agents Forget and Why That Costs You
To understand why it matters, it helps to see the problem it solves. A typical AI agent today works like this: you give it a task, it searches a knowledge base for relevant material, it generates an answer, and then the session ends. The next session starts cold. Nothing the agent learned, which document actually solved the problem, which approach failed, which facts belong together, carries over.
This creates three practical costs. First, repeated work: every session re-discovers the same answers. Second, lost quality: the agent cannot prefer the answer that worked last time over one that merely looks similar. Third, lost context: most vector databases store embeddings, numerical representations of meaning, without recording how ideas connect. A support agent might find a similar old ticket but miss the graph link showing that the fix only applied to a particular product version.
Teams have patched this gap with separate systems: one database for vectors, another for graphs, a third for feedback logs, plus glue code to hold them together. Each extra system adds latency, cost, and failure modes. The pitch is that one engine can do all three jobs, search, relationships, and learning, without the glue.
This is also why the launch landed in October 2026, at the peak of the agent boom. Companies are moving from one agent answering questions to teams of agents doing real work: handling support tickets, triaging code, drafting documents. The moment agents do ongoing work, memory stops being a nice feature and becomes infrastructure. That is the shift RuVector is betting on.

How RuVector Works
The engine combines four capabilities in one system. Each one solves a different part of the memory problem, and they are worth understanding separately before judging the whole.
Vector Search and Knowledge Graph in One Engine
At its core, it performs fast vector search using HNSW indexing with SIMD acceleration, techniques that let it find similar items in large collections in sub-millisecond time. Alongside that search sits a Cypher-compatible knowledge graph. Cypher is the query language made familiar by graph databases, so teams that already think in nodes and relationships can query RuVector’s graph directly.
The practical effect is that an agent can do two things in one query: find material that is similar and follow how facts relate. Imagine a customer support agent receiving a ticket about a login failure. It retrieves a previous resolution for a similar ticket, then follows its graph link to the product version it applied to, and confirms the fix still matches. That second step, the relationship check, is what a pure vector store cannot do, and it is where many agent mistakes come from.
It also includes a graph neural network layer between initial search and final results. This layer strengthens frequently used paths through the graph, so connections that keep proving useful become easier to follow. Think of it less like a filing cabinet and more like a well-worn path through a forest: the routes people actually use become clearer over time.
Feedback Learning: SONA and EWC++
The most distinctive part of RuVector is that it learns from explicitly recorded feedback. When a team records which results helped, for example, when a support lead marks an answer as helpful, its SONA system updates lightweight LoRA adapters, small trainable modules that adjust retrieval behavior. Cognitum One reports accuracy gains of 10 to 30 percent from usage feedback, though that figure comes from the company’s own benchmarks and has not been independently verified.
Two design choices here matter. First, reads alone never change learned weights. Simply looking something up does not teach the system; only explicitly recorded feedback does. That guards against the system quietly drifting because of casual browsing. Second, EWC++ consolidation, a technique related to Elastic Weight Consolidation, protects earlier learning from being overwritten by new feedback. This addresses catastrophic forgetting, the well-known problem where a learning system masters a new task by forgetting an old one.
Importantly, adapter learning is separate from index tuning and ranking settings, which teams control directly. That separation matters for governance: a team can keep human control over how results are ranked while still letting the system learn from feedback. And because the SONA updates run as LoRA micro-updates on a standard CPU, teams do not need a GPU farm to benefit from the learning feature.
Inside PostgreSQL
Many organizations already trust PostgreSQL with their most important data. It meets them there with the ruvector-postgres extension, which is pgvector-compatible and adds 143 SQL functions for vector, graph, and hybrid search inside an existing database. In plain terms, a team can add self-learning agent memory to the database it already runs, rather than standing up and securing a brand-new system.
This is also a cost and compliance story. Running memory inside Postgres means data does not have to leave the infrastructure a company already audits and controls. For enterprises operating under data sovereignty or regulatory constraints, the audience Cognitum One explicitly targets, that matters as much as speed. Founding CEO D. Christopher Keil framed it this way at launch: enterprises want agents that remember their business, not just the last conversation, and they need to know where that memory lives and who changed it.
One honest caveat from the launch material itself: teams should confirm compatibility for their specific pgvector workloads, and full migration details live in the project’s technical guide. PostgreSQL compatibility is a strong starting point, not a guarantee that every existing setup migrates without work.
Portable Memory: The RVF File Format
The fourth capability is portability, delivered through a file format called RVF. An RVF file packages vectors, indexes, and metadata in a single file, with copy-on-write branching and SHAKE256 witness chains, a tamper-evident record of every change. In practice, that means a memory store can be copied, branched, versioned, and audited much like a document, and the same memory runs on servers, in WebAssembly in the browser, and on edge devices.
The audit trail is a genuine differentiator. Because every change carries a tamper-evident witness, a team can answer questions like who changed this memory, and when, questions that matter enormously once agents start making decisions that affect customers, money, or compliance. Running locally also avoids hosted vector-service fees, which is part of the cost argument for self-hosting.
It even bundles ruvllm, a built-in local runtime that runs language models and generates embeddings on-device with CUDA and Metal acceleration. An RVF file can bundle data, models, and graph structures into a single artifact that boots a microkernel in milliseconds. Cognitum One describes this as making it work almost like an operating system for agents at the edge, ambitious language, but it points to a real design goal: agent memory that works on small devices, not only in data centers.

RuVector Performance Claims, Honestly Explained
The launch material makes bold performance claims, and they deserve a careful reading. Cognitum One says its Rust engine, with SIMD acceleration across AVX-512 and NEON instruction sets, delivers search latency as low as 61 microseconds, which its benchmarks put at 30 to 800 times faster than typical vector databases, and more than 52,000 inserts per second on commodity hardware. It also says it needs about 200 MB of memory per million vectors, compared with the 1 to 3 GB typical of other vector databases, with automated RaBitQ and product quantization compressing data 2 to 32 times.
Here is how to interpret those numbers. First, all of them are Cognitum One’s internal benchmarks, and the launch material says plainly that they depend on hardware, dataset size, recall settings, and configuration. A 61-microsecond figure on one workload does not guarantee the same result on yours. Second, the 30 to 800 times faster range is so wide that it tells you more about how much vector-database performance varies by workload than about any single number. Third, the memory claim is the most practically interesting: if it holds on real workloads, demanding retrieval could run on low-cost CPUs without GPUs, which changes who can afford to run agent memory at all.
None of this means the claims are false. Rust with SIMD acceleration genuinely is fast, and quantization genuinely does shrink memory. It means the honest position for a buyer is: these are promising vendor benchmarks that need testing on your own data before you commit. Cognitum One itself recommends exactly that approach, start with one memory store and one agent, measure retrieval quality on real queries, and add graph, feedback learning, and RVF features only as each one earns its place.
RuVector vs Traditional Vector Databases
The table below summarizes the core difference in plain terms. It is based on the launch description and the standard behavior of conventional vector stores.
| Capability | Traditional vector database | RuVector |
|---|---|---|
| Similarity search | Yes, this is the core job | Yes, HNSW with SIMD, sub-millisecond queries |
| Knowledge graph relationships | No, needs a second database | Built in, Cypher-compatible graph with hyperedges |
| Learning from feedback | No, passive storage | Yes, SONA LoRA updates from recorded feedback |
| Protection against forgetting | Not applicable | EWC++ consolidation protects earlier learning |
| PostgreSQL integration | Varies, often a separate service | Native extension, pgvector-compatible, 143 SQL functions |
| Portable, auditable memory | Export tooling varies | RVF single file with SHAKE256 witness chains |
| Runs in browser and at the edge | Usually server-only | Yes, WebAssembly and edge devices |
| Memory per million vectors | Typically 1 to 3 GB (company comparison) | About 200 MB (company claim) |
The table makes the bet clear: it is not trying to be a slightly faster version of an existing tool. It is trying to replace a stack, vector store plus graph database plus feedback log plus export tooling, with one engine. Stacks like that are where real projects slow down, so if the integration holds up in production, the value is in simplicity as much as speed.

Who Should Use RuVector and Who Should Not
It is a strong fit for:
- Teams running agents in production, support, operations, or internal tools where agents handle repeat tasks and quality improves when past successes are remembered.
- PostgreSQL shops, organizations that already run Postgres and want agent memory inside infrastructure they trust, without a new hosted dependency.
- Regulated or sovereignty-sensitive teams, companies that need memory on their own infrastructure, with an auditable record of changes, rather than in a third-party cloud.
- Edge and browser use cases, products where agents must work on devices or in browser tabs, where a full server-side stack is impractical.
- Cost-sensitive builders, teams that want to avoid hosted vector-service fees and run demanding retrieval on low-cost CPUs.
It is probably not the right first step for:
- Anyone who just needs a chatbot over documents, a standard retrieval setup will be simpler, and RuVector’s learning and graph features will go unused.
- Teams with no one to measure retrieval quality, the feedback-learning loop only helps if someone records which results helped and checks whether quality actually improves.
- Buyers who need a fully managed service, it is open-source infrastructure with commercial support available, not a sign-up-and-go hosted product.
- Projects that cannot tolerate vendor-benchmark uncertainty, if you need independently verified performance numbers before adopting anything, wait for third-party benchmarks.
How to Get Started With RuVector
Getting started is deliberately simple. The launch material gives a single install command, npm install ruvector, which detects the system and uses native Rust bindings, or falls back to WebAssembly for browsers and iOS. That zero-config approach is part of the pitch: one install, and the same engine runs on a server, in Postgres, in a browser tab, or on a small device at the edge.
The company’s own recommended rollout is refreshingly cautious, and it is worth following. Start with one memory store and one agent. Measure retrieval quality on real queries, not demo data, before adding anything else. Then add the graph, feedback learning, and RVF features one at a time, only as each one earns its place. That discipline protects you from the most common infrastructure mistake: adopting every feature at once and never learning which one actually helped.
For developers, the practical checklist looks like this:
- Install RuVector and load a small, real dataset, not a toy example.
- Run your agent’s actual queries and record which results were genuinely useful.
- Compare retrieval quality with and without the graph relationships switched on.
- Turn on feedback learning only once you have a reliable way to record helpful results.
- Test the PostgreSQL extension separately if you plan to run memory inside Postgres.
- Check the RVF audit trail: can you trace who changed a memory store, and when?
Installation commands, benchmarks, and the full feature inventory are in the project’s technical guide on GitHub, which is the authoritative source for setup details beyond this overview.
RuVector Pricing and Licensing
Here is the honest answer on price: there is no public price list for it, and this article will not invent one. The core project remains open source under the MIT license, which means teams can use it freely under that license’s terms. What the October 20, 2026, commercial launch added is a Cognitum One commercial license: a contract with enterprise support, deployment and configuration services, upgrade and maintenance commitments, and deployment alongside Ruflo and ruOS on infrastructure the customer controls.
Two cost notes matter for budgeting. First, commercial licensing is negotiated, not listed, enterprise buyers should expect to talk to Cognitum One directly. Second, model and infrastructure costs still apply: it is the memory layer, not the language model or the servers, so those costs sit on top. The real saving in this story is not a subscription price but the avoided cost: no hosted vector-service fees when running locally, and lower hardware requirements if the memory-efficiency claims hold on your workload.
For US teams comparing options, that framing matters. A free MIT-licensed core with paid enterprise support is a familiar open-source business model, and it means a small team can start without spending anything, while a large enterprise can buy the contract and support it needs. What it does not mean is that it is free in every sense, engineering time, infrastructure, and model costs are real, and any honest budget should include them.

RuVector Limitations and Open Questions
No launch story is complete without its caveats, and RuVector has several worth naming plainly.
Performance and accuracy figures are vendor-reported. The 61-microsecond latency, the 30-to-800-times speed claim, the 52,000 inserts per second, the 200 MB per million vectors, and the 10-to-30-percent accuracy gains all come from Cognitum One’s internal benchmarks. Independent verification has not yet appeared, and results will vary with hardware, dataset, and configuration. Treat them as a promising starting point, not a guarantee.
Feedback learning depends on feedback discipline. SONA only learns from explicitly recorded feedback. A team that never marks results as helpful will get no learning benefit, and a team that records feedback carelessly could teach the system the wrong lessons. The feature is powerful, but it is not automatic.
PostgreSQL migration needs checking. The extension is pgvector-compatible, but the launch material itself advises teams to confirm compatibility for their specific workloads. Existing setups should be tested, not assumed.
Commercial details are thin. Beyond the existence of a commercial license with support and deployment services, there are no public prices, service-level terms, or enterprise customer names in the launch material. Buyers who need those answers will have to ask Cognitum One directly.
It is infrastructure, not a finished agent product. It will not write your support replies or run your business. It gives agents memory. Teams still need agents, models, and workflows around it, and the judgment to decide what agents should and should not do.
The Bigger Picture: Memory Is the Next AI Agent Battleground
This launch does not exist in isolation. It lands in a month when the agent stack is being rebuilt piece by piece. Some companies are opening their platforms to agents, Walmart, for example, has built tools letting AI agents shop and buy on its behalf. Others are blocking agents outright, as we explained in why websites block AI agents. And Google has shipped agent infrastructure of its own, covered in our Google Data Agent Kit guide.
Memory sits underneath all of these stories. An agent that shops for you needs to remember your preferences and spending limits. An agent that works inside a company needs to remember its policies and past decisions. An agent that is blocked by a website needs to remember what it tried and what failed. Whoever builds the best memory layer, one that is fast, portable, auditable, and under the user’s control, gains leverage over the whole agent stack.
That is also why the emphasis on control matters. The launch repeatedly stresses that memory runs on the customer’s infrastructure, inside Postgres they already trust, with a tamper-evident record of changes. In a market where most AI capability arrives as a hosted black box, a memory system you can inspect, move, and audit is a genuinely different offer, and it matches the direction of travel for enterprises that are serious about agents but nervous about handing their institutional knowledge to someone else’s cloud.
It is worth connecting this to the week on our own site. Just today, we covered Moonshot’s Kimi K3.1 Pro quota reset, a story about what happens when agent infrastructure buckles under real demand. It is the other side of that coin: infrastructure built to make agents cheaper and more reliable to run, rather than more expensive. Both stories point the same way, the agent era will be won or lost on infrastructure, not demos.
Final Verdict: Is RuVector Worth Trying?
It is one of the more interesting infrastructure launches of October 2026, and the reasons are concrete rather than hype-driven. It solves a real problem, agents that forget, with a coherent design: vector search plus graph plus feedback learning in one Rust engine, running in Postgres, in the browser, and at the edge, with a portable and auditable file format. Its developer traction, at more than 500,000 monthly downloads and thousands of GitHub stars, suggests real usage rather than launch-day noise.
At the same time, the right way to try RuVector is the way its own maker suggests: small, measured, and skeptical. Start with one memory store and one agent. Test the performance claims on your own data. Record feedback carefully before expecting learning gains. Confirm Postgres compatibility for your setup. If the numbers hold on your workload, you have a strong case for adopting it more widely. If they do not, you have lost little, because the core is MIT-licensed open source.
For teams building agents that need to remember, support teams, operations teams, enterprises with compliance requirements, it deserves a serious look this month. For everyone else, it is still worth understanding, because the memory layer it represents is about to matter to every agent product you use. The agents of 2027 will not just be smarter. They will remember. It is an early, credible attempt to build the database they will remember with.
Frequently Asked Questions
What is RuVector in simple terms?
RuVector is an open-source database engine that gives AI agents memory. It combines vector search (finding similar information), a knowledge graph (tracking how facts relate), and self-learning from feedback (getting better at retrieval when teams record which answers helped) in a single Rust engine.
Is RuVector free?
The core RuVector project is open source under the MIT license. Cognitum One also sells a commercial license that adds enterprise support, deployment and configuration services, and upgrade and maintenance commitments. Model and infrastructure costs still apply on top.
How is RuVector different from a normal vector database?
A normal vector database stores embeddings and finds similar items. It adds a Cypher-compatible knowledge graph, learns from explicitly recorded feedback through SONA LoRA updates with EWC++ protection against forgetting, and packages memory in a portable, auditable RVF file that runs on servers, in the browser, and at the edge.
Does RuVector work with PostgreSQL?
Yes. The ruvector-postgres extension is pgvector-compatible and adds 143 SQL functions for vector, graph, and hybrid search inside an existing PostgreSQL database. Teams should still confirm compatibility for their specific pgvector workloads.
How do I install RuVector?
The launch material gives the command npm install ruvector. The install detects the system and uses native Rust bindings, or falls back to WebAssembly for browsers and iOS. Full installation commands and benchmarks are in the project’s technical guide on GitHub.
Are RuVector’s speed claims independently verified?
No, not yet. The 61-microsecond latency, 30-to-800-times speed, 52,000 inserts per second, 200 MB per million vectors, and 10-to-30-percent accuracy figures are Cognitum One’s internal benchmarks, and the company states they depend on hardware, dataset size, recall settings, and configuration. Test them on your own data before committing.
Sources and further reading: the Cognitum One launch announcement via Access Newswire, and the official overview at cognitum.one/ruvector. Performance, memory, and accuracy figures in this article are attributed to Cognitum One’s own benchmarks, as stated in the launch material.
