Most AI sessions start from zero, then drift halfway through a long thread. Contextium is the methodology that fixes that. Give your AI an operating system.
$ curl -sSL contextium.ai/install | bash A genuine multiplier across everything you build. But every session starts from zero. You re-explain your preferences, the AI makes a plausible guess, drifts halfway through a long thread, and tomorrow you start over. The gap between AI's promise and your reality never closes.
Snippets you paste, a memory feature that's a flat list of facts, rules nobody enforces. No structure that survives a long thread. Day 1,000 looks like day 1.
A sticky note.
A way of working: a thinking-and-doing loop with fresh context between them, specs and decisions in published formats, rules backed by hooks that actually fire, and memory written down every session. Each session builds on the last.
An operating system.
The Loop is one command per verb. The boundary between them is the point: a session that wrote the plan and grew attached to its choices is the wrong one to also judge the work.
Agree the goal, settle the open decisions (each question comes with its recommended answer), split the work into roadmap rows, and write a reviewed spec for each. No code yet.
Build one row's spec from a clean context, test it, and get it reviewed. Rows that don't depend on each other run in parallel sessions, each in its own worktree.
Mark finished rows done, journal the session, then land it: commit, merge, push, and prove against a fresh fetch that nothing was left behind. You don't type it — the other two verbs do.
Plus /spec-audit and /implement-audit for adversarial review on a different model, /explain for deep investigation, and a few more. Eleven skills, read by T3 Code, Claude Code, Codex, Cursor, Gemini, Antigravity and Grok from one folder.
What happens between typing a verb and the work being safely on origin.
One repo holds every project: code, specs, decisions, journal. It installs at ~/code/workbench by default, and every session opens there.
The installer asks which tool you drive it with — T3 Code is the recommendation — and installs it if it is missing. Every tool reads the same AGENTS.md and skills folder; there are no per-tool copies to drift.
Each session writes in its own git worktree — the one T3 Code makes for a thread, or one made on first write. Two sessions never share a working tree, so parallel roadmap rows cannot trip over each other.
Lint, types, tests, then review, then lint again if the review changed anything — a script decides the order, not the model. A change that touches a web app gets screenshots at desktop and mobile widths before it closes.
A table picks the reviewer for each kind of work and leaves out the model that wrote the code, so the review does not share its blind spots. With no second model installed, a fresh-context review stands in and says it is not independent. The reviewer also sees who calls what the diff changed.
The close commits, merges the trunk, pushes, fetches again, and checks the work is really there before it removes the worktree. Its last line — closing this tab loses nothing — is printed by that check, never by the model.
A project is laid out the way GitHub's spec-kit lays out a feature: a roadmap of rows with their dependencies, and one spec folder per row. The next step is derived from the roadmap by a script, never typed. Anything left unsettled is marked NEEDS CLARIFICATION, and the build won't start until you settle it.
Choices that would be expensive to reverse become MADR decision records. A record only says accepted when it quotes the words that accepted it, and a commit check holds it to that. A conversation can't quietly become a decision nobody made.
A rule that lives only in a document gets forgotten in the exact moment it was written to cover. Contextium's rules that matter are wired to mechanisms that actually fire: a guard that refuses an edit outside the session's worktree, a guard on commands that change shared hosts, and checks the close runs on every decision record, journal entry and staged secret before it commits.
Advisory prose is allowed, but it's honest about being advisory. When a correction recurs, you write it down once and give it a mechanism. The layer becomes yours.
The git log records what changed. The journal records why each session went the way it did, one file per session in a folder per day, written by /close. Decision records hold why the system is the way it is.
Six months from now you can see what you chose, what you rejected, and the reasoning, instead of re-exploring the same dead ends.
It's plain markdown in a git repo that you own. No platform holds it hostage. If a tool raises prices or pivots, your accumulated context doesn't vanish with it.
Model-agnostic by design. Everything shared lives once: AGENTS.md and .agents/. Most tools read both as they are; the rest reach them through a link in your home folder. One copy on disk, every tool pointed at it, no drift.
The installer asks which AI tools you use, your name, and how autonomous you want the AI, then writes .agents/, wires each tool to it, and leaves your data alone on re-runs.
$ curl -sSL contextium.ai/install | bash Which tool you drive it with (T3 Code recommended), your name, and how autonomous the AI should be. It installs anything missing and links your tool to the one shared layer.
Open ~/code/workbench in your tool and start the Loop. The skills, standards and guards are already in place.
Each session journals its reasoning and lands its own worktree. Re-run bash install.sh anytime to refresh the layer without touching your data.
The shared .agents/ layer and AGENTS.md, plus empty data directories that grow as you work. Every tool reads these same files.
The Loop (project, spec, implement, close), its reviewers (spec-audit, implement-audit, review), qa, explain, debate, and author. Each carries its own scripts and templates.
The judgment rules a change is measured against — read before asserting, a class fix is atomic, no deferral, fix the cause, a test seen failing first — loaded by every tool, refreshed on upgrade, beside your own preferences.
Guards that fire before an edit or a command, wired into each tool that supports them, and the checks the close runs before it commits. Not documentation. Infrastructure.
Fresh-context agents the skills dispatch for a second set of eyes: implement-audit, spirit-check, research, and AI-layer review.
Empty skeletons to start: spec-kit projects, MADR decision records, session journals, and your knowledge. The installer never touches them once they exist.
Docs-only templates for wrapping external services (GitHub, Google, Todoist, and more). Configure only what you need.
This ships as a way of working, not a pile of features. Deploy-on-push stays off until you list the paths that deploy; orchestration platforms and large reconcilers are patterns you can grow into.
You start with the way of working and add weight where your own work demands it. Nothing you don't use is wired in.
Contextium is MIT licensed. No premium tier. No hosted service. No data collection. Just a git repo of markdown files that you own completely.
Run one command, then try /project. Then every session compounds.
$ curl -sSL contextium.ai/install | bash MIT · Plain markdown · No lock-in