Same answers as your CLAUDE.md. 30% cheaper at scale. Your agent asks before it guesses.

Quick start · Features · How it works · Commit checks · Console · Cloud & Teams · Benchmark · FAQ · Docs · Discord

_{New: Contexer Personal Cloud & Teams: sync decisions across machines, share a team decision layer.}

The decision and enforcement layer for AI coding agents

Capture engineering decisions and their reasoning, review changes, and bring the right guidance into Claude Code, Cursor, Codex, and Gemini CLI. With Contexer Teams, share and version decisions across your team, so every teammate's agent picks up an approved change on its next prompt, and enforce the rules that matter with Contexer Guard, on each commit or pull request.

_{150 team rules · Claude Sonnet 5.5 · 1,242 sessions scored by code · synthetic tasks in one repository · benchmark}

Contexer keeps a reviewable, versioned record of what was decided, why, and whether it has been approved. The same local decision store works across supported assistants, so your engineering guidance is not tied to one agent's conversation history. Review, revision history, team approval, and explicitly enabled checks turn recorded decisions into guidance you can manage and verify.

A simple example

You tell your assistant:

"Always use our shared API client for outgoing requests. It handles authentication and retries; separate implementations caused duplicate requests."

Contexer can save both the rule and its reason. In a later session, your assistant can retrieve that decision instead of guessing why the shared client exists. If you link the decision to source files, Contexer can flag when those files change so you know to recheck the advice.

Clear directives can be captured automatically. For an important decision made during a discussion, say "store that decision". Capture beyond explicit directives is best-effort.

See Contexer in action

Watch how to install Contexer and capture your first decisions.

Quick start

Requires Python 3.12+ and uv.

uv tool install contexer   # 1. install
contexer install           # 2. wire into your AI assistants

contexer install auto-detects supported assistants and configures the ones it finds. Restart your assistant, open your project, and follow Contexer's first-run setup guidance to build its starting context.

Cursor uses its own Contexer integration with every supported model, including Claude. If you also use Claude Code, Contexer prevents its imported Claude Code hooks from duplicating actions in Cursor. See the coexistence setup.

Then try telling your assistant:

Save this as a convention: always use uv, not pip, in this project.

Decisions are stored locally in plain JSON under ~/.contexer/, in a directory only you can read. The local features do not require a cloud account; cross-machine sync and team sharing are optional. If a saved store ever becomes unreadable, Contexer keeps working but refuses to overwrite it, so nothing is lost while you recover the file.

Details: installation & verification · per-tool integration notes

Features

Keep your CLAUDE.md, AGENTS.md, GEMINI.md, or .cursor/rules files for stable instructions. Contexer adds searchable decisions, revision history, review, and file-linked context alongside them.

More: why not just use CLAUDE.md?

How it works

1. Capture. Contexer detects clear directives, imports supported memory files, and gives your assistant tools to save decisions with their reasoning.
2. Reuse. Standing rules load when a session starts, approved constraints first, with a pointer to the rest when the list is long. Matching decisions can be retrieved as you ask questions or reference files, without loading the entire store. A decision can also record situations it applies to ("slow upstream reads"), which helps a task worded differently find it; agents don't add these reliably yet.
3. Review and maintain. Inspect pending items, correct an entry, or update a decision when your approach changes. Earlier revisions remain available.

Ask your assistant in plain English:

What decisions did we make about Postgres?
Store that decision, including why we rejected the other option.
Store that globally: use conventional commits across my projects.

Deep dive: how it works · day-to-day usage & CLI

Review and trust

contexer review

Not all captured knowledge has the same status. Clear user directives can be approved automatically. Repository observations and AI-inferred starting context are usable but explicitly non-authoritative; confidence or repeated scans do not count as human approval. Some other AI-inferred knowledge is available as a labeled suggestion; items marked pending approval wait for your review instead of becoming standing rules.

When two current decisions prescribe incompatible version formats, Contexer shows them together as a conflict so the agent asks you which applies. Other contradictions aren't detected automatically yet, though in the benchmark agents using Contexer still asked about every contradicting pair.

Proposed changes to an existing decision do not silently replace its current revision. When a proposed update conflicts with the standing decision, Contexer can show both versions, clearly labeling the unreviewed one, so you can choose what is correct.

Use the review command or local console to inspect the reasoning and evidence, approve or edit pending items, and dismiss advice you do not want.

Optional commit checks

contexer guard adds an opt-in Git pre-commit hook with two levels of checking:

contexer guard --install-hook   # wires .git/hooks/pre-commit for this repo (opt-in, not run by `install`)

Reminders by default. A relevant, trusted approved decision linked to or mentioning a staged file surfaces before the commit, which still goes through. This is a reminder to check the rule, not automatic detection of a violation.

Blocking only when you enable it. Arm an approved decision with a machine-checkable rule (contexer guard arm <id> --regex '<pattern>' or --check secret). A detected violation can then fail the commit. Only explicitly armed checks can block; the guard does not interpret arbitrary architectural rules as executable tests.

GUI commit flows (VS Code, Cursor, and similar) run the hook but only surface a blocked commit; the warning-only reminders are terminal output a graphical commit panel won't show you.

The guard fails open (any internal error, or a run over budget, skips checks rather than blocking your commit) and can be bypassed per-commit with CONTEXER_GUARD=0 git commit …, same as any pre-commit hook is bypassed with --no-verify. It's a local nudge, not a substitute for CI: your pipeline's checks are the backstop that can't be skipped from a developer's machine.

Details: mechanism · CLI reference

Browse and manage your decisions

contexer ui --open

A local web console shows what Contexer has stored across your projects, not just the repository you are working in.

• Inspect and edit. Search decisions, read their reasoning and revision history, and correct their content without losing earlier versions.
• Review proposed changes. See pending decisions and before/after diffs for proposed updates.
• Erase sensitive content. Run contexer erase <id> or choose Erase content in the console to permanently remove one decision’s local content and history. A content-free erasure record remains.
• Export. contexer export --format md or --format adr writes your decisions as Markdown or one ADR per decision, with secrets redacted by default.
• Delete and restore. Remove unwanted decisions while retaining the option to restore them. Deletion markers prevent the same imported entry from immediately reappearing.
• Switch context. Browse per-repo decisions, global rules, cached team context, deleted entries, and settings.

It binds 127.0.0.1, every route is authenticated, and the server itself never reaches the network. It is also off until you ask for it: contexer ui starts it on demand, and the printed link is short-lived on purpose. Set [ui] autostart = true and every session start hands you the URL for the repo you just opened.

Details, the [ui] settings, and the security model: the local console

Personal Cloud and Teams

The open-source local store works for one developer across supported assistants. Optional hosted services extend where that knowledge is available:

Why it matters more for a team

The benchmark ran one developer's sessions; Teams itself has not been benchmarked yet. These are the findings that grow with a team, and what Teams adds on top:

• More people write more rules. A rules file's cost per session grew 36–37% when the rulebook went from 34 to 150 rules; Contexer's grew 15%. Every teammate's agent pays that per session.
• More authors write rules that contradict each other. Agents using Contexer asked before coding on every contradicting pair in the benchmark (12 of 12), against 7 of 12 with static files.
• One approved rulebook for everyone's agents. A lead reviews shared decisions before they become team rules, and every teammate's agent (Claude Code, Cursor, Codex, Gemini CLI) receives the same approved set. Nothing becomes team policy without that approval.
• Checks on pull requests, not just prompts. Contexer Check compares each pull request's diff with the team's approved decisions and posts an advisory review comment. A lead can promote an individual decision so the optional Teams Guard check fails when a pull request drifts from it.
• A record of who decided what. Team decisions keep their history, reviewers and approvals.

See personal and team context in action

Watch how Contexer handles your personal decisions and shared team context.

Shared decisions pass through secret redaction first. If you switch redaction off (redact_secrets = false), every share warns you and asks you to confirm the exact text, and background sends pause until it's back on.

Learn more: Personal Cloud & Teams · connection and sharing guide

Limitations

• Capture is not exhaustive. Contexer does not save every useful conclusion from every conversation. Explicitly ask to store important decisions and review what was captured.
• Assistant integrations differ. Cursor's hooks limit per-prompt context injection; Gemini CLI restores context on the next turn after compression. See the integration notes.
• Code changes are signals, not verdicts. A changed file can make a decision worth reviewing, but Contexer cannot guarantee that all stored advice is current or correct.
• Reminders are not enforcement. Agents can still ignore context, and local commit hooks can be bypassed. Keep tests and CI checks for guarantees you depend on.
• Sharing is optional. The local store is per-developer. Cross-machine sync and team context require the corresponding hosted service.

Full details: published limitations.

Benchmarks

We gave an AI coding agent 38 tasks that only come out right if it knows a team rule, and compared Contexer with a full CLAUDE.md, a folder of decision docs, and no rules, at 34 and 150 stored rules (1,242 sessions, scored by code).

• Same accuracy, lower cost: 30% less per session than a full CLAUDE.md, because only the relevant rules are sent. At 34 rules decision docs led on accuracy (111 vs Contexer's 108).
• Asks instead of guessing: when two current rules contradicted each other, agents using Contexer asked first every time.
• Not yet solved: rules stated during a session reached the store in only 6 of 24 runs, against 24 of 24 for a CLAUDE.md the agent was told to maintain.

Read the benchmark → · Try it on your repo in two commands →

Documentation

Contributing

Bug reports, fixes, and documentation improvements are welcome. See CONTRIBUTING.md for setup, code style, and the PR process. Questions or ideas? Join the community on Discord.

License

MIT. See LICENSE for full terms.

The Contexer name and logo are trademarks of Contexer.ai. The MIT license does not grant rights to use the Contexer name, logo, or brand in any way that implies official affiliation.