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. Everything shared lives once, in .agents/. Claude Code, Codex and Cursor read it through symlinks; Gemini and Copilot get config generated from it in the format they need. 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 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 canonical .agents/ layer, shown here, plus empty data directories that grow as you work. Every tool reads these same files — by symlink where the format matches, by generated config where it does not.
The Loop verbs (project, spec, implement, close) plus both reviewers (spec-audit, implement-audit), explain, debate, and author. One keystroke each, in every tool.
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 skills dispatch when they need a second set of eyes: implement-audit, spec spirit-check, research, rule-efficacy, AI-layer. A Claude Code bonus.
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