Remember, at platform scale
The second brain your agents actually use.
Qortex turns everything your team and your agents produce into one governed, self-hosted knowledge graph. Not a chat log. A second brain the whole platform can reason from.
It grows on its own
Qortex · our own knowledge graph, replayed from real data
In plain words
What it is, where it lives, when to reach for it
- What is it
- A knowledge base for your team and agents: markdown notes indexed into one searchable graph.
- Where do I use it
- In the dashboard's Brain view, and from your terminal through the quox CLI.
- When would I use it
- When an agent or teammate asks something your notes already answer, or a decision needs its history.
- How do I use it
- Run
quox brain search "<query>"in your terminal, or open the Brain view and search there.
Not a mock-up
This is what it actually looks like.
The living vessel above is the real shape of it, rendered live. Here is the same graph inside the dashboard's Brain view: every node an igniting neuron, every thread a connection between what you know.
Sources you connect are indexed on their own, every agent can search and cite it, and every note is scoped and provenanced.
Not a database, a memory
Not a chat log. A living knowledge graph.
Most memory bolted onto AI is a chat log or a vector dump. Qortex is different. It ingests everything worth keeping, consolidates it into weighted beliefs, and lets any agent retrieve and cite it, with the provenance attached.
Forget
A transcript is a record of what was said, not what is known. Nothing is consolidated, so nothing is easy to find again.
Sprawl
Everything gets embedded and nothing gets weighed. Retrieval returns whatever is nearby, not what is actually true.
Consolidates and cites
Every Qortex answer shows which sources it cites, and each cited passage is checked against the sentence it supports. Qortex publishes how often answers are grounded: the rate is a number you can check, not a promise.
One memory, three organs, one loop
Three organs, one memory, every agent.
Qortex is three parts that feed each other, then hand off to whichever agent asks.
Brain
Grabs what you need and makes it searchable, chunk by chunk.
QuoxDream
Consolidates the raw material into weighted beliefs while the tab is closed.
QuoxMemory
Holds the distilled version your agents read first.
Agent
Searches and cites it in the same turn, grounded and scoped.
The loop feeds itself: when a newer source changes a fact, the old belief is replaced and kept in a visible history. Deletions propagate from folders, docs, transcripts, plans and memories, and account deletion erases a user's memories and private brain notes.
Server-side, on a schedule
It feeds itself.
Connect a source once and Qortex keeps up with it on its own, server-side, on a schedule. Not a browser timer that only runs when a tab is open.
Sources are grouped by what they give your agents, and you turn on only the ones you want.
Explore your brain
See the shape of what it knows.
This is demonstration data, not a live account, but the shape is the same one you would see for real: notes gathering into vaults, hubs standing out as the ones agents cite most, and links drawn where notes reference each other.
Search plus context, cited
Every agent can search it. Answers cite what you actually know.
Agents reach Qortex two ways: a search tool they can call, and a knowledge context Quox injects into the turn when the instance switches it on. Each passage carries a short handle such as [K1], answers cite the handles they used, and when nothing relevant exists Qortex says so rather than padding the prompt (on blind test sets it declined 70% of questions whose answer was not in the brain). Each cited passage is checked against the sentence it supports. Results are scoped to the org and user asking.
One shared tool, every agent, no copy and paste into prompts.
You
What did we agree on the Q3 renewal terms?
searching the brain
Agent
You agreed a twelve-month renewal at the existing rate, with a five per cent cap on any mid-term increase.
tool quoxbrain_search("Q3 renewal terms")
The real interface
The Qortex cockpit.
Not a mockup. A growth ring of the notes it holds, plus the full page with a note open, below.
- 1Facet by scopeOrg and You read as clickable counts, 1,551 and 331, so organisation-wide knowledge splits from your own notes before you open the graph.
- 2Facet by sourceAgent Memory, Dev Sessions, Git History and Quox Docs each carry a live count, narrowing the 1,882 notes down to one ingestion channel.
- 3Switch the graph modeBrain, 2D and 3D sit in one toggle, so the same notes render as the point-cloud vessel or a flatter layout.
- 4Watch the count take shapeFirst sparks reads 1,882 notes with 118 more taking shape, the same growth figures the ladder further down this page uses.
- 5Open a note's full detailSelecting a node opens its full record beside the graph, here a governed finding on HITL routing tool names with its origin session ID intact.
- 6Register a source or reindexTwo header actions let you add a new source or force a reindex without leaving the page.
Captured from the real Qortex page, not a mockup.
The difference that matters
Scoped and provenanced.
Qortex ingests a whole governed platform, its distilled knowledge, its audit trail, and your connected world, all scoped and provenanced. It knows where every note came from and who is allowed to read it. Tying evidence-grade records to WARD receipts, so a changed record shows, is planned.
Scoped
Every note carries an org and a user boundary. Nobody reads across a scope they are not in.
Provenanced
Every note knows the source it came from and when it arrived.
Witnessed (planned)
Planned: notes ingested from governed evidence will carry their WARD receipt, so a changed record shows. Today Qortex records the source and arrival time of every note, not a hash chain.
The write side
Does AI agent memory need governance?
Every memory article about AI agents treats memory as a read problem: retrieval, RAG accuracy, hallucination reduction. It is also a write problem, and that half gets skipped. Memory is accumulated state. Every note Qortex stores changes what an agent believes going forward, and what an agent believes changes what it does next.
A write to memory is a decision with delayed effect: an agent that memorises a wrong fact today can act on it in a completely different context weeks later, with no action-level review to catch it, because the change happened at write time, not at the moment of the consequential action.
If actions get policy gates and an evidence trail, writes that shape future actions deserve the same treatment: who wrote it, what scope it is readable in, and a provenanced record of the change, with WARD receipts for evidence-grade writes on the roadmap.
Watch it fill in
It grows, and you can see it.
A live graph you can explore node by node, and a growth ladder from a handful of notes to a dense, connected mind, and a grounding rate (quox brain usage) that shows whether your agents are actually answering from it.
Forming
A handful of notes, not yet connected.
Growing
Clusters appear as related notes link up.
Alive
A note-count milestone: the brain has grown past the early stages. It measures size, not how often agents cite it.
Dense
A higher note-count milestone. It measures size, not whether the notes are consolidated or current.
Explore the graph node by node in the cockpit, or watch the ladder move as new sources are connected.
What is live today
Live now, and in progress.
Live now
- Chunk-native retrieval and search
- The self-feeding loop: agent memory, docs, git history, dev sessions, QuoxPlan, folders and QuoxMemory, on a 30-minute schedule
- Capture from wherever you work: quox brain add, "save this" in chat with Qortex, and URL or PDF clipping, searchable in seconds
- Hybrid retrieval: semantic (vector index) plus keyword search, one hit per note, and a "nothing relevant" answer when it does not know: on independent blind question sets Qortex declined 70% of questions whose answer is not in the brain and wrongly hedged on 5% of answerable ones (11 October 2026)
- Agents read the whole note, not just a snippet, and cite the exact passage
- A daily brief of what entered your brain (quox brain brief, or ask Qortex to catch you up)
- Contradictions supersede: when a newer source changes a fact, the old belief is replaced and kept in a visible history with the reason. A decision timeline lets you reinstate a wrong correction (quox memory timeline, history, reinstate, and a Decisions panel in Qortex)
- What leaves the instance: a settings panel shows where note text is sent (embedding provider, consolidation, agents), with per-org controls
- Inline citations and a grounding rate you can check (quox brain usage)
- Qortex, the recall agent: one question across memory, the knowledge brain and past sessions
- Ask Qortex: suggested questions drawn from your own notes, in the dashboard and quox brain suggest
- Agent search plus automatic knowledge context (switched on per instance)
- The governed cockpit
- The graph explorer
In progress
- Consolidation into beliefs (opt-in per org today)
- WARD receipts on ingested evidence
- External connectors (Notion, Google Drive, Gmail) via the credential and MCP layer
The three parts
Qortex, Memory and Mind: how they fit together.
Three separate products that read from the same governed platform. Here is what each one actually does, and where the lines are.
The self-feeding graph
Connects to your sources once, then keeps indexing and consolidating them on its own into a governed, cited knowledge graph.
The memory layer
Persistent, tiered storage for what an agent has learned: episodic, semantic and entity memory that survives a restart or a cleared browser.
The reasoning layer
Twelve named cognitive implants that perceive, recall, reason and act, with every decision logged as evidence you can replay.
How they fit: Qortex pulls in the sources you connect and consolidates them into a governed graph, QuoxMemory holds the distilled result agents read first, and QuoxMind reasons over both to decide what to do next.
Second brain, answered
What a second brain is, and what makes this one different.
What is a second brain?
A second brain is an external, searchable store of what you know, so you can find and reuse it later instead of holding it all in your head. The idea started as a personal knowledge habit. Qortex applies it to a whole platform: a shared second brain your AI agents read from and cite, not just one you read yourself.
What is Qortex?
Qortex is Quox’s second brain for AI agents: a self-feeding, governed knowledge graph you self-host. It ingests the sources you connect, consolidates them into weighted, cited beliefs, and serves them back to every agent scoped and provenanced, with inline citations and a published grounding rate.
How is Qortex different from a personal second brain like Notion or Obsidian?
Those are second brains a person reads and edits by hand. Many tools now offer AI search and agents too. Qortex fills itself from the Quox activity you already have rather than waiting for you to file a note, keeps provenance on every belief, and shows the citations behind each answer. It runs on your own QuoxCORE instance, so the knowledge stays yours.
Is my second brain private and self-hosted?
Yes. Qortex runs on your own QuoxCORE instance, source credentials are encrypted at rest on your instance, and every note is org-scoped so one team cannot read another’s. Nothing is sent to a third-party memory service. The outbound calls go to the providers you configure: your embedding provider (OpenAI or Gemini) for semantic search, and your LLM when consolidation or the Qortex agent reads notes to answer.
Can a whole team share one second brain?
Yes. Qortex is org-scoped, so a team shares one governed second brain: every agent and every person on the instance reasons from the same cited memory, with provenance on every belief.
For the longer argument on why a persistent second brain changes how agents work, read why second brains are useful.
Give your agents a memory worth citing.
Connect a source, let it index, and watch the graph grow. Every agent on the platform reads from the same governed memory.
How you get it
In the store today, a brain that feeds itself
One licence, installed on your own QuoxCORE instance.
On its own
A second brain that keeps itself current: it reads what you feed it, links what it already knows, and surfaces the connection when it matters rather than when you remember to search.
On top of QuoxMemory
Qortex builds on QuoxMemory, the durable memory layer every Quox install already ships with. Qortex keeps its own searchable index beside that store and writes consolidated beliefs back into it.