← Theory

A Shared Mind for Claude Code and Codex

Claude Code and Codex each keep their own notes, tied to one tool and often one machine. Switch tools or laptops and yesterday's decision is not there. thinqOS gives both tools one shared Mind that belongs to you, not to a tool vendor.

Coding agents keep little across tools. Switch from Claude Code to Codex and you start over. Move to a second laptop and you may start over again. You become the memory: re-explaining the ticket, re-pasting the decision, reminding the agent of the convention it agreed to yesterday.

thinqOS is built to take that job off you. Its CLI connects Claude Code and Codex to one shared Mind: a durable, per-person memory that each connected tool reads from and writes to. This piece is for the developer who lives in Claude Code and Codex: what it feels like, then exactly how it works underneath, because for this audience the mechanism is the point.

What it is designed to do

With the hooks installed and working, these are the five things it is built to take off your hands:

• It already knows you. Open a brand-new session, in any folder, and ask: "what have I been working on, and what's the last thing I did?" With the hooks installed and working, it can answer from your recent tickets and last actions without being told to use thinqOS.
• It carries across tools. Make a decision in Claude Code, then ask about it in Codex: "did we keep that approach or drop it, and why?" The answer is designed to come from the conversation that happened in the other tool. One Mind behind both, not a cache per app.
• It picks up where you left off. Check out a ticket's branch on a different machine and just say "continue." The session-start hook is built to give the agent where you left off on that ticket, so it can resume your thread instead of asking you to recap it.
• It finds the conversation you can't place. "I was debugging something about a spend-cap smoke test a while back. Find that." It searches your past sessions from every connected tool. Exact identifiers have been a weak spot in our own testing, so check what comes back.
• It surfaces what's related. "Show me my other conversations connected to this work." It is built to return the cluster of related sessions, the ones you half-remember having.

The hooks are designed so you don't have to prompt for memory. We describe a tool as working automatically only after a dated end-to-end check for that tool, and we will list those checks as they are recorded.

How it actually works

There's no fine-tuning and no magic. It's two ordinary mechanisms doing honest work: the lifecycle hooks your CLI already supports, and a small set of MCP-compatible memory tools exposed by thinqOS.

Capture, after every turn

Claude Code and Codex both let you run a command when a turn ends: a Stop hook. The thinqOS CLI installs a small one. When the agent finishes responding, the hook ships that session's transcript to your thinqOS account. It runs in the harness, not the model: it sends the transcript without another model call, and the model cannot decide to skip it. Every machine you connect is designed to ship to the same place, keyed to you, so three laptops become one history rather than three.

Recall, before every answer

The same harness lets a command run when a session starts (SessionStart) and when you submit a message (UserPromptSubmit). The thinqOS CLI installs those too. Before the agent answers, the hook asks your Mind for what's relevant to the moment and prints it back as context the model reads first. The hook is built to supply relevant context before the agent answers, without you asking for it. On session start it also reads your current repo and branch, parses the ticket from the branch name, and injects a "where you left off" digest for that ticket. That is the resume step: it is designed to put the context on the table before you type a word.

One protocol to the Mind

When a hook needs recall or resume context, it calls thinqOS memory tools through the same JSON-RPC tool surface the agent can use directly. A handful of primitives sit behind it: recall the distilled beliefs and goals your Mind holds about you; search your verbatim conversation history; find related past conversations; and resume the most recent activity on a topic. The hooks call these on your behalf; the agent can also call them directly mid-task when it decides it needs to look something up. The hooks are built to prime the same Mind in Claude Code and Codex. thinqOS also connects to ChatGPT and Claude.ai, where the model decides when to call it.

Why a Mind, not a log file

Many agent memories now distill durable understanding out of raw transcripts, separating settled belief from verbatim history. thinqOS does that too. It reads each captured session and distills your goals, your conventions, the decisions you've made and later changed, into a structured Mind kept separate from the raw history. So a question like "what's my standing policy for resolving Sentry issues?" is answered from settled belief, while "find where I pasted that URL" is answered from verbatim history. Two layers, each queried for what it's good at.

What makes it a Mind rather than a cache is what it stores. Each settled thing is a belief held by someone, carrying a source, a confidence, and an audience. That fourth dimension is the seam most memories miss. Each Mind keeps its own record of a fact, anchored to a shared world of entities, and recall is designed to respect each belief's audience. How strictly that is enforced today is set out on the Trust and control page.

It's yours, and it's scoped to you

The Mind belongs to your identity, not to a vendor or a single app. Capture and recall are keyed to you, so what you build up in Claude Code is meant to be available in Codex and vice versa, and recall is designed to return only what your identity is permitted to see. The Trust and control page sets out how far that is enforced and tested today. You can read what your Mind holds, correct a belief, archive what is wrong, and export it in documented open formats; complete export is still being verified.

The shape of it

Capture on stop, recall on start and on every prompt, one shared Mind behind all of it, reachable over a standard protocol from whichever tool you happen to be in. The aim is continuity: one Mind your toolchain shares, so the next session can pick up where you left off.

Part of the thinqOS Theory series.