What is Qortex?

Give a capable AI agent a real job and watch what happens twice. It reasons its way to a decision, acts, and does well. Then the session ends, the context is gone, and the next agent starts from nothing. It re-reads the same documents, re-derives the same conclusion, and sometimes, pushed to give an answer it does not have, it fills the gap with something that sounds right and is not there at all.

Qortex is Quox's answer to that. It is a knowledge graph your agents feed and cite: a durable, server-side store of what your organisation actually knows, that an agent can search before it acts and quote from when it answers. So if you have landed here asking what Qortex is, the short version is this. It is the memory your agents share, grounded in your real sources rather than in whatever a model happened to absorb during training.

What Qortex actually is

A knowledge graph is not a folder of documents, and it is not a chat history. It is a structured, searchable map of facts and the links between them, built from your own sources: docs, past decisions, tickets, and the record of what your agents have already done. Qortex builds that map and keeps feeding it as work happens, which is why it is self-feeding rather than a one-off import you have to maintain by hand.

Two things make it specifically useful to an agent. It is queryable the way an agent works: mid-task, the agent asks Qortex a question and gets back the relevant notes with their sources attached, not a pile of files to re-read. And it is kept separate from code intelligence on purpose. RepoBrain answers questions about your codebase; Qortex answers questions about your knowledge, the decisions, the history, the "did we ever do this before" that otherwise lives in people's heads and scattered documents.

An agent that cites, and an agent that declines

The point of grounding an answer in a source is that you can check it. When an agent pulls a fact from Qortex, it can point at the note that fact came from, so a claim stops being "the AI said so" and becomes "here is where this came from, go and read it." That is the same move Quox makes everywhere else: you do not trust the output, you check it.

The harder half is knowing when to say nothing. A retrieval layer that always returns its best guess will confidently hand an agent a near-match for a question your sources never answered, and the agent will run with it. Qortex is built to decline instead: when the answer is not in your knowledge, the useful response is "not found here," not a plausible invention. We measure both halves, how often the right source is retrieved and how often an unanswerable question is correctly refused, and we are tightening them. We are deliberately not publishing a single headline score in this post, because a retrieval number without the method behind it is exactly the kind of claim this blog exists to avoid.

Free in Core, server-side, and yours

Qortex's engine runs inside QuoxCORE, which is free and self-hosted, so the knowledge your agents build lives on your own servers rather than inside someone else's product. That matters for the same reason the rest of Quox is self-hosted: a knowledge layer ends up holding the most sensitive map of your organisation there is, and that map should not have to leave your control to be useful. Qortex also redacts secrets it catches inside itself, so a credential that slips into a note does not sit there in the clear.

The engine is free. The cockpit, the interface for exploring and curating the graph by hand, is a one-off paid add-on. It is the same split we use across the platform: the capability your agents need is free, and the convenience layer a human drives on top is where it is paid.

Why shared memory is a governance question

It is tempting to file memory under convenience, a way to save your agents some re-reading. It is more than that. The moment several agents share one source of knowledge and act on it, that knowledge becomes load-bearing. A wrong fact in Qortex is a wrong fact in every decision that cites it, and a missing source is a gap every agent inherits. So the questions that matter are the governance ones. Where did this come from? When? Can I check it? Is it still true?

That is why Qortex is built to cite rather than assert, to decline rather than guess, and to live on your infrastructure rather than ours. A knowledge layer your agents share is only safe if it is a knowledge layer you can audit. If you want the longer version, the Qortex page walks through how the graph is built and queried, and QuoxMemory covers the durable, server-side memory it sits on.