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 /probe for adversarial self-review, /explain for deep investigation, and a few more. Seven skills total.
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.
Built on Claude Code, but the methodology travels. One source generates the instruction file each agent reads, so Codex, Cursor, Gemini, Copilot, Windsurf, Cline, and Aider all run the same Loop without drift.
The installer lays down the .claude/ layer and a starter CLAUDE.md, asks your name and how autonomous you want the AI, and leaves your data alone on re-runs.
$ curl -sSL contextium.ai/install | bash Your name and how autonomous the AI should be. It writes a starter CLAUDE.md and lays down the .claude/ methodology layer.
Open the repo in Claude Code (or your agent of choice) and start the Loop. The rules, skills, 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.
A .claude/ layer plus a starter CLAUDE.md and empty data directories that grow as you work.
The Loop verbs (project, implement, close) plus probe, explain, debate, and propose-rule. 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 skills dispatch when they need a second set of eyes: code review, probe, 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, Notion, 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