The cognitive layer for AI

Your AI doesn't need a better memory.
It needs a mind.

A memory system can find facts. A Mind knows which facts should govern the task in front of it, how sure to be, and who in the room is allowed to see them.

thinqOS is the cognitive layer for AI: agents that remember you, learn your lessons, and can show you exactly why. A mind that persists across sessions, tools, and machines while the models keep changing. What it stores is not a chunk of text but a belief held by someone, carrying a source, a confidence, and an audience.

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 thinqos-harvest install --client both
✓ 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.
Beyond memory

Four ways AI holds context.
Only one builds understanding.

An AI can have perfect recall and still be clueless. Chat history, memory, RAG, and wikis can all hand it facts, and the best of them now extract and update those facts on their own. What none of them naturally decide is which route to take, which facts matter now, who they apply to, how much to trust them, what tools are in play, or what should stay out. That last part is 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

Memory / RAG

Retrieval

Finds facts, notes, and preferences that resemble the request, but similarity is not the same as judgment.

Useful, but limited

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

Digital Mind

Cognitive state

Holds beliefs that carry an owner, a confidence, and an audience, then chooses what should govern this task and what this room is allowed to see.

Persistent, contextual, and actionable

That last one, a Digital Mind, is four things working together:

Recall
Facts and preferences you can recall later.
+
Routing
Which memory, history, knowledge, or tool path this turn actually needs.
+
Attention
Which facts and boundaries govern this task, and who is allowed to see them.
+
Trace
What fed the answer, what was missing, and what was left out.
=
A Digital Mind
Cognitive state an AI can act from, scoped to the room, inspectable, and owned by you.

Looking for AI memory? thinqOS is that, and the part most memory leaves out. Building a context layer? This is the layer that decides what belongs in the moment.

How it works

Capture it. Route context. Explain the answer.

1

Capture

Capture context from conversations, documents, and AI-tool work, so a strategy you set in one place and a decision you make in another land in the same mind instead of scattering across apps.

2

Extract

Resolve raw context into reusable state: beliefs, goals, relationships, source, confidence, salience, and boundaries.

3

Route

At answer time, choose among Mind, history, documents, 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.

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 facts,
a mind for every perspective.

thinqOS separates what's true in the world from what each mind believes about it. Facts live once, in a shared world. Every identity, human or agent, holds its own perspective on them: how certain it is, how alive the belief is, where it came from, and who has seen it. The same fact can be held differently by you and by your agent. That split is what lets people and agents share one layer 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, observed, or consolidated. 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: Your AI Doesn't Need a Better Memory →

What it looks like

One fact,
two perspectives.

Context isn't a black box. A fact lives once in the shared world. Each mind holds its own read on it: its certainty, how alive the belief is, where it came from, and who's seen it. Here, you and your agent hold the same fact differently.

// The structure mirrors the real two-layer model:
// a shared proposition, plus a per-mind evaluation.
// Values shown are an example, not customer data.
refund_policy.mind Example 
# Shared world: the fact, stored once
proposition p-3920:
  summary: "Refunds over $200 need manager approval"
  subject: entity:refund-policy

# Your perspective on it
evaluation (you):
  confidence:   0.92
  salience:     0.80
  source:       declared
  protection:   locked      # you confirmed it
  disclosed_to: [you, agent:support]

# Your agent's perspective on the same fact
evaluation (agent:support):
  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, abstracts patterns from many, and lets all of them strengthen, fade, or lock 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 & consolidate

The mind derives new beliefs from what it already knows, and abstracts patterns from many specifics, turning scattered facts into general understanding it can reuse.

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.

Inspectable, 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 can be replayed, audited, and exported as a signed, portable package with its identifiers intact, so your context is 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 won't fix AI
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
DevelopersYou build with AI all day. Give your stack a mind that remembers your project, decisions, and context across your tools, models, and sessions.
Agent buildersShip agents with persistent minds, route-aware answer traces, per-call cost tracking, disclosure controls, and the inspectable audit trail real deployments need.
AI-forward organizationsMake cognition your edge: AI that compounds your org's knowledge instead of resetting every session.

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

Request Access See How It Works →