Integrations
Keep the coding tool you already use
Reality Graph integrations are hooks, not plugins. One command installs them into the agent’s own project configuration for the Codex CLI and for Claude Code, and removes them again. Everything else works beside Reality Graph through a prompt you paste yourself. Git is the one requirement, because that is where the evidence comes from.
Last updated:
Your setup
Two bound agents, and an honest word for everything else
Two rows below describe hooks that bind an agent's lifecycle to a run. One describes an install that is not yet proven. The last describes a workflow that happens to work, which is a different and weaker promise.
| Tool | Status | What that means in practice |
|---|---|---|
| OpenAI Codex CLI | Hooks installed | realitygraph integrate codex. Codex supplies a per-turn identity, so a run is bound to the turn that produced it. Version-gated to the verified hook contract, and native Ctrl+C emits no stop, so that run finalises at the next boundary. |
| Claude Code | Hooks installed | realitygraph integrate claude writes .claude/settings.json. The hook contract is documented and not version-gated. Claude Code supplies no per-turn identity, so Reality Graph derives one and records it as observer-derived; an interrupted turn finalises when the next prompt arrives. |
| Antigravity | Installs, not yet proven | A user-scoped plugin rather than a project file, so one install covers every project on the machine. Its validator accepts a hooks file without proving which events the running agent invokes, so this reports observed only once a real hook event arrives. |
| Cursor, GitHub Copilot, other agents | Works beside it | No adapter, no hook, no lifecycle binding. You paste a generated prompt, and the evidence still comes from Git afterwards, whichever tool made the change. |
The per-tool pages go through the workflow one at a time: OpenAI Codex, Claude Code and Cursor.
By design
What connects, and what we refuse to call a connection
An integrations page is where a product is most tempted to describe an intention as a binding. Two tools are bound. The rest are named for what they actually are.
What is wired in
- The Codex CLI and Claude Code, through reversible hooks in the agent's own project configuration, leaving login, approvals and model controls untouched.
- A prompt you paste into any other tool, generated for the mission on record.
- A local read-only context server that answers project questions, writes nothing and makes no network call.
- Git, as the source of changed files and diffs after the run.
What is not
- Hooks for Cursor, GitHub Copilot, Windsurf or Cline. No adapter, hook or lifecycle binding exists for any of them.
- CI integration. There is no API client, no parser and no ingestion path for any provider.
- Git hooks, pre-commit integration, pull-request checks or a GitHub App.
- Any control over another tool. Reality Graph never injects, launches or reads back.
Validated on Linux with Python 3.12 and the official Codex CLI. Windows and macOS are unverified in the current release matrix.
Questions people actually ask
- Why do only some tools get hooks?
- Because a hook needs a documented lifecycle surface to bind to, and not every tool has one. Codex and Claude Code both emit session start, prompt submit and stop under a documented contract, so both are bound through one adapter. Cursor and GitHub Copilot expose nothing equivalent, and listing them as integrations would be the easy version of this page and the false one.
- What is different about Claude Code?
- One thing, and it is recorded rather than smoothed over: Claude Code supplies no per-turn identity in its hook payload. Reality Graph derives one from the session and marks it observer-derived, so a reviewer can always tell a provider-supplied identity from one this tool minted. An interrupted turn also emits no stop, so it finalises when the next prompt arrives.
- What exactly does integrating do to my setup?
- It merges Reality Graph entries into the agent’s own project configuration: .codex/hooks.json for Codex, .claude/settings.json for Claude Code. Your login, approvals and model controls stay untouched. Repair and removal only touch entries Reality Graph wrote; ambiguous ownership fails closed rather than editing a stranger’s handler. And it observes rather than governs: Reality Graph cannot stop or cancel a turn.
- Do I need Git?
- Yes. Git is the attachment point for the evidence: changed files and diffs are read from it rather than taken from the model's prose. Without Git there is nothing for a verdict to rest on, and capture fails closed above 500 KB of scrubbed diff.
Nothing to rip out, nothing to migrate
Whichever agent writes your code keeps writing it. What changes is what you have in your hand afterwards.