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, 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.
Plan the work and write a short SPEC of what success looks like. No code yet, just a clear target.
Execute the SPEC with self-validation, starting from a clean context. A new session catches what the invested one defends.
Journal what happened and why, one file for the day, then commit. Tomorrow's session reads it and picks up where you left off.
Plus /implement-audit for adversarial review, /explain for deep investigation, and a few more. Eight skills in Claude Code; the Loop verbs ship as native commands in Gemini, Codex, Cursor, and Copilot too.
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 hooks that actually fire: a commit gate, a destructive-git guard, a memory-write guard.
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, one file per day, written by /close at the end of a session.
Reconstructing an old decision needs both, so the system keeps both. 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. Pick your tools at install time and each gets its own native config from one source: a full .claude/ layer for Claude Code, GEMINI.md for Gemini, AGENTS.md for Codex, plus Cursor and Copilot. Same Loop, same rules, no drift.
The installer asks which AI tools you use, your name, and how autonomous you want the AI, then writes each tool's native config (.claude/, GEMINI.md, AGENTS.md, and the rest) and leaves your data alone on re-runs.
$ curl -sSL contextium.ai/install | bash Which tools you use, your name, and how autonomous the AI should be. It writes the native config for each tool you pick from one portable source.
Open the repo in Claude Code, Gemini, Codex, Cursor, or Copilot and start the Loop. The rules, commands, and hooks are already in place.
Each session journals its reasoning and commits. Re-run bash install.sh anytime to refresh the layer without touching your data.
The full .claude/ layer for Claude Code, shown here, plus empty data directories that grow as you work. Gemini, Codex, Cursor, and Copilot get the same methodology, rules, and Loop commands projected into their own native config.
The Loop verbs (project, spec, implement, close) plus implement-audit, explain, debate, and author. One keystroke each.
Always-loaded and kept short on purpose: voice, depth, boundaries, simplicity, no-deferral, mechanisms, journal format, and how to write your own.
Mechanisms that fire: a commit gate, a destructive-git guard, a memory-write guard, a session checklist. Not documentation. Infrastructure.
Fresh-context sub-reviewers the Claude skills dispatch when they need a second set of eyes: implement-audit, research, spirit-check.
Empty skeletons to start: people, goals, business context, daily logs, multi-session projects. They grow richer every session.
Docs-only templates for wrapping external services (GitHub, Google, Todoist, and more). Configure only what you need.
This ships as a methodology, not a pile of features. The heavy machinery, orchestration platforms, large reconcilers, multi-model SPEC review, per-session worktrees, is documented as advanced 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