Cortex: an operating system for organizational intelligence.
The missing layer between organizations and AI: a single, access-partitioned brain that AI agents run on, installed on a company's own infrastructure, with the model and the agent kept swappable.
Cortex loads a company’s documents, decisions, and code into a single, access-partitioned brain that AI agents run on. In a head-to-head benchmark, Cortex answered the same questions with the same accuracy as pasting the entire corpus into the model, on roughly a tenth of the tokens and a tenth of the cost. Unlike full-context approaches, its cost stays flat as the corpus grows.
Scattered knowledge is an old problem. AI agents made it sharper.
Every company’s knowledge is spread across documents, chat, code, and people’s heads. Agents don’t consolidate it: they expose the gaps. Each session starts from scratch with no durable memory, the model underneath changes every six to twelve months and the workflows get rebuilt around it, and once an agent or a second brain has ingested everything, there’s no way to keep sensitive content out of its reach.
- Knowledge scattered across documents, chat, code, and individual people
- Agents forget everything between sessions
- Workflows welded to a single AI vendor
- The same questions answered and the same analyses rerun, because prior work is hard to find
- No way to keep forbidden content out of an agent’s context once it’s indexed
- One brain that outlives people, tools, and models
- Durable memory and decisions that don’t drift
- The freedom to swap models without rebuilding the workflows
- Role-appropriate answers, with the reasoning and lineage to act on them
- Sensitive content that never reaches anyone who isn’t cleared for it
The durable layer isn’t the agent or the model. It’s the organization.
The agent is just a runtime. The model is swappable. What has to persist is the organization’s knowledge and the decisions made on top of it. Existing tools each solve a slice: graph-RAG frameworks, agent-memory systems, second brains, LLM-maintained wikis, but they tend to assume one developer and one model. They break when knowledge grows, when new people join, or when the model changes, and none of them solve the three things that matter at organizational scale: partitioning access, keeping decisions from drifting, and keeping forbidden content off the device in the first place.
Not the agent. The OS the agent runs on.
Cortex installs per company, on the company’s own infrastructure. It ingests documents, and over time code, decisions, and meeting notes, builds an access-partitioned knowledge graph and a compounding wiki over them, and lets every employee work against that brain through an agent that runs reusable skills. Findings flow back in, so the system gets smarter with use. The model and the harness are swappable; the substrate is not.
Preserve organizational knowledge
Knowledge stays with the organization instead of walking out the door with people or breaking when the model changes. Documents, decisions, and code are ingested into an access-partitioned knowledge graph and a compounding, human-readable wiki, with canonical entity resolution making each real-world thing one node everywhere, so knowledge gathers in one place instead of fragmenting across tools and heads.
Govern AI access
Every employee and every agent gets role-appropriate knowledge, and nothing else. Access is computed per person from roles and explicit sharing, audited on every write, and revocable, so sensitive content stays with the people cleared for it, even as agents work across the whole corpus.
Learn from every interaction
The system gets smarter with use instead of starting from scratch each session. Findings are fed back: deterministic, hook-driven memory captures what happens rather than leaving the model to remember, a decision ledger lets prior decisions be reused instead of re-derived, and a personal finding can be promoted into governed org knowledge.
Connect information across teams
Whether you search by exact name or by meaning, everything related surfaces together. A fused lexical-and-semantic index keeps exact names, codes, and strings first-class alongside meaning-based retrieval; the knowledge graph traces typed relationships across people, projects, and documents; and global search answers whole-corpus questions, all within each person’s clearance.
Stay independent of AI vendors
Swap the model or the harness without rebuilding your workflows. Cortex is the OS the agent runs on, not the agent itself, so the model and harness sit behind swappable seams: your workflows, memory, and decisions outlast any one vendor’s pricing or capabilities.
Three choices set Cortex apart.
Enforce at delivery, not at query
Content you aren’t cleared for never reaches your device or your agent’s context. It’s absent, not filtered, so a local copy or an agent can’t leak what it never received.
Decisions converge instead of drifting
Every decision is a hash-chained, model-tagged record. The same question converges on the same authoritative answer over time, rather than being re-derived and drifting.
One self-hosted install, no vendor holding the keys
Graph, governed memory, decision provenance, a compounding wiki, and portable skills, delivered as a single per-company install, run by one operator.
Deterministic at the decision, identity, and memory layers, on top of a nondeterministic generation layer. Not reproducible model output: convergence, where trust and reuse matter.
Same answers. One-tenth the cost. No context-window ceiling.
We ran the same questions, answered by the same model (Claude Opus 4.8), three ways: paste the whole 32-document corpus into the model on every query; a tool-using agent that crawls the files; and Cortex. The corpus was roughly 203,000 tokens of source. All three returned correct answers across every question type. The difference is what each one costs to get there, and what happens as the corpus grows.
| Metric | Paste everything | Tool-using agent | Cortex |
|---|---|---|---|
| Input tokens / query | 203,160 | 22,820 | 18,868 |
| Cost / query | $1.022 | $0.139 | $0.107 |
| Round-trips | 1.0 | 4.4 | 1.4 |
| Time / query | 7 s | 17 s | 10 s |
| Accuracy (8 question types) | 8/8 | 8/8 | 8/8 |
| Scales with corpus? | Linear; hits context wall at ~158 docs | Spiky, grows | Flat (~19K) |
The most important result isn’t cost. It’s scalability. Full-context prompting scales linearly until it eventually exceeds the model’s context window. Cortex’s retrieval cost stays nearly constant as the knowledge base grows, so organizations can expand their knowledge without continually increasing inference cost or rebuilding workflows.
Where the benchmark is honest about its limits.
Pasting everything is the fastest way to answer a single question at this size (about 7 seconds versus 10). Cortex’s advantage is cost, token efficiency, and scaling, not raw single-query latency.
And this is a directional benchmark: eight questions, one per type, not yet a large statistical sample. The per-type pattern holds and full-context’s per-query cost is near-constant, so the comparison is stable.
Currently in private beta.
The graph engine, canonical entity resolution, incremental indexing, delivery-boundary access enforcement, and residency controls are built and running. The durable memory layer, the compounding wiki, and whole-corpus global sensemaking are rolling out. Cortex is in private beta with a small number of teams.
Interested in Cortex for your organization? Book a 15-minute intro call below, or email brent@graphline-systems.com.
Carrying production without a platform team?
Start with a 15-minute intro call, or send an email. We’ll talk through where your systems are today and what it would take to make them reliable.
Pick a time that works and it’s booked: a quick call to see whether we’re the right fit for what you’re building.
Pick a timePrefer email? Send a note about your team and systems and we’ll get back to you, usually the same day.
brent@graphline-systems.com Send an email