Context Isn't Information. It's the Relationships Between It.

You did the thing everyone tells you to do. You gave the model context — all of it. Every document, the whole folder, the entire knowledge base. And it still hands you generic answers that miss how you actually operate. So you figure it needs more context, and you paste more. It doesn't help.

Here's why: a pile of information was never context in the first place.

Picture handing a new hire the entire company wiki on their first morning and saying "you're caught up." They've technically seen everything now — every doc, every policy, every past decision. Do they understand your company? Obviously not. The understanding was never sitting in the pages. It's in how the pages relate: which policy actually governs which situation, which decision overrode which other one, what everyone means but nobody writes down. The new hire has all the information and none of the context. So does your AI.

This is the foundation the whole idea of "context engineering" rests on, and almost everyone gets it backwards. So let's define the word properly.

Context is the relationships, not the pieces

Context is not the information. Context is the relationships between pieces of information.

The documents, the files, the facts — those are the pieces. Context is how they connect. This document supersedes that one. This policy governs that process. This decision was made because of that constraint. This is what "done" means when you say it. None of those are facts sitting in a file. They're relationships between pieces of information — across files and within them — and they're the part that turns a pile of data into an understanding of a situation.

If you want the precise version: the information is the nodes, and context is the edges between them. A heap of nodes with no edges is just data. The edges are where the meaning lives — and the edges are exactly what almost nobody hands their AI, because they aren't written down in any single document to hand over.

Here's a concrete one. You can paste a hundred documents into a model and it still won't know that when your biggest client asks for a discount, you loop in finance before you answer. That's not a fact in any file. It's an edge — client type connects to a decision connects to who gets involved — and it's the kind of thing that actually determines how the work goes. The pile has none of it.

What "AI that knows you" actually requires

This is why "AI that knows you" is a much bigger promise than it sounds.

To genuinely know you, a model needs more than your documents. It needs the relationships that describe you: who you are, how you think, what you do, what information you have, and what decisions you make — and, above all, how those connect. Why you price the way you do. What you always check first. What "good" looks like in your hands. Which of your own documents you'd trust and which you'd quietly ignore.

Your files are the easy part — the nodes. The relationships are the hard part — the edges — and they're the part that makes the thing actually you, instead of a generic assistant with your logo on it. A model loaded with all your files but none of your relationships is the new hire all over again: read everything, understands nothing, can't yet do the job.

The catch: your context lives in your head

Here's the problem, and it's the whole reason this is hard.

Every one of those relationships lives in exactly one place: your head. The AI can read your documents — it can see the nodes. But the edges are invisible to it. Why this decision, how that connects, what you actually mean, which version wins when two disagree — none of it is written anywhere, because to you it's obvious, and obvious things don't get written down. You don't document that you loop in finance before discounting for your biggest client. You just do it. Or take something more routine: someone asks you for last month's customer report. You know, without being told, that the pieces live in three different systems because no single place holds all of it — so you pull from each and stitch them together. And you know that to make the report actually true, you have to go ask the account manager whether the latest project is still on track, because the current status isn't written down anywhere yet. Which sources to pull, how they fit together, whose word to check for what's live — that's orchestration and lineage, and you carry all of it in your head. It's some of the most valuable context you have, and it's the least likely to exist in any file.

That's the trap. The context that would make an AI genuinely useful to you is precisely the context you'd never think to give it — because you don't experience it as information. You experience it as "how things are."

The only way in: context mapping

So how do you give an AI something that isn't written down and lives only in your head?

You map it. You surface the relationships and make them explicit — you turn the edges in your head into something a machine can actually use. That's context mapping, and it's what "context engineering" really means underneath the jargon. Not pasting more information. Drawing the map.

Everything worth doing in this space is a version of this. Putting version metadata on your documents so the model knows which one supersedes which — that's mapping the relationships between your files. Writing down the decision rules you follow without thinking — that's mapping how you work. Capturing why a decision got made and what it replaced — that's mapping your reasoning across time. Different slices, one discipline: getting the map out of your head and into a form the model can read.

And this is the part the frontier labs will not do for you. They'll keep making the model itself smarter — better at reasoning over whatever nodes it's handed. But "smarter in general" and "knows your world" are different things, and no amount of the first produces the second, because your edges are private. They're not in any training set and never will be. No model release will ever surface the map that lives in your head. Someone has to draw it — and that work gets more valuable as the models improve, not less, because a smart model with your actual context is worth far more than a smart model guessing at it.

The whole thing in one breath

Information is the pile. Context is the map. Knowing you means having your map — who you are, how you think, what you decide, and how all of it connects. And the only way to get that map is to draw it, because it lives in your head and the machine can't read minds.

You can start drawing it yourself. Labeling your documents so your AI stops confusing versions is a real first edge, and the Context Auditor maps the relationships across a set of your documents for you. And when you want the whole map — your actual context, made legible to every AI you touch — that's the work Solaris exists to do.