Experience becomes belief
A customer report is evidence, not truth. The Mind interprets it as a candidate claim, then holds a separate stance: how confident it is, how prominent the claim is, what emotional weight it carries, and whether it is protected.
Salience 0.45
Salience 0.40
Give this belief your attention.
Salience increases.
Protect this belief.
Much weaker evidence opens conflict.
Introduce contrary evidence.
The threshold decides blend or conflict.
Advance two weeks without attention.
Unprotected salience decays.
A customer report has become a candidate belief. In this example, the extractor assigned 0.50 confidence. Salience starts at its 0.50 schema default, and the belief is unprotected.
Full simulatorPush several beliefs around at once
The guided walkthrough follows one belief. This lab exposes the whole small Mind: several beliefs, an audit trace, open conflicts, protection, and compressed time.
Try this: let two weeks pass three times and watch what survives. Then recall one belief, protect another, and contradict it.
Everything here maps to a real mechanism: recall reinforces and resets the recency clock, confirmation sets a protection floor, a substantially weaker contradiction against a protected belief opens a conflict instead of overwriting, and decay archives whatever falls below 0.05 salience unprotected. Nearby evidence still blends normally. The emotional belief fades slower than you'd expect. That's the affect dampening.
The walkthrough is the path. These are the mechanics underneath.
Each section below keeps the interactive detail: identity boundaries, attention scoring, affect, decay, write paths, lifecycle, retrieval tools, and the parts that are not finished yet.
A shared world, a private mind
In plain terms: many Minds can refer to the same launch and the same reliability issue. What each Mind believes about them is its own business, and the walls between Minds are structural, not polite.
Entities, the nouns of the world, are shared. But claims and stances are private. Each proposition belongs to exactly one Mind, enforced by the database itself, not a read-time filter. Two Minds can consider the same decision differently, and neither can read the other's copy.
The company's Mind
issue · reliability
Entities are the common ground. Nothing else is shared.
External advisor's Mind
Both Minds hold their own record of the same claim, at their own confidence, anchored to the same shared entities.
Prompt assembly is responder-scoped: when an identity answers, the context assembler loads exactly one Mind, its own. And below the runtime rule, a composite foreign key means an evaluation structurally cannot reference another Mind's proposition. There is no cross-Mind path to leak through.
Attention is a score you can hold in your hand
When a Mind is asked "what matters right now," candidates are fetched by meaning, then re-ranked by a composite score. These are the actual weights from the attention code.
In plain terms: a belief wins attention by being relevant to the question, trusted, prominent, recently used, aligned with a goal, and, if you confirmed it, it gets a standing head start. Start from a preset, then move the sliders and watch it compete for the prompt.
show the working
Recall changes the Mind. Retrieval is not a read-only lookup. The winners get reinforced: their reinforcement count increments, their recency clock resets, and the recall itself is logged so "what did this Mind attend to, and when" stays auditable. Remembering something makes it easier to remember next time. That's the point. One tool, introspect, is deliberately exempt and fully read-only.
Notice what the affect sliders do: it's the absolute value of valence that boosts salience. Strongly positive and strongly negative beliefs both rise. Intensity drives attention, not polarity.
Everything fades, unless it's protected
Left alone, beliefs fade. Emotional weight slows the fade, mirroring the attention boost. Protection levels put a floor under what you've confirmed, and a hard stop under what you've locked.
In plain terms: what you never bring up drifts away, what moved you lingers, what you confirmed can fade but never below "still quite sure," and what you locked doesn't move at all. Pick a protection level and watch 180 days pass.
Curve shows salience from a starting value of 0.9, at the schema's default decay rate, dampened by affect: rate × (1 - |valence|·0.5) × (1 - arousal·0.5). A maximally affect-laden belief decays at a quarter of the neutral rate. Timescale is illustrative; the floors, threshold, and dampening formula are the real ones.
Protection also gates writes. If new information is substantially weaker than a protected belief—an existing-confidence advantage strictly greater than 0.15—the system refuses to blend it in and raises a conflict for review. Nearby evidence still uses the normal weighted blend. So a belief you explicitly confirmed can't drift below "quite confident, quite prominent," can't be archived, and can't be silently overwritten by a much weaker contradicting extraction.
Four doors in, one way to generalize
The main path
Conversations move through an episode state machine, get windowed, and each window is extracted independently and idempotently. Re-running a window cannot double-write. In group chats, only your own lines are attributed to you.
Direct and synchronous
States a belief outright. The claim is resolved or created, the stance is written at the given confidence, and it's marked confirmed and protected immediately. No extraction sweep needed.
Asynchronous
Persists free text as a durable, rebuild-safe record and queues it for the normal extraction worker. Eventual, not immediate.
Seeded identity
An agent's configuration seeds locked, protected beliefs: its authoritative self-model, which ordinary chat statements can't silently overwrite.
One belief, two months
Follow a single belief from a throwaway sentence to protected knowledge. Choose any step; the card on the right shows how its state changes. The mechanisms and defaults are code-backed; the elapsed timeline is illustrative.
"Customers are reporting failed checkouts"
The chat's episode moves through the extraction state machine. The extractor emits a proposition with a summary and an embedding, plus an evaluation in the responding agent's Mind. It assigns confidence from the evidence; this example uses 0.50. Salience starts at its 0.50 schema default, with neutral affect.
The leadership team asks whether the launch is still safe
The recall scores this belief well: high relevance, decent recency. Recall is not read-only, so the belief is reinforced, its recency clock resets, and the recall is logged.
Usage calibration now works in its favor: a belief that keeps getting recalled scores higher next time.
"Should we delay until the issue is resolved?" Yes.
The evaluation becomes confirmed at protection level user_confirmed. The click itself does not manufacture certainty; it sets 0.7 floors that the next decay pass enforces. The belief cannot be archived, earns a +0.05 retrieval bonus, and opens a conflict when substantially weaker evidence collides with it.
The scheduled-campaign assumption quietly archives
A throwaway belief from the same chat, never confirmed and never recalled, decays freely. Once its salience drops below 0.05, it's archived. Nothing protected ever reaches that threshold.
Tiered recall, deliberate writes
Retrieval comes in tiers, cheapest to deepest, and most of them change the Mind by design: recalling reinforces. The reads that don't are marked. Writes are explicit.
| Tool | Effect | What it does |
|---|---|---|
| prime_mind | read-only | Cheapest tier. A bounded, salience-ranked set for session startup and ambient priming. No embedding call, no commit. |
| recall_mind | reinforces | The default query-focused semantic tier. Returns a formatted context block; the winners get reinforced. |
| search_mind | reinforces | The deepest tier: full history plus fuzzy recall, with a coverage receipt and a contract about when "you never told me" may be claimed. |
| introspect | read-only | A query-less snapshot of top beliefs, holdings, and the working set. The one retrieval tool that never reinforces. |
| believe | writes | Asserts one confirmed, protected belief, effective immediately. |
| observe | writes | Persists free text durably; extraction happens later, on the worker's schedule. |
| resolve | writes | Confirms an evaluation, or locks it so decay never touches it. |
| consult_mind | judgment | Not memory CRUD: a decision gate for non-trivial actions. Returns proceed, proceed-with-caution, ask-user, defer, or block. |
| export_mind | portable | The whole Mind leaves as a signed archive or open linked data: beliefs, goals, and memory, never secrets. |
Deterministic list tools (propositions, holdings, entities) and maintenance operations (rebuild, import) exist too; the table shows the surface most people touch.
Everything you need, in one place
A Mind is not something you run instead of memory. thinqOS is the cognitive layer that includes your memory and adds belief and judgment on top. If what you want is the best memory, what you want is the whole stack: your full history, retrieval over your documents, exact records, and a Mind that reasons across all of it. There is nothing else to bolt on.
Your whole history, searchable
Every conversation is kept and searchable to the deepest tier, with a coverage receipt, so the system only says "you never told me" when it can back it up. The Mind is distilled from that history; the raw record never goes away.
Retrieval over your documents
Documents are indexed and retrieved, and they feed beliefs and stay linked in the graph. You get the retrieval and the belief that came out of it, not one instead of the other. It is RAG, with a memory that learns.
Exact records, too
Keyed records with precise lookup live alongside and project into the Mind as holdings. Precise storage and cognition in one system, not two you have to reconcile.
Memory, retrieval, and records underneath; cognition on top. That is what "cognitive layer" means. It does not replace your memory, it is your memory, made able to hold a point of view.
Real, deployed, and not finished
Because the Mind is a projection over stored source history, it can be rebuilt: replayed cheaply from the event log, or re-extracted expensively from the sources. That property is also why the gaps below are fixable rather than fatal. Stated plainly:
Beliefs carry an audience list, but an empty list is treated as universal in some code paths, and holdings aren't audience-filtered yet.
The system can usually show why a belief exists, but not always the complete chain from source observation through extraction, prompt, response, and correction.
Reinterpreting a Mind re-runs extraction over its history: real cost, real time, provider rate limits. A production operation, not a refresh button.