A map of what you think, drawn from what you said. And it keeps drawing.

Whatever you put in is an entry, and there is one kind of it: a half-sentence, a voice note from the car, a pasted document, a finished argument. It is one kind because how considered something was is not observable at the moment you write it, and asking you to declare it would be a person ticking a box about their own writing.

It is never tidied — not summarised, not reflowed. Every step after it loses something, and the words you said stay the only record of what you said, so “is that actually what I meant” always has somewhere to be answered. You can correct a misheard word by hand; the machine never will.

Speaking is there because that is the form most of these arrive in. Dictation puts the words in the box for you to read before you keep them, and it sends your voice to the browser’s speech service — which is said here rather than discovered. Several files at once become several entries, never one stapled together, because an entry is one thing somebody wrote.

While something waits to be read, the button you put it in with wears a ring and a count, and says when it has come out the other side — so the gap between saying a thing and seeing it on the map is visible rather than a guess.

This is the one thing a machine does here. It reads an entry, finds the distinct ideas in it, and writes each as a seed under 200 words, up to 14 from one entry — small enough that “is that what I said” is answered at a glance. A seed is immutable and is never read back in, so the machine never measures its own paraphrases as though they were you. An entry with no title is named afterwards from the ideas that came out of it.

Today a seed points at the whole entry, not the sentence. Pointing at the exact words is built and being tested, not switched on, and it is built one way on purpose: a model is never asked where the words were, because it cannot count characters and an offset it reported would be a confident number with nothing behind it. It is asked for a quote, and the code looks for that quote in your own words — so a quote that is not there is a fabrication the code catches, rather than a pointer nobody checks.

The two concept tiers are general and items. The broad one is ranked: first is what the passage is obviously filed under, second is the one reaching somewhere else, and it is named at the broadest level that is still accurate, because the top of that list is where this idea meets every other. There is no vocabulary to pick from — the words come out of your writing. The one exception is a short list of words found to carry two senses (memory meaning recall and meaning storage), which are dropped, because a connection made by a shared word and no shared subject is worse than none.

Nobody drew these regions. Concepts named on the same idea pull together strongly and concepts from the same entry pull weakly; a clustering pass groups them, anything too small to be a place merges into its nearest neighbour, and each region is named after its top two concepts. So a region can rename itself as what you write about moves — which is the point: it is a picture of the corpus now, not of the day it was set up.

Colour and position are different jobs. Every idea has a position; only the biggest regions get a colour, and how many is a dial on the map. A colour is a claim that this is a major region; everything past the dial shares one neutral bucket, called other rather than unfiled, because it is filed — just not somewhere big enough to be a place. The colours come from a theme, which is a scale between two colours cut into as many as there are coloured regions: a wide one runs the whole wheel and tells regions apart, a narrow one is shades of one colour and says they are all one kind of thing.

A concept is not placed by the physics, so it never pushes anything out of the way. It spans time: a dot where it was first named, a dotted string bending past the ideas it passes, and the asterisk where it was named most recently — so a concept you keep coming back to is a long thread, and one you named once is a point. It takes the colour of the region it belongs to. A concept named by only one thing is not drawn; how many it needs is a dial, and so is the way the string is drawn.

The claim underneath all of it: an idea that arrives from nowhere is rare, and most of what feels new is two things you already held, put together for the first time. A pile of notes hides that, because nothing in it is next to anything. A map built from what each note is about puts them in reach.

Every pair of things pulls once for each thing they share: the entry they came out of, a link somebody wrote between them, each source they both use, each concept they both name. Only the strongest few lines are drawn, and how many is a dial — every pair still pulls, so the layout says more than the lines do. Links are never declared: an edge you drew exists because a sentence needed it, written inline as [[a title]].

A bar under the map is a guided search: hover a region to light it, press it to keep only it and what it touches, then step into its concepts and its neighbouring regions. And the list is the same corpus — every idea opens with what it came from, what came out of it and what it names, one click each way. Names appear as you get close to things rather than all at once, so the shape stays readable from a distance. What the map cannot do is tell you a combination is any good. It raises the question; you answer it.

This is the use that has actually happened, so it is the one worth describing plainly. Filter the map to one region, turn time on, and open an old entry beside a recent seed: the old idea fills a hole in the new one, and the new one builds on the old. Your thinking compounds, and the map is where you watch it do so rather than taking it on trust.

An entry’s date is the day it was said, and it can be corrected, because a bulk import stamps everything with the import day. A seed takes its entry’s date rather than its own — every seed may have been written by the machine on one afternoon, which says nothing about when the idea was had. Correcting the date moves its seeds with it.

It is a real camera, not a picture that gets bigger. Scrolling moves you into the map toward whatever is under the pointer, and keeps going: you pass the near ideas, they drop behind you, and the far ones come up. Dragging turns the map around whatever you grabbed, and a turn carries on a little after you let go.

Each view also has a when filter, so you can ask the list and the map the same question — only this spring, only before the move — without the 3D view at all.

It can only see what you can see. The page writes out the corpus you are in — the whole of it, or only what is on screen, your choice — and sends that; nothing on the server assembles a second copy with its own idea of what you may read. In a shared corpus that means everyone’s shared work and nobody’s private work, because that is what the page holds.

It reads and never writes. Nothing it says becomes an entry or a seed, and the conversation is not kept: start again, or reload, and it is gone. If something it says is worth keeping, you put it in the box yourself, in your own words — the one way in stays the one way in.

The same write-out can be copied or downloaded for a chat somewhere else: one file that explains how to read it, numbers every thing, and lists each thing’s own relations, so an outside model can cite by number and quote rather than paraphrase.

No machine may write one. Reducing a dump to an idea can be machine work, because a seed is a pointer at something you said. An argument is not a pointer at anything, and one a machine wrote would not be yours to stand behind. That is not a setting: every readable kind is declared as the author’s, and the code that writes into the corpus cannot name one without failing to compile. There is no Accept button, which is the stronger version of one rather than its absence: there is nothing machine-written waiting to be signed.

Length is a guide, not a gate. You can put anything in, at any length, and publish it or not; the only length that refuses anything is 100,000 words, and that bounds what the machine is asked to read rather than what you may write. The band on the meter — 400–900, around 650 — is what an argument meant to be read cold tends to need, and past 1500 it is usually two arguments wearing one title. It is counted, not judged, and it tells you; it does not stop you.

There is one removal, and it is archive: it takes the thing off the map and stops its page answering, and the file stays — so it corrects the record rather than rewriting it. The seeds that came only out of it go with it; two entries can feed one seed, so one that another entry still supports stays. Unarchiving brings it back private, because coming back is not the same decision as publishing. Deleting for good is possible only from the archive, so nothing is ever deleted in one step from where you were reading it.

Nothing is copied into a corpus. What you share is a pointer to your own entry or seed, read live, so an edit shows up there and archiving takes it out everywhere at once. Entries and seeds are shared separately, so you can put in the ideas without the dump they came from. A link only resolves against what the same person shared; anything else is defused to its words, because the thing it points at may be private.

Concepts are never added. A concept is on a corpus exactly when something in it names one, so the stars and regions of a shared corpus are drawn from the shared work alone — which is where it gets interesting: two people who never filed anything together meet at a concept both of them named.

Access is one setting with three answers: members only, anyone can read, or anyone can add (and adding joins you). The last two are open to the whole internet to look at — on the public map, signed in or not — and listed in a corpus library; adding always needs an account. Sharing something offers the things that came with it (an entry’s ideas, its sources), so a corpus does not end up holding an idea without where it came from. Admins rename, invite, promote and take things out; a filter narrows the map to one member at a time. You invite friends, and a friend is two people who follow each other — following alone grants nothing.

It is the same map you use, not a copy. The public page is this page with everything that writes taken away: Public and every corpus open to view, regions, concepts and time, with nothing to add, edit or share. It opens in 3D, because time is what it is there to show.

The folder decides who sees it. Personal is yours alone. A folder open to everyone is on the public map, and Public is the one everybody can add to. Nothing is public by default: a thing reaches the internet only by being put in an open folder, and a members-only folder is withheld completely, its name included, because a name on a public map is itself the disclosure.

A seed can be on the public map as a point with its one-line gloss, and never as the sentences behind it: it is a machine’s reduction of somebody’s words, and those stay where they were written. Nothing a machine makes is published by the machine; putting a seed on the map is always a person’s act.

What is still missing is conversation. Two writers meet at a concept, not yet at an argument — there is no way to answer somebody else’s piece in a way the map records. The roadmap carries that one.