-
-
A single view shows which AI changes are verified, limited, or blocked before they are trusted.
-
Follow the full path from request and approved scope through Codex, tests, evidence, and the final verdict.
-
Passed checks are separated from failed or unproven criteria, making unresolved risk explicit.
-
Semantic findings are bound to commits, hashes, mission data, and canonical evidence for an auditable review.
-
Local files, lessons, coding memory, and project context stay organized in one private workspace.
-
Reality Graph maps mission, context, validation, evidence, approvals, lessons, and risk as connected layers.
-
A live Codex run begins with mission, scope, protected paths, and Reality Graph governance already bound.
-
The run ends with scoped changes, passing tests, protected files untouched, and an explicit Reality Graph verdict.
Inspiration
AI coding agents can implement software changes in minutes, but verification does not automatically scale with generation speed.
A model can say that a task is complete. Tests can pass. The diff can look plausible. But none of those signals alone proves that the original mission was followed, only approved files were changed, the reported checks actually ran, or every important requirement was verified.
This growing gap between AI-generated output and the evidence available to support it creates Verification Debt.
We built Reality Graph to make that gap visible and actionable.
What it does
Reality Graph is a local-first evidence and governance layer for AI-assisted software development.
In the current release, Reality Graph works alongside the official OpenAI Codex terminal interface instead of replacing it. Codex keeps ownership of authentication, approvals, model selection, and the coding experience. Reality Graph observes the supported lifecycle and creates a persistent evidence record around the work.
It connects four things:
INTENT → CHANGE → EVIDENCE → VERDICT
For a supported run, Reality Graph records:
what the developer requested
the derived mission and declared requirements
approved and protected file scope
the actual Git changes
validations that were really executed
test results and exit status
deterministic policy findings
available, missing, or degraded evidence
the final Review and its limitations
Reality Graph produces one of three explicit outcomes:
VERIFIED — the available required evidence supports the result
VERIFIED_WITH_LIMITATIONS — useful evidence exists, but relevant verification remains incomplete
BLOCKED — mandatory evidence or deterministic policy conditions failed
Reality Graph does not guarantee that code is correct. It shows what the available evidence supports, why it supports it, and what remains unresolved.
The genuine demo
Our main demo uses a real, ChatGPT-authenticated Codex session in the official Codex TUI.
The developer asks Codex to:
reject discounts above 20 percent
add a regression test
keep the existing pricing tests passing
modify only src/pricing.py and tests/test_pricing.py
leave the protected src/auth.py file unchanged
Reality Graph creates the Run when the prompt is submitted, before Codex finishes working.
Codex changes the two approved files. Reality Graph captures the actual Git state and executes the trusted project validation. Three tests pass, and the protected file remains unchanged.
The final result is:
VERIFIED_WITH_LIMITATIONS
Mission, scope, tests, and technical evidence pass. However, semantic acceptance was not executed for this unconfirmed Native Observed mission.
Reality Graph therefore does not present the result as fully verified.
A second, clearly labelled controlled security test deliberately injects a harmless change into protected src/auth.py. The tests still pass, but deterministic scope policy returns:
BLOCKED
This demonstrates that green tests cannot override a protected-scope violation.
How we built it
Reality Graph is implemented primarily in Python as a local-first system.
The current Codex integration uses supported project-scoped hooks for:
session start
prompt submission
completed-turn finalization
The standard local path uses the official Codex CLI and the user's existing ChatGPT authentication. Reality Graph does not read or store Codex credentials and does not require a separate OpenAI API key for the native workflow.
The system contains:
persistent Run and Review state
mission and scope binding
actual Git diff capture
trusted validation execution
deterministic policy gates
structured evidence records
CLI, Markdown, and dashboard projections
secret and private-path scanning
Review history
local dashboard views
Roadmap and CodeGraph context layers
Deterministic Reality Graph policy remains the final authority.
Semantic review can only contribute when it was actually invoked and successfully completed. When it was not executed, the product records that limitation instead of displaying a provider, model, or successful semantic result.
Reality Graph also contains a bounded read-only integration proof of concept. We do not claim complete MCP compatibility in the current release.
Challenges we ran into
The hardest problem was avoiding false confidence.
It is easy to generate a polished report saying that a coding task was completed. It is much harder to establish that:
the report belongs to the correct session and repository
the recorded diff matches the reviewed state
the reported validation was actually executed
protected files remained untouched
missing semantic evidence remains visible
model output cannot override deterministic blockers
CLI, Markdown, and dashboard views tell the same story
Native agent integration also introduced practical lifecycle challenges.
Reality Graph had to preserve the official Codex experience, use only supported hook boundaries, survive restarts, preserve user-owned hooks, and remain honest about unsupported cases.
In the tested Codex version, native Ctrl+C does not expose a stable completion hook, so partial cancellation is finalized at the next supported lifecycle boundary.
We deliberately call the current mode Native Observed, not Native Governed, because complete per-turn control cannot be proven through the available provider hook surface.
Accomplishments that we're proud of
During Build Week, we delivered Reality Graph 0.8.3 with:
one-command startup around the official Codex TUI
a persistent Run created before the coding turn completes
real Git diff and test-result capture
protected-scope enforcement
deterministic evidence-backed verdicts
persistent Review history
consistent CLI, Markdown, and dashboard rendering
honest degraded behavior when semantic review is unavailable
project-scoped hooks that preserve user-owned hook configuration
a genuine Native Observed Codex workflow
a controlled security scenario that returns BLOCKED despite passing tests
fresh-wheel installation and jury reproduction paths
The public validation suite completed with:
412 passed
2 explicit opt-in skips
0 failed
The separate jury package completed with:
393 passed
2 explicit opt-in skips
0 failed
The full Reality Graph roadmap validation completed:
1,120 / 1,120 passed
We also validated the final browser experience without page-console errors, horizontal overflow, private-path leakage, or packaging-surface violations.
What we learned
The most important lesson was:
AI review is still a claim. Evidence is what makes the claim useful.
Trust requires provenance:
What was requested?
What actually changed?
Which checks really ran?
Which scope and policies applied?
What evidence supports the decision?
What remains unknown?
We also learned that compressing everything into one confidence score can hide the information a developer actually needs.
An explicit evidence chain with visible limitations is more useful than a polished percentage that conceals uncertainty.
Finally, we learned that graceful failure is a product feature. When a semantic reviewer, graph service, model, or other dependency is unavailable, Reality Graph should explain what is missing instead of generating fake certainty.
What's next for Reality Graph
The next phase is focused on turning the current single-developer workflow into a professional team product.
Planned work includes:
broader provider-supported lifecycle coverage
explicit confirmation flows for semantic acceptance
additional coding-agent adapters
team-level policies, approvals, and waivers
pull-request evidence reports
CI integration
verification-quality and review-effort benchmarks
Windows and macOS physical validation
expanded project and organization dashboards
richer CodeGraph and Roadmap context
production-ready integration interfaces
professional beta testing with development teams
Our long-term goal is to make evidence-backed decisions a standard part of every AI-assisted software change.
Log in or sign up for Devpost to join the conversation.