Caliber: keeping CLAUDE.md, .cursor/rules and AGENTS.md in sync with a moving codebase
Continuously sync your AI setups with one command. Codebase tailor suited agent skills, MCPs and config files for Claude Code, Cursor, and Codex.
At a glance
- What is it?
- Caliber is an MIT-licensed TypeScript CLI that generates and refreshes AI context files for Claude Code, Cursor, Codex, OpenCode and GitHub Copilot, with a deterministic scorer and a pre-commit refresh loop. The judgement: the audit-first workflow and the backup/undo path are the parts worth adopting, while the score itself is a rubric, not a measurement of whether your agent actually behaves better.
- Who is it for?
- Adopt Caliber if your team runs more than one agent platform and your context files are hand-maintained, because the audit-then-diff workflow, the .caliber/backups/ originals and caliber undo give you a reversible way to keep CLAUDE.md, .cursor/rules/ and AGENTS.md aligned with the repository. Skip it if a single hand-written CLAUDE.md is working, or if you cannot run the bootstrap step from a real terminal.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 52 days ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The stale-context problem Caliber targets
The README opens with a specific failure: a hand-written CLAUDE.md goes stale the moment you refactor, and the agent then references paths that no longer exist, misses new dependencies, and reasons about yesterday's architecture. That is a real category of breakage. Context files are ordinary text checked into the repository, so nothing forces them to be updated when a module is renamed or a dependency is swapped. The agent has no way to know the file is wrong. It simply reads it and proceeds.
Caliber's answer is to treat those files as generated artifacts with a refresh loop rather than as documents a human maintains by hand. The audience is teams that already use at least one coding agent and have noticed the drift, and specifically teams where different engineers use different tools. The README lists Claude Code, Cursor, Codex, OpenCode and GitHub Copilot, and notes that AGENTS.md is shared between Codex and OpenCode when both are targeted. If everyone on the team uses one editor, the multi-platform generation is dead weight and the value narrows to the refresh loop alone.
What the scorer actually measures
The Before/After panel is the most quotable part of the README and also the easiest to misread. It shows a jump from 35/100 to 94/100 across six named categories: FILES & SETUP, QUALITY, GROUNDING, ACCURACY, FRESHNESS and BONUS. The README is explicit that scoring is deterministic, with no LLM and no API calls, and that it works by cross-referencing config files against the actual project filesystem. The stated checks are whether referenced paths exist, whether code blocks are present, and whether there is config drift since the last commit.
That is a structural audit. It can tell you that CLAUDE.md points at a directory that was deleted, or that the file has not changed since the last commit while the tree has. It cannot tell you whether the prose in the file is accurate about behaviour, or whether the agent produces better diffs because of it. The 94/100 badge in the header is the same rubric score applied to a repository, not a benchmark result. Treat it as a checklist that either passes or fails, and read the per-category breakdown rather than the total.
Bootstrap, /setup-caliber and caliber init
The install path requires Node.js >= 20 and starts with a single command:
npx @rely-ai/caliber bootstrap
The README describes bootstrap as a one-time step that takes about two seconds and is entirely local, with no LLM calls and no code sent anywhere. It installs a /setup-caliber skill into your agent. You then start a Claude Code or Cursor CLI session in your terminal, not in the IDE chat window, and type /setup-caliber. The agent detects the stack, generates configs for each targeted platform, sets up pre-commit hooks and enables continuous sync.
If you do not use Claude Code or Cursor, the alternative entry point is caliber init, described as the same setup delivered as a CLI wizard. That path requires you to bring your own key for Anthropic, OpenAI, MiniMax or Vertex AI. The distinction matters: bootstrap itself never calls a model, and generation happens through your own subscription or API key. The README's claim that Caliber never sees your code follows from that arrangement, but it is worth confirming which provider your wizard run is pointed at before the first generation.
The refresh loop and the files it writes
After setup, the loop is: configs are generated, your code evolves, and caliber refresh runs automatically on every commit through a pre-commit hook. The README's diagram places refresh at the end of the cycle and routes it back to regeneration. New team members are nudged to bootstrap on their first session.
The generated set is platform-specific and named in the README. For Claude Code it writes CLAUDE.md, CALIBER_LEARNINGS.md, .claude/skills/*/SKILL.md in the OpenSkills format, .mcp.json for auto-discovered MCP servers, and .claude/settings.json for permissions and hooks. For Cursor it writes .cursor/rules/*.mdc with frontmatter fields description, globs and alwaysApply, plus .cursor/skills/*/SKILL.md and .cursor/mcp.json. For Codex it writes AGENTS.md and .agents/skills/*/SKILL.md. For OpenCode it writes AGENTS.md and .opencode/skills/*/SKILL.md. For Copilot it writes .github/copilot-instructions.md.
CALIBER_LEARNINGS.md is the one artifact that is not a config file. The README describes it as patterns learned from your AI coding sessions, which implies an accumulating file that grows over time. How it is pruned or bounded is not stated in the supplied material, and that is a gap worth checking in the repository before you commit to the loop.
Audit first, writes second, and the undo path
The workflow is deliberately staged: score, propose, review, backup, undo. Scoring is read-only. Proposed changes are shown as a diff. You accept, refine through chat, or decline each change individually. Originals are copied to .caliber/backups/ before any write, and caliber undo restores everything to its previous state.
There is a second behaviour buried in that section. If your existing config already scores 95 or higher, Caliber skips full regeneration and applies targeted fixes only to the checks that are failing. That is a sensible guard against churn in repositories where the context files are already in decent shape, and it also means the tool's output is not uniform across projects. Two teams running the same version can get very different volumes of change depending on where they started.
For branch work, the README gives one concrete command:
caliber score --compare main
That reports how your branch moved the score relative to main, which is the closest thing here to a CI gate. The README does not describe a non-zero exit code or a threshold flag, so wiring it into a pipeline as a hard failure is not something the supplied material supports.
Windows, provider detection and the failure modes named in the README
The Windows notes are the most candid part of the documentation and read like accumulated bug reports. Run from a real terminal (PowerShell, CMD or Git Bash), not from inside an IDE chat window. Git Bash is recommended because the pre-commit hooks and auto-sync scripts use shell syntax; if you only use PowerShell, the README states that hooks may be skipped silently. That is the sharpest limitation in the whole document. A skipped hook means the refresh loop stops running and the configs drift again, with no error surfaced, which is precisely the failure Caliber exists to prevent.
Two more constraints are stated. For Cursor Agent CLI on Windows, download from cursor.com/downloads rather than using the curl | bash command shown for macOS and Linux, then run agent login. And run one terminal at a time, because concurrent Caliber sessions can cause conflicting state and unexpected provider detection. Provider detection is therefore stateful, and the README treats simultaneous runs as unsupported rather than merely discouraged.
There is also a scope boundary implied by the design. Caliber generates context files and audits them against the filesystem. It does not verify that the agent's answers are correct, and it does not manage the MCP servers it discovers in .mcp.json. If your problem is agent output quality rather than config drift, this is the wrong tool.
How this differs from hand-maintained configs and from docs generators
The obvious alternative is doing nothing: keep a CLAUDE.md written by hand and update it during code review. The difference in approach is where correctness is enforced. A hand-written file is correct only when a reviewer notices it has gone stale, and the review has to happen on the same pull request that renamed the module. Caliber moves the check to a deterministic filesystem comparison that runs on every commit, which catches path references and drift without anyone remembering to look. What it gives up is editorial judgement. A generated CLAUDE.md reflects detected languages, frameworks and dependencies; the architectural rationale a senior engineer would write is not something the described mechanism produces.
The other comparison is with documentation generators in the Sphinx or TypeDoc family. Those extract structure from source and publish it. Caliber writes files that are consumed by an LLM at inference time, and its scoring rubric is about whether those files are grounded in the repository, not whether they are complete API references. The overlap is that both are generated, and both need a regeneration step in CI or in a hook. The divergence is the consumer: one is a human reader, the other is an agent that will act on a wrong path.
Maintenance cost, licence and what to verify first
The repository is TypeScript, MIT-licensed, not archived, and the release list shows v1.53.5, v1.53.4 and v1.53.3 all published on 2026-07-26, with the last push timestamp matching v1.53.5 to the second. Three patch releases inside a few minutes on the same day is a release cadence that implies frequent small fixes. For an adopter, that cuts both ways: bugs get addressed quickly, and the version you pin can be superseded within hours. Pinning a specific version in package.json rather than tracking latest is the more predictable choice for a hook that runs on every commit.
MIT is permissive and imposes no source-disclosure obligation on your project, but this is not legal advice and the licence text in the repository is the authoritative document. Note that the npm package is published as @rely-ai/caliber while the repository lives under caliber-ai-org, and the README points to trycaliber.ai as the homepage. If your organisation has rules about which registries and domains are approved, that split is worth resolving before the first bootstrap run.
The first thing to verify is the Windows hook behaviour if anyone on the team uses PowerShell, since silent skipping is the one failure mode that defeats the product's purpose. The second is the CALIBER_LEARNINGS.md growth policy, which the supplied material does not describe. Run caliber score --compare main on a throwaway branch and read the six category lines before deciding whether the generated diffs are ones your reviewers will accept.
Editorial conclusion
Adopt Caliber if your team runs more than one agent platform and your context files are hand-maintained, because the audit-then-diff workflow, the .caliber/backups/ originals and caliber undo give you a reversible way to keep CLAUDE.md, .cursor/rules/ and AGENTS.md aligned with the repository. Skip it if a single hand-written CLAUDE.md is working, or if you cannot run the bootstrap step from a real terminal. Before rolling it out, run caliber score --compare main on a branch and read the per-check breakdown, since the 94/100 figure in the README is a rubric score computed from your filesystem, not evidence that agent output improves.
Community notes