Checkout Execution Run
Homepage
Real GPT 5.6 agent run - complete task node
Checkout Execution Branch Re-run
Insufficient Evidence Run
Real GPT 5.6 agent run

Prism — The trust layer for AI agents

AI agents are getting really good at doing work. They can search the web, call tools, debug code, and investigate issues. But after they're done, you're usually left with one of two things: a final answer or a huge transcript.

Neither is great.

As a developer, I don't just want to know what the agent concluded. I want to know how it got there, whether the evidence is actually good enough, and whether I'd trust it before taking action.

That's why I built Prism.

Prism turns an agent run into something you can actually review. Instead of scrolling through messages, you get an interactive Execution Story with a timeline, execution graph, replay, and step-by-step inspection. More importantly, every major recommendation comes with a Decision Proof that shows exactly which pieces of evidence support it, what alternatives were ruled out, and how well that conclusion is actually verified.

What inspired me

This project came from something I kept noticing while building AI agents.

Modern agents are becoming surprisingly capable, but reviewing their work still feels like reading chat logs. A confident-looking answer can sometimes be based on a single weak observation, and it's hard to tell the difference without manually retracing everything the agent did.

I wanted something that made reviewing an agent feel more like reviewing code or reading a trace—not guessing whether the final answer sounds convincing.

What Prism does

With Prism you can:

Replay an entire agent run as an Execution Story instead of a chat transcript.
Inspect every recorded step, including prompts, tool calls, inputs, outputs, latency, tokens, and model information.
Visualize the execution using a React Flow graph with causal and evidence relationships.
Review a Decision Proof explaining why an agent made a recommendation.
Challenge individual pieces of evidence and immediately see the verification level update.
Run a Proof Stress Test that removes each evidence link one at a time to identify which ones are critical and which ones don't actually matter.
Branch an investigation under a different assumption and compare both execution traces.
Prevent actions when the remaining evidence is no longer strong enough to justify them.

For the demo, Prism investigates a drop in EU checkout conversions.

The agent follows the problem from the initial alert, through release comparisons and error logs, until it reproduces the root cause: a GB checkout is sending UK instead of the ISO country code GB.

That reproduction becomes the strongest piece of evidence in the proof.

If you challenge it, the recommendation immediately changes from Auto-safe to Human review required. There's also a second scenario where the agent only has weak signals, and Prism refuses to approve the action altogether.

How I built it

Prism is a local-first application built with:

Next.js 15, TypeScript, Tailwind CSS, React Flow, and Framer Motion for the frontend.
FastAPI, Python, SQLite, and local JSON artifacts for storing and serving traces.
A provider-agnostic trace format for runs, events, tool calls, analyses, proofs, approvals, and branching.
The OpenAI Agents SDK with GPT-5.6 Terra and web search for recording real agent executions.
GPT-5.6 to generate concise explanations and Decision Proofs, while restricting every claim to real events from the recorded trace.
Deterministic rules—not model confidence—for action gates and proof stress testing.

I also used Codex throughout development to speed up implementation, testing, architecture decisions, and code quality.

Challenges I ran into

The biggest challenge was making sure Prism wasn't just another pretty visualization.

Showing a graph of agent steps is useful, but it still doesn't answer the question I actually care about:

Can I trust this recommendation?

To solve that, I separated explanations from verification.

The model can explain what happened, but every Decision Proof has to reference recorded events. If someone removes or challenges a piece of evidence, Prism recalculates the verification level using deterministic rules instead of simply trusting what the model originally said.

Getting real agent runs working without making the demo unpredictable was another challenge.

I ended up supporting both curated, deterministic demo stories for judging and real recorded OpenAI agent runs using the exact same trace format, so the product works both as a polished demo and as a real developer tool.

What I learned

Building Prism changed the way I think about AI observability.

Seeing what an agent did is only the first step. The harder question is understanding which evidence actually matters, what happens if that evidence turns out to be wrong, and when an agent simply shouldn't be allowed to act.

That became the core idea behind Prism: