Durable Memory + a Mind

Memory remembers.
A Mind understands.

Memory preserves the full history. A Mind decides what matters now, how sure to be, and who in the room is allowed to see it. Together, they create cognition.

thinqOS is the cognitive layer for AI: a durable, continuously growing Memory for sources and evidence, paired with a novel Mind for beliefs, goals, confidence, relationships, attention, and judgment. Both persist across sessions, tools, and machines while the models keep changing.

In private preview · An AI4Outcomes product
Request Private Preview Give your coding agent a mind →
Read our point of view →
my_mind · live capture 12,391 relationship lines
A real Mind. Every dot is a belief with an owner, a source, and a confidence, clustered into the themes it lives by.
For developers · Claude Code + Codex One command. Your agent starts every session already knowing you →
$ uvx --link-mode=copy thinqos install
✓ Claude Code wired  ✓ Codex wired  ✓ memory imported
# your next session opens with:
Where you left off on TOS-1046: panel shipped in #2288; ticket close pending verification.
What thinqOS knows about you: prefers small PRs · release rule: never bypass CI gates · lesson: verify the tag before claiming it moved.
Two layers, one cognitive system

Memory preserves.
A Mind decides.

Memory and Mind solve different problems. Memory can keep the complete source history and retrieve the right evidence. A Mind turns that evidence into beliefs, confidence, goals, relationships, boundaries, and attention. thinqOS keeps both layers distinct, then makes them work together as cognition.

Chat history

Ephemeral

Stores the conversation, but the meaning fades the moment the session ends. Every new thread starts cold.

Fragile and easy to lose

Retrieval memory

Retrieval

Preserves facts, files, and history, then finds the evidence a request may need. It is the durable substrate, not the judgment layer.

Essential source layer

Wiki / Context layer

Organized knowledge

Curated, linked knowledge — wikis, context files, and open formats like Google's OKF. Portable and agent-readable, but relevance is still re-derived from text, links, and conventions.

A filing cabinet with a schema

thinqOS cognition

Memory + Mind

Pairs durable evidence with beliefs that carry an owner, confidence, and audience, then chooses what should govern this task.

Persistent, contextual, and actionable

thinqOS pairs two distinct layers:

Memory
The durable, continuously growing source layer: full documents, evidence, history, and searchable retrieval.
+
Mind
The novel cognitive layer: beliefs, confidence, goals, preferences, relationships, boundaries, attention, and judgment.
=
Cognition
Evidence and judgment working together: contextual, inspectable, scoped to the room, and owned by you.

Memory does not become less important when you add a Mind. It becomes more useful: the Mind can reason from durable evidence without forcing every source into cognitive state.

How it works

Capture it. Route context. Explain the answer.

1

Capture

Preserve conversations, documents, and AI-tool work in durable Memory, so the full source remains searchable instead of scattering across apps.

2

Extract

Let the Mind learn supported beliefs, goals, relationships, confidence, salience, and boundaries from those sources.

3

Route

At answer time, route between Mind, Memory, history, and tools, then assemble only the context that should govern this turn.

4

Trace

Keep the answer inspectable: which routes were selected, which had context, what was dropped for prompt fit, and where follow-up repair or learning belongs.

The receipt, on every answer
Used from your Mind: "Deploys apply migrations before traffic cutover" (belief · confidence 0.92 · source: incident 2026-06-16) Confirm Forget
Dropped: 2 older tickets (below relevance floor) · Tools considered: 14 offered, 3 used · Cost: $0.004

Every answer carries its trace: what fed it, what was dropped and why, what it cost - and you can correct the Mind right from the receipt.

In practice

Same task. Four levels of context.

The point is not to pour the whole mind into every prompt. The point is to filter an evolving mind through the task at hand, so the AI acts on the few facts that should govern this moment and ignores the rest.

And it is not just better context - it can be cheaper. In a blind test on our own production conversations (July 2026), a proposed tight-context-plus-retrieval configuration matched a full-transcript window's answer quality at about 15% of the uncached answer-prompt tokens. The giant window, given more raw material, actually hallucinated slightly more. That quality-matched configuration is the direction thinqOS is building toward, not the shipping default; today's smaller configuration was the weakest arm measured.

Blind replay study · July 2026: 80 turns · 14 conversations · 5 context strategies · Read the paper →

Developer

"Fix this failing deploy."

No memory

Reads the current error and guesses from the prompt.

Memory / RAG

Retrieves similar errors, old fixes, or notes that share terms with the failure.

Wiki / OKF layer

Finds release docs, architecture pages, and runbooks if they are named and maintained well.

Cognitive layer

Brings in the active ticket, repo rules, recent CI history, release contract, and "do not bypass production checks" because those govern the fix, then leaves an answer trace showing which context routes actually fed the recommendation.

Agent builder

"Prepare the customer-risk brief."

No memory

Summarizes whatever was pasted into this run.

Memory / RAG

Finds nearby customer notes, tickets, or call transcripts.

Wiki / OKF layer

Reads account, risk, renewal, and support pages if they exist and are current.

Cognitive layer

Weights goals, source freshness, confidence, open commitments, approval rules, relationship context, and tool results before drafting the brief.

Personal AI

"Help me answer my financial planner."

No memory

Gives generic planning language.

Memory / RAG

Pulls old finance notes that look similar to the question.

Wiki / OKF layer

Looks up maintained pages about goals, risk tolerance, and constraints.

Cognitive layer

Intersects the question with current goals, preferences, uncertainty, relationship permissions, and what should not be shared, with a traceable reason for why that context surfaced.

What a mind tracks

A shared world of entities,
a mind for every perspective.

thinqOS separates the world every mind shares from what each mind believes about it. The shared world is the entities: the people, projects, and concepts every mind reasons about, the common ground. Every identity, human or agent, holds its own beliefs anchored to them: how certain it is, how alive the belief is, where it came from, and who has seen it. You and your agent can hold the same claim about the same thing at different confidences, each its own record, neither reaching into the other's. That's what lets people and agents share one world without sharing one blob.

Confidence

How certain this mind is about a belief, from 0 to 1, and its own value, not the world's. It eases down over time unless the belief is confirmed or locked.

Attention & salience

How alive a belief is, and whether it should enter this interaction. Attention combines task relevance with goals, recency, source trust, relationships, and boundaries.

Source

How the belief arose: declared, extracted, inferred, or observed. A typed record of why the mind believes what it believes.

Boundaries

Who each belief may be shared with, tracked per belief and enforced inside recall itself. A belief not meant for this room is never even considered, so privacy is how remembering works.

Read: Why Memory Needs a Mind →

What it looks like

Same fact,
two minds.

Context isn't a black box. You and your agent both know this fact, and each of you holds your own record of it, anchored to the same shared entity. Each record carries its own read: its certainty, how alive the belief is, where it came from, and who's seen it. Here, you and your agent hold the same claim differently.

// The structure mirrors the real two-layer model:
// a shared entity, plus each mind's own proposition and evaluation.
// Values shown are an example, not customer data.
refund_policy.mind Example 
# Shared world: the entity both minds point at
entity refund-policy

# Your mind: your own record of the claim, plus your stance
proposition p-3920 (owner: you):
  summary: "Refunds over $200 need manager approval"
  subject: entity:refund-policy
  evaluation:
    confidence:   0.92
    salience:     0.80
    source:       declared
    protection:   locked      # you confirmed it
    disclosed_to: [you, agent:support]

# Your agent's mind: its own record of the same claim, its own stance
proposition p-7714 (owner: agent:support):
  summary: "Refunds over $200 need manager approval"
  subject: entity:refund-policy
  evaluation:
    confidence:   0.74
    salience:     0.41      # decaying, unreinforced
    source:       inferred
    protection:   none
    disclosed_to: [agent:support]
Living beliefs

A mind doesn't just hold beliefs.
It forms them.

thinqOS doesn't only store what it's told. It derives new beliefs, and lets all of them strengthen, fade, lock, or reconcile over time, the way memory actually behaves. The edge isn't any single one of these moves. It's that they happen to beliefs that each carry an owner, a confidence, and a source, inside a mind you can read line by line.

Infer & propose

The mind derives new beliefs from what it already knows. When a pattern in your goals or preferences starts to form, it's meant to surface that for you to confirm or correct, never to promote its own guess unchecked.

Decay & reinforce

Every belief fades on a decay curve unless it's used. Bring one up again and it strengthens. What you stop touching quietly recedes. What still matters stays vivid.

Protect & forget

Confirm a belief and it resists decay. Lock it and it can't be overwritten. Forget one and every inference that leaned on it is defeated in a cascade, so nothing keeps standing on a fact you removed.

Reconcile

When a new belief collides with an old one, the mind surfaces the conflict instead of silently overwriting. It supersedes what's outdated, keeps the old version as history, and updates what it now trusts.

Inside a digital mind

What a mind holds.

Beliefs are only part of it. A mind also carries goals, preferences, procedures, and relationships: the durable state an identity needs to act.

Goals

What the identity is trying to achieve.

Preferences

What it likes, values, and avoids.

Working notes

Durable plans, commitments, and open questions; momentary context stays in the turn.

Procedures

Learned how-to: the steps it knows for getting something done.

Relationships

Who and what connects: trust, relation, and links between them.

Built for humans and agents

One cognitive layer, doing two very different jobs.

Underneath, it's the same engine: a digital mind for an identity. But giving yourself continuity across the tools you use, and giving the agents you build a mind that persists, are two different stories. thinqOS does both.

For you

Carry your own mind across every AI you touch. thinqOS holds durable beliefs, goals, and evidence, then gives each model or tool the right scoped context based on what you are doing and who you are with. You stop re-explaining yourself to each new tool, and no model you switch to starts from zero.

Personal contextAcross toolsAcross contextsContinuity

For your agents

Give the agents you ship a persistent identity: goals, preferences, procedures, and beliefs that survive restarts. Each agent gets its own mind, isolated by default. They consult and delegate to each other, instead of waking up blank every run.

Agent identityIsolated mindDelegationContinuity

Building with AI coding agents like Claude Code or Codex? See thinqOS for Developers →

Trust by design

Private by default, and yours to steer.

One mind, one owner

Each identity has its own mind, and minds are isolated by default. No agent can read another identity's mind. Privacy is the architecture, not a setting, so a bad day in one mind stays in that mind. There is no shared blob for it to spread through.

You steer what's remembered

Confirm a belief, lock it, edit it, or forget it, one at a time. Turn capture off per conversation. The mind only keeps what you let it keep.

Open by design, not opaque

The mind is readable, queryable structured state, never a black box. Changes are append-only, answer traces show which cognitive routes and context fed a response, and the whole mind exports as open linked data, JSON-LD, YAML-LD, or a Vault-LD folder you own, against a published, resolvable context. Your memory can leave and join a wider graph, never locked to one model or vendor.

Who's building this

Built by people who've shipped
context infrastructure before.

thinqOS is built by the team at AI4Outcomes, an AI-native product portfolio based in Ontario, Canada. Its founder is a primary inventor on multiple patents related to data and AI context, the exact problem of giving AI trustworthy access to what matters. The work toward a persistent cognitive layer has been years in the making, and thinqOS is where it comes together.

An AI4Outcomes productExplore the portfolio →
Dan DeMers

Dan DeMers

CO-FOUNDER · PRODUCT

Primary inventor on multiple patents related to data and AI context. A career building data and AI infrastructure, with earlier roles in markets at RBC and Citigroup.

Jenn DeMers

Jenn DeMers

CO-FOUNDER · OPERATIONS

Operations, execution, and company-building across the AI4Outcomes portfolio, spanning enterprise environments and scaling-business operations.

Building in the open
Why Memory needs a Mind
Read →
Building in the open
One world, two minds
Read →
For builders and buyers
The context layer that thinks
Read →
Access

Private preview,
opening in waves.

thinqOS is in active development. We're opening access gradually and matching each team, agent, or builder to the right preview. Tell us how you'd use a digital mind.

Request Private Preview
IndividualsFor you and the agents you rely on. Keep your own context and add durable agents for recurring work, each picking up where it left off, across every model and machine.
Small businessFor a small team and the agents that support it. Give the owner, sales, support, and ops their own Minds under shared rules and activity history, then hand work between them.
Office of the CEOA fully configured executive team that works from how your business runs. We build your agent team with you and stand up a shared world model of your organization, kept current, so cognition, not headcount, is the leverage.
EnterpriseFor security review, deployment controls, and contracted support, whatever your size. Governed Minds, full activity history, and the audit trail real deployments require.

The model you use will keep changing.
The mind that knows you should not.

Request Access See How It Works →