A mind for your coding agent.
Your coding agent starts every session blank. It re-suggests the approach you killed last week and reintroduces the bug you fixed on Tuesday. thinqOS captures your Claude Code and Codex sessions into a persistent mind, and before each answer it recalls the slice that governs the task in front of you. You stop being the memory.
- → Before it answers: the active ticket, the decision you already made, the approach you already killed.
- → After each turn: what changed is captured automatically. The model never has to remember to ask.
- → On every answer: a trace of which routes actually fed the response.
✓ Claude Code wired ✓ Codex wired ✓ existing memory imported
The context is in your head, not your agent
You explained the architecture on Monday. By Friday the agent has lost the module boundaries, suggests the library you already rejected, and walks you back into a refactor you decided against.
Every new session is a cold start. The reasoning behind the code, why this pattern and not that one, lives in scrollback you will never read again.
Per-tool memory does not fix this. ChatGPT's memory stays in ChatGPT. Your IDE plugin's context stays in the IDE. The moment you switch tools, or just open a new session, you are a stranger again.
Put a mind above your tools
thinqOS sits above your coding tools, not inside one of them. It captures your Claude Code and Codex sessions automatically, and before each answer it recalls what matters back into the agent's context. Every decision becomes a belief carrying a source, a confidence, and a reason, not a string you re-paste. Retrieval is only one route: thinqOS can also pull recent history, attached knowledge, and tool context, then record which routes were selected and which actually supplied context. Distilling beliefs out of transcripts is table stakes now; what makes this one yours is that the Mind lives above every tool, you own it, and it travels with you to the next tool and the next machine.
Connect Claude Code & Codex
Your sessions flow in as episodes, automatically. Claude Code and Codex are live today; Cursor and more are on the way.
Sessions become beliefs
Architectural decisions, naming conventions, the libraries you chose and the ones you rejected, recurring failure modes, and the why behind each, each one a belief you can read, see the source of, and correct.
Use what governs the task
Fixing a deploy, the agent already has the active ticket, the repo's release rules, the recent CI signal, and the destructive-migration constraint, recalled before it answers. Refactoring, a different slice comes forward. The answer trace shows which memory, history, knowledge, and tool routes were selected, so you can see what governed the task instead of trusting a black box.
What thinqOS knows about you: prefers small PRs · release rule: never bypass CI gates · dead end: the retry-wrapper approach was rejected 06-12 · lesson: verify the tag moved before claiming it moved.
Injected at session start and refreshed per prompt, in Claude Code and Codex alike. The model never has to remember to ask.
What the mind remembers
Decisions and rationale
Not just what you chose, but why, and what you ruled out getting there.
Conventions and patterns
How this codebase actually does things, so the agent stops fighting your style.
Dead ends
The approaches you already tried and rejected, so they stop coming back around.
Recurring failure modes
The bugs and traps this project keeps hitting, remembered across sessions.
Constraints
Performance budgets, security rules, dependency limits, the rails the work has to stay inside.
The thread across tools
A decision made in one tool is there when you open another, because the mind lives above all of them.
Why this is different
It is not another per-IDE plugin or another per-tool memory feature. The native memories are silos by design: Claude Code's auto-memory lives per-repo on one machine, Codex's memories live in local files on one machine, and neither reads the other. thinqOS is one mind, above every coding agent, owned by you and fully inspectable. The store is append-only, so you can read what it believes about your project, see where each belief came from, correct it, and retract what you do not want it to keep, with everything that depended on it falling away too. The runtime is inspectable too: answer traces summarize the cognitive routes selected for a response, how much context each supplied, and what was dropped for fit without exposing private source text. And it is portable: export your Mind with every decision and identifier intact as a single package, so your project knowledge is never trapped inside one model or tool. Even if you used thinqOS for nothing else, a coding agent that already knows your decisions and recalls the right ones at the right moment earns its seat.
For exactly how the connection works, capture after each turn, recall before each answer, and auto-resume of where you left off across tools, read A Shared Mind for Claude Code and Codex.
It also keeps two kinds of memory apart. The rules you hand-write, your CLAUDE.md and conventions, are instruction memory: stable, authored by you, changed only when you change them. What the agent harvests from how the work actually goes is learning memory: mutable, accumulated, and never allowed to quietly rewrite the rules you set. The mind sharpens on its own; what you instructed stays yours.
Wondering why not just keep a CLAUDE.md? Fair question, and the honest answer is Why Not Just Use a Folder of Markdown Files?: for one agent a vault of notes is enough, and there is a specific line past which it is not. If you are designing several agents rather than one, How Many Minds Do You Need? covers where the boundaries fall.