← Library

What Is a Mind?

Most "AI memory" is a pile of text you search. In a thinqOS Mind the unit of memory is a belief held by someone: a claim with an owner, a source, a confidence, and an audience. One fact, many minds, no duplication. A technical deep-dive into what that means under the covers, and where the honest edges are.

Most products that advertise "AI memory" are selling the same thing under different names: a pile of text you can search. Your notes, your chats, your documents get chopped into fragments, converted into vectors, and stored in a database. When the assistant needs to "remember," it finds the fragments that look most similar to your question and pastes them back into the prompt. It works, and it's genuinely useful. But it is not memory in any meaningful sense. It's retrieval.

thinqOS is built on something different, and the difference is worth understanding precisely, because it's the foundation everything else in the platform stands on. We call it a Mind. The unit of memory in a Mind is not a document or a fragment of text. It's a belief held by someone: a specific claim, held with a specific degree of confidence, that matters a specific amount, and that can change over time without anything being rewritten or deleted.

This paper explains how that actually works under the covers, and where the honest edges are.

The strawman everyone ships

Start with the thing a Mind is not, because it's the thing almost everyone builds: a markdown vault (Obsidian, a wiki, a folder of notes) wired to embeddings and retrieval-augmented generation (RAG).

The pipeline is well understood. Text gets split into chunks. Each chunk is embedded into a vector. At query time, your question is embedded too, the nearest chunks are retrieved by cosine similarity, and they're stuffed into the model's context window. It's a fine architecture for "find the relevant passage." Infinite notes, instant recall.

But notice what it structurally cannot represent:

• Who believes a thing. A chunk of text has no owner's stance. "Dan prefers Python" is just a string; there's no notion that this agent is fairly sure of it while that agent has never heard it.
• How strongly, and how much it matters. Confidence and importance aren't modeled. A passing remark and a load-bearing fact are the same kind of object.
• That a belief stopped being true. To "update" a belief you edit the note. To "forget," you delete it. There's no lifecycle: beliefs don't weaken, get superseded, or decay.
• Disagreement. Two agents who hold opposite views produce two contradictory notes, with nothing tying them to the same underlying question.

These aren't bugs in a particular implementation. They're the ceiling of the model. A vault of text can store what was said; it can't store what is believed, by whom, and how that belief is changing. That's the gap a Mind is designed to close.

The core idea: World versus Mind

A Mind separates a fact from a stance on that fact. Two layers, two different jobs.

The World layer stores claims, once. The central object is a proposition: a single claim, either a structured triple like (Dan, prefers, Python), or a canonical claim key such as python-created-1991 for assertions that don't decompose neatly into subject/predicate/object. There is exactly one record per claim, shared across every Mind in the system. Entities (people, agents, organizations, concepts) live alongside them and carry vector embeddings, so claims about them can be found semantically.

The Mind layer stores stances. Each evaluation is one mind's position on one proposition. This is where the richness lives. An evaluation carries:

• a confidence (how sure this mind is the claim is true),
• a salience (how much this claim currently matters to this mind),
• a valence and arousal, the emotional coloring of the belief, on axes of positive/negative and calm/intense,
• a decay rate, a lifecycle status (active, stale, contradicted, superseded, archived), and a protection level.

There is exactly one evaluation per mind per proposition. The payoff of this split is the sentence to keep in mind for the rest of this paper: one fact, many minds, no duplication. The claim that "Dan prefers Python" is stored once in the World. Dan's own Mind, his financial-planner agent's Mind, and his research agent's Mind can each hold a different, independently-evolving stance on it: without three copies of the text and without any of them stepping on the others.

A belief is alive

In a vault, a note is inert until you edit it. In a Mind, an evaluation is a living thing whose state changes as a consequence of how it's used.

Recall strengthens it. Every time a belief is retrieved and actually used, its salience is reinforced, a small bump on each retrieval. Memories you lean on stay near the surface; memories you never touch sink. This is reinforcement-on-use, and it's automatic.

Forgetting is modeled, not manual. Salience decays over time on an exponential curve. But here is the part that makes it feel less like a database and more like a memory: the decay rate is modulated by affect. Strongly-valenced, high-arousal beliefs decay more slowly. A fact you learned in a frustrating, high-stakes moment persists; an emotionally flat detail fades. This deliberately mirrors the role emotion plays in human memory consolidation. In the production system, affect is the signal that actually carries differentiation: across active evaluations, affect shows real spread, while confidence and salience still tend to cluster in a narrow band. We mention that because it's the honest state of things: affect is doing real work; some of the other dimensions are still settling.

Stated truth outranks guesses. Beliefs carry a source, declared, observed, or inferred, and a precedence rule enforces an order: a thing the user directly stated overwrites a thing the system merely inferred, rather than being averaged with it. Beliefs can also be protected (user-confirmed or locked), and a protected belief resists being quietly clobbered by a noisy re-extraction. When two stances do blend, the existing belief is weighted far more heavily than a single new extraction, so one offhand turn can't overwrite an established conviction.

None of this requires rewriting the underlying fact. The proposition in the World is stable; the stance in the Mind is what evolves.

How beliefs get in: extraction with discipline

A vault ingests text by embedding it wholesale. A Mind is more deliberate, because storing a belief requires deciding what the belief actually is.

After a conversation turn, a structured extraction pass reads what was said and emits typed objects: entities, propositions, and "holdings" (a mind's own goals, preferences, and procedures). Write-time extraction and dedup are table stakes now, the whole agent-memory category does some version of them; in a Mind they're written idempotently against the World layer, so a proposition deduplicates on its claim key or its triple and the same fact reinforces one shared record rather than spawning a copy in every mind that hears it.

There's a narrower, stricter layer for directly-stated personal facts (a name, a timezone, a declared preference) that only records what the user actually said, never what was inferred from context. And there's a guard worth calling out because it speaks to the honesty of the whole approach: before extraction runs, any inferred context the system itself injected into the conversation (its own best guesses about the user) is stripped out, so the extractor can never launder its own guesses back in as if the user had stated them. The system is built to know the difference between what it was told and what it surmised.

The Mind organizes itself

Left alone, episodic beliefs would accumulate into a sprawl. So once a day, a consolidation pass runs. It clusters related beliefs by semantic similarity and shared subject, and where a cluster is strong enough, it proposes a more abstract belief that summarizes them, with an evidence chain linking the abstraction back to the specific beliefs that support it. The sources stay inspectable; nothing is thrown away. And the abstraction doesn't get to call itself confirmed on its own authority: it stays unconfirmed until it's either reinforced enough times to earn system confirmation, or a human confirms it.

This is real and it runs automatically. We'd frame it carefully: the substrate organizes itself into cleaner structure over time. It is not the agent rewriting its own goals by fiat, and that restraint is deliberate, which is its own paper.

Theory of mind, almost for free

Here's where the two-layer model pays a dividend that a vault simply can't. Because any entity can be the subject of a proposition, and any mind can hold an evaluation of any proposition, a question like "what does my research agent believe my financial planner thinks about my risk tolerance?" isn't a new feature to build. It's a query: a join across minds, propositions, and entities. Nested perspectives are representable by construction.

We want to be precise here, in keeping with how we've written the rest of this paper. The perspectival, multi-mind machinery is real in the schema and real in the code. What it is not, yet, is heavily exercised at scale in production: relatively few genuinely multi-mind propositions exist in the live system today. So the honest claim is about capability, not volume: the model makes nested, cross-agent belief representable as a first-class operation, and that's the foundation we're building the next layer of behavior on. It's the part of the architecture we're proudest of and the part we're most careful not to oversell.

What this is, and what it isn't

A Mind is a perspectival, affect-aware, self-organizing belief store. It holds facts once and stances many times. Its beliefs strengthen with use, fade on a curve bent by emotion, defer to what you actually said, and consolidate into cleaner abstractions over time, all without deleting or rewriting the underlying record.

It is not a hand-curated knowledge graph, and it is not magic. There are integrity properties we're still proving out: making sure a Mind reliably reflects its owner's actual goals rather than noise, and bringing every layer of belief (including an agent's core values) fully into the retrieval path. We track those openly because a memory system that overstates what it knows is worse than one that's modest about it.

But the shape of the thing is what matters, and the shape is genuinely different from a searchable pile of text. When a thinqOS agent remembers something about you, it's not finding a similar paragraph. It's holding a belief: one with an owner and an audience, one it can be more or less sure of, one that matters more or less, one that can change its mind.

Part of the thinqOS science series, by AI4Outcomes.