Graphene - Decision Provenance Graph

The description states that Graphene is a memory and guardrail layer for coding agents, designed to address agent drift — where an agent contradicts itself over time. It records all actions taken by an agent as a graph, including goals, decisions, attempts, failures, and fixes.

It uses typed edges in the graph to represent causal relationships between events. Before executing any action, the system checks proposed actions against historical data using one of three verdicts:

• allow — no conflict
• warn — previously failed attempt
• block — contradicts prior decision

A dashboard displays both guarded and unguarded versions of tasks so users can see what was caught by the guardrail. The system also supports a live chat mode where real models are run through the same guardrail.

The backend is built with FastAPI, storing runs in SQLite and replaying them on startup. The frontend uses React + Vite + TypeScript, leveraging React Flow for visualization. An adapter allows integration with either scripted scenarios or real LLMs.

Inference This is a proof-of-concept or early-stage prototype, not yet a commercial product, based on the lack of any mention of customers, revenue, or deployment details.

The authors claim that coding agents often contradict themselves, and that this contradiction stems from lack of memory rather than intelligence. They state that conversation history stores what was said but not what was decided — which is a key distinction in their positioning.

They also assert that the system’s guardrail logic is based purely on string processing, without models or embeddings, ensuring consistency and explainability.

Inference The positioning has evolved from a general problem (agent drift) to a specific solution (decision provenance graph), with emphasis on consistency over recall, and human-readability of verdicts.

The description does not explicitly name target customers or define an Ideal Customer Profile (ICP). However, it implies that the primary users are likely:

• Developers working with coding agents
• Teams building or deploying AI-powered development tools
• Organizations using LLMs in code generation workflows

It also suggests a developer-focused audience, given its technical nature and integration into coding environments.

Inference The ICP appears to be developers or engineering teams who are currently experimenting with or implementing coding agents, particularly those concerned with agent reliability and consistency.

There is no evidence of pricing, business model, monetization strategy, or revenue streams in the provided description. The project is presented as a hackathon submission.

Inference No commercial structure has been established yet; this remains an experimental tool.

The system uses:

• FastAPI backend
• SQLite for storage
• React + Vite + TypeScript dashboard
• React Flow for graph visualization

Key technical decisions include:

• Shared rule module between backend and mock to ensure parity
• Parity tests to validate behavior consistency
• Real-time reasoner server-side execution instead of inference from graph shape
• No sample mode in the dashboard — all content comes from actual runs

Inference The architecture shows attention to correctness, reproducibility, and developer experience. It is likely built for internal use or demonstration rather than production deployment.

There is no evidence of traction, such as:

• Customers
• Revenue
• Product adoption
• User engagement metrics
• Deployment in real-world environments

The project is described as a hackathon submission and lacks any indication of ongoing development or market presence beyond the authors' own work.

Inference This is an early-stage prototype with no demonstrated traction or maturity in terms of user base, product-market fit, or commercial viability.

There is no mention of competitors or competitive landscape in the description. The authors do not reference existing tools for managing agent consistency or decision graphs.

Inference No competitive context is evident from the description alone. This may be a niche area with limited prior art, or it could be an emerging space where Graphene might be positioned as a novel solution.

• No commercial traction or revenue: The project is described only as a hackathon submission.
• Unproven scalability: The system uses SQLite for storage and FastAPI backend — not optimized for large-scale usage.
• Limited scope: Currently focused on guardrails, not full agent orchestration or execution.
• Developer-centric focus: May not scale beyond niche developer use cases without broader market alignment.
• Lack of external validation: No third-party reviews, user feedback, or independent assessments.

Inference The risk is high that this remains a prototype with no clear path to commercialization or widespread adoption.

1. What specific use cases have you identified for Graphene beyond the hackathon demo?
2. Have you tested the system in real-world coding agent workflows, and if so, how did it perform?
3. How do you plan to scale beyond SQLite and FastAPI for production environments?
4. Are there any plans to integrate with popular IDEs or development platforms?
5. What is your roadmap for monetization or commercial viability?
6. Have you considered how the guardrail logic might evolve as agent capabilities increase?