A memory, not a pile of chunks.

Why "just retrieve the right chunk" runs out of road

Almost every AI platform answers "how do your agents know things?" with RAG. Chop documents into chunks, embed them, run a similarity search, hope the right chunk floats to the top.

Standard RAGIt works — until it doesn't. Chunks have no relationships. Every query starts from zero. The system finds text that sounds like your question, not knowledge that answers it.

Note graphsAnd it's not the graph view you've seen hyped, either — that constellation of dots drawn over a folder of notes. The whole picture rests on a single, untyped relation: this links to that. One kind of edge, typed in by hand, recording that two notes are connected but never how. Pretty to look at; hollow to reason over.

orqoLong-Term Memory here is a different machine — every edge typed, every type carrying meaning an agent can follow.

This is the "remember" layer of context management

Four classes, by epistemological function

When content enters an orqo project — a document upload, a workflow result, a web capture, even a substantive conclusion one agent shares with another — a three-pass pipeline classifies it by what kind of knowledge it actually is.

Four classes branch into 54 precise knowledge types, a formal ontology drawn from decades of educational-science research and validated in an EU-funded project. One finding stood out: from the typed relations alone, multiple meaningful paths through a domain emerged on their own — no manual authoring required. Structure was enough for navigation to appear by itself.

For thirty years, this theory had one fatal bottleneck: classification needed educated human experts. A single project took a team of ten, for months. Modern LLMs dissolved that — orqo's pipeline classifies content with over 94% agreement with human expert categorization, in hours, automatically.

Traversal, not blind search

Because every unit is typed and every edge means something, agents don't fire off blind searches — they traverse.

From any knowledge unit, eleven directions: deeper. broader. why. how. consequences. examples. context. related. sources. next. previous. Each direction follows specific relation types — "why" walks causal edges, "deeper" walks hierarchy.

The economics follow directly: a RAG system typically burns 10+ retrieve-and-read cycles piecing an answer together from scattered chunks. An orqo agent typically needs 2–3 targeted traversals — the structure tells it where to go next. Fewer LLM calls, fewer tokens, faster answers. Your memory isn't just smarter; it's cheaper to query.

Your AI bill, engineered down

The value is in the edges, not the similarity.

The chain a similarity search can never follow

In Yellowstone, reintroduced wolves changed the course of rivers: wolves thinned the elk, the elk stopped over-browsing willow and aspen, vegetation and beavers returned, roots and dams stabilized the banks — the rivers meandered less. Two facts, tightly connected, sharing almost no words.

Ask a similarity search "why did the riverbanks stabilize?" and it returns more text about rivers. The wolves never come up — there is no lexical bridge to follow. A linked wiki only knows the connection if someone already wrote it into a document. But in orqo's graph the chain exists as typed, directed edges — and an agent standing at the river walks the why edges backward and arrives at the wolves in four deterministic hops, whether or not any single document ever stated the connection.

Nobody curates this graph — it grows passively

Every run, every upload, every meaningful agent conversation leaves the organization a little smarter, without anyone thinking about it.

All of it asynchronous, never slowing a workflow down. And when an employee moves on, what they learned stays navigable.

That passive capture is a switch, not a mandate — you can decide to turn it off. Doing so costs you none of the deliberate path: an agent granted the write capability can contribute knowledge on purpose, handing content to the graph as a first-class action. It never writes raw nodes — it submits content, and the same three-pass classifier gives it Meder types and typed edges, exactly like a human upload. Incidental capture is optional; intentional contribution is always there.

And intake isn't limited to what your agents produce. Connect an adapter and outside sources pour through the same pipeline — point one at your inbox and every email becomes classified, navigable knowledge, typed and linked like everything else; the same goes for a shared drive or a code repository.

Switch it on, and your agents navigate it mid-run

This is the point of the whole machine. Give any agent in any workflow one capability — read knowledge — and while it works it can reach into the organization's memory. Not a blind similarity grab dumped into its prompt, but a guided, multi-step walk to the exact knowledge the task needs.

That loop is the revolution hiding in plain sight. Standard RAG hands a model a pile of chunks and hopes it can assemble an answer. orqo hands it a map with signposts and lets it walk — the structure does the wayfinding, so the agent reasons its way to knowledge that answers instead of text that merely resembles the question.

One engine, three ways out

Your workflow agents query this graph as they run — that's its main job. The same engine reaches outward, too: it renders this graph to your screen, and answers your customers straight from it. And it drives a second graph entirely — the Chief of Staff's personal memory, on its own social ontology, walled off from the org's — because what's shared across orqo is the engine, not a single structure.