Crossing GuardAn open source control layer for AI coding agents
One memory, one rulebook, one honest boundary — across every coding agent you use. Local-first, being prepared for open-source release. Hook overhead depends on your configuration.
No public install or download is available from this page. This is a website design preview, not a product release. Examples, support labels and metrics illustrate the intended design.
Works with the agents you already use — and says exactly how well
Same binary, same rule file, demonstrated live on three agents across three model families. The two "registered" agents have their hook seams mapped; coverage is probed before we ever call it proven. We never claim a wall we didn't build — that honesty is the product.
What it does
01
Your project knowledge follows you between agents — files-first, no vendor store. Hit a limit on one, pick up on another with the context intact.
02
Write "never push to main" once. It compiles to each agent's own hook seam — and the coverage report tells you, per rule, per agent, what's truly enforced versus best-effort. Nobody else labels the seams honestly.
03
The same rules.json drove a live block on Claude Code, Codex, and OpenCode — three integration styles, one source of truth. Add a runtime by adding a data row, not a rewrite.
How it works
One command, then crossing attach wires the hooks into each agent you use.
Pick from the library or write a capability + action. It compiles to every agent's seam automatically.
The report shows what's enforced, best-effort, or unsupported — per agent. No surprises, no bluffing.
No user-count to quote yet — so here's proof of work instead of proof of a crowd. Every claim above links to a probe you can run.
Never get stuck
When one agent hits the wall mid-task, the paddle goes up — and your session, memory, and rules cross to another agent or a local model. Keep working.
At limit Claude Max · resets 4h 51m
Cross to Codex → session + memory + rules travel with you.
For the team lead who has to answer for it
Org policy is a signed, versioned bundle — org > repo > user, tighten-only. Compiles locally; the server just distributes it.
Every rule renders its real enforcement per agent. A security review reads the report, not the marketing.
Self-host the whole thing, with any future managed service subject to a separate announcement. License and contribution terms are being finalized.
We didn't put Open in the name. We put it in the license.
The Comparison Lab
Reproducible head-to-heads — same repo, same rules, same session-carry test — with probe artifacts attached. Updated when the probes re-run.
| Matchup | US searches/mo | Status |
|---|---|---|
| Codex vs Claude Code | 13,600 | Probe-backed |
| OpenCode vs Claude Code | 3,150 | Probe-backed |
| Gemini CLI vs Claude Code | 2,200 | Registered |
Open-source release in preparation. Explore the design and proposed workflows.
Home › Agents
One memory. One rulebook. Your own agents.
Bring reviewer, helper, and follower agents into the coding workflow you already use. Choose the models behind the roles. Give each a job worth doing.
Marketing concept. Role examples explain the intended experience, not a live demonstration or a release support promise. Spontaneous Memory below is a proposed capability.
A second perspective. A focused pair of hands. Someone keeping an eye on the bigger picture. Different roles, working around the same task.
01 · REVIEWER
Bring in an agent to examine changes, question assumptions, and surface issues before you move on.
Example brief: “Review this change for failure paths and explain what needs attention.”
02 · HELPER
Give a helper a bounded task alongside the main work: investigate a question, check an assumption, or prepare a focused result.
Example brief: “Check the relevant documentation and report the constraints.”
03 · FOLLOWER
Have a follower track work as it develops and contribute observations without taking over the main task.
Example brief: “Watch for decisions that conflict with the project's earlier direction.”
At the heart is the open-source framework we're preparing for release: a place to connect your own code to supported events in the AI workflow.
Use different models for different roles across supported providers. A reviewer needn't use the same model as the agent doing the work.
Give each role instructions, relevant context, and a clear scope. The framework is the foundation; the frontend is where those roles and their work become visible.
When this happens…
A supported event makes relevant work available.
…run your logic…
A check, a reviewer, or another focused contribution.
…within its authority.
Advice, observation, and permission to act are different things.
Provider choice depends on available integrations and credentials. Triggers, context access, execution and delivery vary by role and runtime; this concept does not promise arbitrary-provider compatibility or identical controls everywhere.
The framework and your configuration
Crossing Guard provides the mechanisms. Your configuration describes how you want to use them. You don't have to adopt our development process to use the framework.
The connections to supported agent hooks, the machinery for running checks and evaluating rules, and the records of what happened. It defines the available capabilities and their boundaries.
Your chosen models, agent instructions, selected rules, and workflow criteria. What should a reviewer look for? Which facts matter to your project? Those choices belong to you, not hidden inside the framework.
When existing mechanisms aren't enough, extend the framework at supported integration points. Add a check or integration, then configure how your workflow uses it.
Shared mechanism: run a reviewer and record its findings.
Your configuration: choose its model and instructions—review database changes for one project, accessibility for another.
An extension when needed: connect a project-specific checker through a supported integration point.
The interface brings configuration and results together: what is selected, which agent contributed, and what it reported. Available controls depend on the implemented role and integration; configuration is not a promise that every option has a visual editor.
A supplied configuration pack is a starting point, not a mandatory workflow. Configuration cannot create a missing hook, enable unsupported live interruption, or grant an agent authority by itself. Spontaneous Memory's proposed delivery choices remain subject to those same boundaries.
Spontaneous Memory · proposed concept
Your main agent follows the task. A memory follower looks beyond that immediate context for a past decision, forgotten constraint, or relevant lesson that could change the work.
It isn't only remembering what you asked it to remember. It's making a useful connection to knowledge outside the main line of context—and bringing it back when it matters.
“Before you continue: we tried this approach before. Here's why we changed it.”
Illustrative message, not an actual retrieved memory or product transcript.
Surface an insight at a supported checkpoint, when the working agent has an opportunity to use it.
For an important insight, interrupt the working agent where live delivery is supported and explicitly authorized.
No. Event-triggered delivery, queued messages, and live interruption are different capabilities. An event or queued delivery must not be presented as an immediate interruption. Spontaneous Memory and its delivery behavior need implementation and runtime-specific verification before a release claim.
No. A relevant memory is context, not an instruction with higher authority. The follower's contribution remains separate from permission to approve, change files, or control another agent.
Shared memory, shared rules, and your own supporting agents. The crossing guard stays at the intersection; you decide who joins the work.
Back to Crossing Guard →Home › Compare
Same task, same rule file, same session-carry test on every agent — each claim linked to a probe you can run yourself. Updated when probes re-run, and every page says when. No vibes. No affiliate links. Bring a snack.
Cells ship only where probes actually run — anything else is one more opinion listicle, and the internet is stocked.
| Matchup | US/mo | KD | CPC | Status |
|---|---|---|---|---|
| Codex vs Claude Code | 13,600 | 8–16 | $30.00 | Probe-backed |
| Claude Code vs Cursor | 11,900 | 5–12 | $7.00 | Partial |
| OpenCode vs Claude Code | 3,150 | 7 | $3.50 | Probe-backed |
| Claude Code vs GitHub Copilot | 2,650 | 1–4 | $6.00 | Registered |
| Gemini CLI vs Claude Code | 2,200 | 9 | $5.00 | Registered |
| Codex vs Cursor | 1,300 | 3–6 | $25.00 | Watch list |
Same "never push to main" rule on each runtime's own hooks — who blocks, who asks, who times out open. Enforced / Best-effort straight from the coverage report.
Kill it mid-task, resume elsewhere. What survives? With our layer: files, memory, and rules do.
"Yes, even the expensive ones stop."
Home › Reference
Hooks, memory, context files, session formats — researched across Claude Code, Codex, and OpenCode, side by side, with the differences that actually bite.
| Page | Target term | Vol/mo | KD | Status |
|---|---|---|---|---|
| Claude Code memory, actually explained | claude code memory | 1,000 | 7 | Ships |
| Hooks: the complete seam map | claude code hooks | 2,800 | 25 | Ships |
| CLAUDE.md — what loads, when, how big | claude md | 1,200 | 8 | Draft |
| MCP config across runtimes | claude code mcp | 3,900 | 35 | Planned |
| Skills, cross-vendor | claude code skills | 8,800 | 59 | Long game |
Every page cites its probe. When a vendor changes a seam, the canary flips and the page updates with a dated changelog. The research came first — this site publishes the homework behind the tool.
Home › Limits
What counts against every plan's meter, when it resets, what you lose mid-task — and how to walk your work across instead of waiting at the wall.
At limit the paddle is up
resets 4h 51m · 5-hour window · opus counts ~5× sonnet
Your session doesn't have to wait: carry it across →
Open
34% of window · weekly cap separate · resets Thu 09:00
No meter
your machine, your rules · slower, private, always open
No free tier — it rides a Claude subscription (Pro/Max) or API billing. Free: this page's plan math, and the open-source layer that carries your work when the meter runs out.
Natively the session freezes and context is stranded until reset. With a crossing guard: session, memory, and rules walk across to another agent — or a local model — and work continues.
In the real build this is a live status check, not an essay.