Forkpoint

Inspiration

AI agents can call tools, inspect files, modify code, and make many decisions before a task finally fails. Traditional logs show what happened, but they rarely reveal where the agent first went wrong. Forkpoint was inspired by Git branches and game save points: locate the exact decision where the outcome diverged, correct the context, and explore what should have happened next.

What it does

Forkpoint is a causal debugger for AI agents. It imports a normalized JSON execution trace and transforms it into an interactive timeline and decision graph.

Forkpoint identifies the earliest unsupported assumption, highlights the evidence that contradicted it, and shows how the mistake propagated through later tool calls, file changes, and test failures. A developer can then edit the context at that Forkpoint and generate a corrected alternative execution plan.

The included constrained replay demo safely verifies a corrected branch and demonstrates the result changing from Failed to Passed.

How we built it

Forkpoint is built with Next.js, React, TypeScript, Zod, Vitest, and the OpenAI Responses API.

GPT-5.6 performs structured causal analysis across the trace. It identifies the first unsupported assumption, references supporting evidence, estimates confidence, explains downstream propagation, and proposes an alternative execution plan.

Codex was used throughout development to implement the application, inspect repository state, verify file changes, run tests, diagnose failures, and validate the constrained replay workflow.

The public demo intentionally uses a deterministic built-in trace, so judges can experience the complete workflow without consuming API credits. Live GPT-5.6 analysis of custom traces was tested locally with a protected temporary API key.

Challenges we ran into

The hardest challenge was distinguishing the first causal mistake from the final visible error. A compiler or test failure may only be a downstream symptom of an unsupported assumption made much earlier.

We also needed to make replay safe and honest. Forkpoint never executes arbitrary model-generated shell commands. Custom traces produce a corrected plan, while executable verification is limited to a controlled built-in fixture.

We added explicit paid-API confirmation, request deduplication, cooldown protection, structured output validation, sanitized errors, and strict secret handling.

Accomplishments that we're proud of

We completed an end-to-end agent-debugging workflow:

Validated JSON trace import
Interactive execution timeline
Causal decision graph
First-error identification with evidence
Error-propagation visualization
Editable corrected context
Alternative branch generation
Constrained Failed-to-Passed verification
Public demo, documentation, and automated tests

What we learned

Agent debugging requires causal analysis, not merely log summarization. The most important event is often not the final error, but the earliest decision made without sufficient evidence.

We also learned that AI-generated debugging becomes much more trustworthy when every conclusion references trace evidence and execution is separated from model-generated planning.

What's next for Forkpoint

Next, Forkpoint could support native Codex session exports, traces from additional agent frameworks, authenticated team workspaces, repository snapshots, multiple competing replay branches, and sandboxed verification against real project checkpoints.