It isn't the graph you've already seen
For a few years now note graphs have been everywhere: second brains, personal wikis, maps of links. They're good things, and the Sphere Grid looks enough like them to be mistaken for one. It isn't, and the difference isn't cosmetic.
The objection, said before you think it
«I already have a second brain»
It's probably true, and it probably works well. We're not here to tell you you're using it wrong: what you've built is useful, and this page doesn't exist to talk you out of it.
It exists because from a distance the two things look alike enough to make people close the page thinking they've already understood. And whoever closes it there doesn't lose one more feature — they lose that these are tools for two different jobs, and that they can share the same day without treading on each other.
The misunderstanding, said straight away
A note graph draws the documents you've written and the links you put inside them. A Graphify does the same with a bigger, denser archive. The Sphere Grid draws something else: how a mind is made — what moves it, what it can do, what it must not forget, what it isn't allowed to rewrite. The first two are maps of the same kind of thing; the third is the map of a different kind, and it resembles them only because it too is made of dots and lines.
Note graph
Graphify
Sphere Grid
The order doesn't emerge: it's declared
In note graphs the shape arises by itself. You link two notes, then two more, and after a year you have a cloud. It's fascinating to look at — and almost nobody goes back to it a second time, because there's no front door: no point is more important than another, so you don't know where to start.
Here the hierarchy exists before the drawing. At the centre the file, around it the cores — the underlying drives — then the modules that hook onto those cores, then their sections, then the logs. The distance from the centre isn't chance: it's rank. You look at the map and you know where you are, even if you didn't write it.
That isn't engineers' fussiness: it's what makes the thing usable by anyone. An ordered structure can be handed to someone else, can be downloaded ready-made, can be corrected knowing where to put your hands. A cloud can't: that is readable only by whoever grew it.
Your entire archive, here, is one node
This is the part you usually don't see until somebody tells you. Take a well-kept personal wiki — years of notes, thousands of links, the graph filling your screen. In the Sphere Grid all of that sits inside one memory module, or inside the register of a single module.
Not because we compress it: because it is of another order. What you've gathered is material. A core isn't material — it's the reason you go looking. A module isn't a note — it's something your AI knows how to do. An archive, however vast, is one of the things that mind possesses, not the mind.
And that isn't a property of that particular graph. Below is a Graphify — another tool, another archive, another way of drawing the same things — and this time the landing point is a different associated memory, on the other side of the same Sphere Grid. The relationship doesn't change: only the two pictures do. If it changed, it would mean that the first time we had picked the node that made you believe it.
And if the archive is genuinely large — a person's whole knowledge base — it usually doesn't stay one block: it unpacks where it belongs. The trade notes end up in the memory of the module that practises that trade, the ones about you next to the cores that concern you, the rest wherever it's needed. They become five nodes instead of one, and it makes no difference: five associated memories are still material hanging off the structure. None of them becomes a core.
And the associated memory is not just the place where the material sits. A functional module — a thing your AI knows how to do — carries with it how it went using it: the corrections, the exceptions, what does not hold with your files. Your wiki, reduced to one node, becomes that module’s experience: the procedure and the history of the procedure in the same object, with different permissions. It is the point where an archive stops being consulted and starts being used.
That's why the Sphere Grid stays readable even when the file becomes enormous: it grows in depth where it's needed, not in width everywhere.
And the outside: the 3D Sphere Grid
So far we have looked at the inside of a node: an entire archive hanging off the structure as an associated memory. The Android App also does the opposite — it shows the outside, all at once. It is called the 3D Sphere Grid, and it is the whole profile in three dimensions, like a body in shells. The profile at the centre, then the files, then the blocks by depth. You rotate with a finger, pinch to come closer, touch a node to know which file it is and open it.
Going to three dimensions does not erase the difference from a note graph: it makes it more visible. Here the direction in which a thing sits is not where the drawing left it — it comes from the meaning of the text, read from the same index that search by meaning uses. Things that talk about the same matter end up in the same wedge, and the lobes form by themselves: nobody draws them, and nobody declared them.
Closeness says similarity, not a link. This is where it would be easy to cheat: two nearby blocks look alike, and drawing a line between them would make a denser, better-looking map. The lines are only the real ones — the ones the file declares, parent and child, root and file. A similarity is not a relationship, and drawing it as if it were would be the same shortcut that makes a note graph denser than it knows.
And the price is stated: it needs a model for search by meaning, and the profile indexed. Without vectors the sphere would be mute, that is, an ornament — so if either is missing the screen says so and takes you where it is fixed, instead of opening empty. For now it belongs to the Android App.
And there are two views, which reason the opposite way
The other view is called “Understanding”, and it is a cloud built the other way round: in the 3D Sphere Grid position says everything — the radius is the shell, the direction is the meaning — and the lines are the skeleton the files declare. In the cloud position says nothing, the dots sit where they settled, and every line says one precise thing.
They are links that were extracted, not guessed: where you filed a log, where the app had suggested you file it, which block names which thing. The first level asks for nothing and is there from the first log you file; the second one is opened by a model that runs on the device — phone or browser — and pulls out names of people, places, dates and things — to download in four sizes (201, 331, 379 or 647 MB), which you choose: the 379 MB one knows five languages, the other three declare twenty-two, and on the ones left out it finds less. Since 7 September there is a fifth entry, 325 MB, and since 13 September a sixth, 411 MB: neither is a size — besides the things they find the relations between the things, the very lines of the cloud, which light up in the “Relations” map.
The third level is questions, not facts. If two names never appear together but both are named next to the same thing, the app can draw a dashed line between them. It is a question it asks you: you switch it on, and it is not saved anywhere. Without that rule it would look as if the app were deducing facts about the life of the person using it — and the whole difference between deducing and asking is right there.
And «second brain» is too big a name
An archive of notes, however well linked, is not a brain. A brain has drives — it wants something. It has rules it doesn't rewrite for itself. It knows who it is when it wakes up. It decides what is worth remembering and what to let go. An archive does none of that: it preserves and associates, and that is already a great deal.
If you want to stay inside the metaphor, a personal wiki resembles at most a region of neocortex: the part where associations hold together. That's a lot — much of what you know lives there. But it's a region, not the organ. Everything else is missing: what wants, what fears, what decides, what says «I».
Let's call it what it is: a simplified index of a database, drawn. That isn't a put-down — it's a description, and it's exactly why it works so well. An index exists to find things again, and a drawn index finds them even when you'd forgotten you put them there. Asking it to be a brain is asking it to do another job.
And this isn't pedantry about vocabulary. Whoever hears «second brain» expects the archive to do things an archive cannot do: choose for them, remind them who they are, tell them no. Then it doesn't happen, and it looks like their fault for «not using it properly». A more honest name would have promised less and delivered everything.
The other parts — the ones that push, the ones that forbid — are present in the Sphere Grid, and not because we were clever: without them an identity doesn't stand up. The cores are precisely «what moves». The permission zones are «what doesn't get rewritten». That's the difference between remembering and being someone.
And so the name, turned the other way round, has to be said: it is the whole Sphere Grid that can be called a second brain. Not a piece of it, not the part that resembles the wiki — that's the index. The whole of it: the cores that push, the modules that know how, the memory that keeps or lets go, the zones that say what isn't rewritten. Those are the four things the name was invented for, and they are all in the same place.
And that's why the difference isn't measured in features. An archive of notes is consulted: it sits still until you ask it something. A Continuity Layer is read before the question, and it decides how the question is understood. It isn't a place where you search: it's what you search with.
With one boundary, worth putting first. «Brain» here is in the functional sense the word has always carried when people speak of second brains — what moves, remembers, chooses and refuses — not in the biological sense, and not in the sense of consciousness. We aren't simulating neurons and we don't claim to be. The point is that this functional sense, which an archive of notes doesn't reach, is covered here in full.
Every piece declares who may rewrite it
In an archive of notes there is nothing saying «this part is not to be touched». There's no need: you write the notes and you rewrite them. Here, on the other side, there's somebody who reads, understands and might rewrite — and so every block declares how much of it is yours, from the rules only you can change down to the scratch notes the AI overwrites without asking.
It's the difference between an archive and a constitution. An archive preserves; a constitution also says what may not be changed, and by whom.
In two columns
| Note graph | Sphere Grid | |
|---|---|---|
| What a node is | a note you wrote | a nucleus, an ability, a rule, a memory |
| Where a link comes from | from the links you put in | from the structure: a module declares which nucleus it belongs to |
| The order | emerges over time, and there is no entrance | declared before the drawing: the distance from the centre is the rank |
| The scale | the graph is everything you have | a whole archive fits inside as one node, or as a few |
| Permissions | there are none: you write and rewrite | every block declares who may rewrite it |
| What it answers | «what have I written» | «who is it, and how does it work» |
What they do better, and by a lot
Bringing things back up. Links you hadn't foreseen, forgotten notes resurfacing because somebody had tied them to something else. That serendipity comes precisely from the absent order we've cleared away here: it's a virtue bought at the very price we don't pay.
Letting you start immediately. There's no format to learn, no permission zones to understand: you open it and you write. IllAIra asks for more attention at the start, and we don't pretend otherwise — it's written on the page that explains what it costs, too.
Searching. A well-indexed archive finds one sentence among ten thousand in a second. The Sphere Grid isn't built for that, and on that ground it loses.
If what you need is keeping what you read and think in order, a personal wiki is the right tool and IllAIra doesn't replace it. It's for something else: giving an artificial intelligence an identity that holds between one conversation and the next. And if you like, that wiki can become one of its memory modules — it isn't either/or.
In one line
A note graph answers «what have I written». The Sphere Grid answers «who is it, and how does it work». The second question contains the first, not the other way round.