← Library

A Shared Mind for Claude Code and Codex

If you live in Claude Code and Codex, you already know the tax: every session starts from zero. Each one is brilliant for an hour and an amnesiac forever. thinqOS gives them a shared, persistent memory: recalled before the agent answers, captured after, the same across every tool and every machine. The memory is yours, not a vendor's, and what surfaces is strictly your own.

Coding agents are astonishing within a session and helpless across them. Close the terminal and the context is gone. Switch from Claude Code to Codex and you start over. Move to a second laptop and you 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 removes that tax. It gives your coding agents one shared mind: a durable, per-person memory that every 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 feels like

Five things stop being your job:

• 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?" It answers with your real recent tickets and your last actions. Nothing to connect, no "use thinqOS" incantation. A stock agent starts blank; yours starts oriented.
• 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 comes back, pulled from a 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 has already greeted the agent with where you left off on that ticket, so it resumes 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 locates the exact messages across every past session, no matter which tool or day they happened in.
• It surfaces what's related. "Show me my other conversations connected to this work." It returns the cluster of related sessions, the ones you half-remember having.

None of these require you to prompt for memory. That's the whole point: the system remembers so you don't have to ask it to.

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. thinqOS installs a tiny 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: zero tokens billed, zero conversation overhead, and the model cannot decide to skip it. Every machine you work on ships 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). thinqOS 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. So the recall is involuntary and ambient: memory surfaces the way it does in your own head, without you going to fetch 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's the auto-resume: the context is already 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. Because the memory surface is MCP-compatible, the same mind works from Claude Code, Codex, and hosted assistants alike.

Why a mind, not a log file

Distilling durable understanding out of raw transcripts is table stakes now: any serious agent memory reads sessions and separates 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 smarter cache is the unit 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. One fact lives once and is shared to many minds with no duplication, and disclosure is enforced at recall, not just at write: a belief outside the room is never even a candidate to surface. Scopes are isolated by default, so the blast radius of anything you record stays contained to where it belongs.

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 available in Codex and vice versa, and everything any tool surfaces is strictly your own conversations, never anyone else's. Ownership here is architecture, not a policy promise: the store is append-only, so nothing is silently overwritten; it's inspectable, so you can read what it holds about you; it's correctable, so a wrong belief can be retracted; and forgetting cascades, so removing a thing removes what depended on it. You can export your mind, decisions and beliefs with their identifiers intact, as a single portable package you can re-import. Your memory lives above any one model or app, never trapped inside one. Turn off the hooks and the tools go back to amnesiac; the memory stays, yours to keep.

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 result is the thing that's been missing from coding agents since they arrived: continuity. Not a better memory bolted onto one app, but a single mind your whole toolchain shares, that already knows what you did yesterday and tells you where you left off before you ask.

Part of the thinqOS science series, by AI4Outcomes.