Reality Graph

Reality Graph is a self-reported local-first evidence and governance layer for AI-assisted software development, built as a proof-of-concept during an OpenAI hackathon. The product claims to observe AI-generated code changes, record mission, scope, tests, and approvals, and produce verifiable outcomes (VERIFIED, VERIFIED_WITH_LIMITATIONS, BLOCKED) based on deterministic policy checks.

The description states that Reality Graph works alongside the official OpenAI Codex terminal interface, capturing Git diffs and validation results, and enforcing protected file scope. It does not claim to guarantee correctness but instead shows what evidence supports a decision and what remains unresolved.

Key commercial signals are absent: no revenue, customers, pricing, or adoption data are provided. The project is described as a single-developer effort with no external validation beyond its own test suite.

The description states that Reality Graph is:

• A local-first evidence and governance layer for AI-assisted software development.
• It works alongside the official OpenAI Codex terminal interface, not replacing it.
• It records and verifies:
  • What the developer requested
  • Derived mission and declared requirements
  • Approved and protected file scope
  • Actual Git changes
  • Validations that were executed
  • Test results and exit status
  • Deterministic policy findings
• It produces one of three explicit outcomes:
  • VERIFIED
  • VERIFIED_WITH_LIMITATIONS
  • BLOCKED

Reality Graph is implemented in Python, uses supported project-scoped hooks for lifecycle events (session start, prompt submission, turn finalization), and integrates with the official Codex CLI.

It does not claim to store or read Codex credentials, nor does it require a separate OpenAI API key for its native workflow.

Inference The product is described as a tool that observes AI-generated code changes and applies deterministic checks to produce governance verdicts. It is not an AI model itself but a monitoring and verification system.

The description states:

• Reality Graph was built to address Verification Debt, which arises when AI-generated output lacks sufficient evidence to support it.
• The product aims to make the gap between AI generation and verifiable evidence visible and actionable.
• It is positioned as a governance layer, not a replacement for AI coding tools.

The author claims that:

• “AI review is still a claim. Evidence is what makes the claim useful.”
• Trust requires provenance: what was requested, what changed, which checks ran, etc.
• Compressing everything into one confidence score can hide information developers need.
• An explicit evidence chain with visible limitations is more useful than a polished percentage.

Inference The positioning has evolved from a hackathon prototype to a tool that emphasizes transparency and trust in AI-assisted development, focusing on governance over correctness.

The description states:

• Reality Graph works alongside the official OpenAI Codex terminal interface.
• It is designed for developers using AI coding agents, particularly those working with local-first workflows.
• The current demo uses a real ChatGPT-authenticated Codex session.

It does not state:

• Who the end-user customer is beyond a developer
• Whether it targets teams or individuals
• If there are specific verticals or industries

Inference The initial ICP appears to be individual developers using AI coding tools, particularly those working in local environments and seeking governance over their changes.

The description states:

• Reality Graph is a local-first system.
• It integrates with the official Codex CLI and uses existing ChatGPT authentication.
• No pricing or monetization model is described.
• No revenue, customer base, or commercial traction is mentioned.

Inference There is no evidence of a business model or pricing structure. The product appears to be a prototype without commercialization plans.

The description states:

• Reality Graph is implemented in Python.
• It uses supported project-scoped hooks for lifecycle events (session start, prompt submission, turn finalization).
• It captures Git diffs and validation results.
• It supports CLI, Markdown, and dashboard projections.
• It includes:
  • Persistent Run and Review state
  • Mission and scope binding
  • Trusted validation execution
  • Deterministic policy gates
  • Structured evidence records
  • Secret and private-path scanning
  • Review history
  • Local dashboard views

It also mentions:

• Native agent integration challenges (e.g., Ctrl+C does not expose a stable completion hook)
• Deliberate use of the term Native Observed, not Native Governed, due to limitations in provider hook surface.

Inference The technical approach is local-first and Python-based, with hooks for lifecycle events. It supports multiple output formats (CLI, Markdown, dashboard) and integrates with existing tools like Codex.

The description states:

• The product was built during a hackathon.
• Current version: 0.8.3
• It includes:
  • One-command startup
  • Persistent Run before 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
  • Controlled security scenario returning BLOCKED despite passing tests

It also mentions:

• Public validation suite: 412 passed, 2 skips, 0 failed
• Jury package: 393 passed, 2 skips, 0 failed
• Full roadmap validation: 1,120 / 1,120 passed
• Browser experience validated without errors

Inference The product is a mature prototype, with a functional demo and test suite. However, there is no evidence of customer adoption or commercial traction.

The description does not mention:

• Direct competitors
• Existing tools in the AI governance space
• Market positioning relative to other verification or compliance systems

Inference No competitive context is provided. The product appears to be unique in its specific integration with Codex, but there is no evidence of a broader market landscape.

The description states:

• Reality Graph is a single-developer effort.
• It is built for local-first workflows and does not yet support full CI/CD or team-level governance.
• The current mode is labeled as Native Observed, not Native Governed, due to limitations in the provider hook surface.
• It does not claim complete MCP compatibility.

Inference

• Risk of limited scalability beyond individual developers.
• Risk of incomplete integration with AI agents due to hook limitations.
• Risk of no commercial traction or product-market fit without evidence of adoption.
• Red flag: The product is described as a hackathon prototype, not a production-ready tool.

1. What is the intended transition from a single-developer workflow to a team-level governance system?
2. How does Reality Graph plan to expand beyond Codex and support other AI coding agents?
3. Are there any plans for CI/CD integration or pull-request evidence reports?
4. What are the technical limitations of the current hook-based approach, and how will they be addressed?
5. Is there a roadmap for team-level policies, approvals, and waivers?
6. How does the product plan to scale beyond local-first workflows?
7. Has the product been tested with any real-world development teams or organizations?