Read everything. Find the structure. Cite the source.
Reading unstructured human thought and finding its hidden structure is not possible without modern language models. That makes the model the whole product, and it makes how we use it the whole question. Here is the honest version.
1. Read every fragment
Your dump is split into numbered fragments, one thought each. The whole set goes to the model in one call with the numbers attached. The model is told, in plain language, that it is reading someone's own thoughts, that it may not add any, and that every node it returns must carry the indices of the fragments it came from.
2. Find the hidden structure
The model returns a strict JSON shape: two to six clusters with short names and a one-line summary, nodes inside each cluster, loose thoughts that belong nowhere, connections, tensions, and open questions. We validate that shape with a schema before anything else happens. Malformed output is retried once, then handed to our local engine so you never see a broken map.
3. Connect with reasons
Each connection is a pair of node ids and a short reason. We insist on the reason because a line without one is decoration. Tensions are connections where the two thoughts pull against each other, and the model has to say how. Open questions are collected into one node and framed as decisions you could make, never as a grade.
4. Enforce the citations
After the model, a validator walks the map. Sources outside the fragment range are dropped. Nodes with no remaining sources are dropped. Connections or tensions pointing to dropped nodes are dropped. Any fragment nobody cited is parked as a loose thought so nothing you wrote is lost. Only then does the map reach your screen.
5. Collapse to action
Collapsing a cluster is a second, smaller call: the cluster's fragments plus the open questions that touch them, returned as an outline or a next-steps list with the same citation rule. When no model is available, a deterministic collapse builds the outline straight from the cluster's structure.
Model-agnostic, stated plainly
Nodemeadow does not depend on one provider. A thin layer speaks HTTP to whichever model is configured, with failover to a second. Studio accounts get priority routing. We evaluate new models on three hundred real dumps with hand-checked clusters, and swap when one cites and clusters better. You never pick a model, and your maps never change shape because a vendor changed its mind.
The local engine
Every deployment also carries a small deterministic mapper: term weighting, agglomerative clustering, and shared-word reasons. It is what the homepage demo uses on deployments without a model key, and what catches a failed model call. It is honest about what it can see. When it is in use, the map says so.
What the model never sees
Your account. Your other maps. Anyone else's dump. Provider calls carry the fragments of one map and nothing else, and no provider we use trains on API traffic. Your thoughts are never used to train any model, ours or anyone's.