RESONANCE

Inspiration

The project grew out of a tension I had been carrying for some time. Through my earlier work on verifiable computation, particularly systems involving directed acyclic graphs for provenance and lightweight proof structures, I became increasingly aware of a gap: most generative AI interfaces still treat reasoning as a linear transcript. Even sophisticated tools for attaching semantics to computational artifacts tend to operate after the fact. I wanted to explore what it would mean to make the structure of reasoning itself the primary, interactive object during generation. Not just recording thoughts, but allowing them to be inspected, revised, and branched while the model is still in the loop. The moment I realized that editing an early assumption could visibly affect downstream nodes and mark prior paths as stale, the direction became clear. RESONANCE began as an attempt to give Codex sessions the same kind of revisability and cumulative structure that source control gave to code.

What RESONANCE does

RESONANCE turns Codex sessions into interactive, visual graphs of reasoning. Instead of producing a linear chat history, the system materializes each interaction as a network of typed nodes: Goals, Assumptions, Generation strategies, and Results. Users can inspect the structure of their reasoning, directly edit any node, and create new branches by revising earlier decisions. When a node is edited—particularly an assumption—the system generates a revised branch while marking affected prior paths as stale. Influence weights w_i \in [0,1] on each node make the relative importance of different parts of the reasoning visible. The result is a living graph that supports exploration, revision, and cumulative development of ideas rather than one-shot prompting.

How we built RESONANCE

I built RESONANCE almost entirely through iterative collaboration with Codex. After establishing the core data model, I used Codex to generate the frontend, the graph rendering logic, the branching mechanism, and the state management for stale nodes. The architecture centers on a lightweight graph engine. Each node v_i carries a semantic type, textual content, an influence weight w_i \in [0,1] , lineage references forming a directed acyclic graph, and a staleness flag. When a node is edited, the engine traverses affected downstream paths and updates node states according to a simple propagation rule based on the influence weights. The interface was built as a responsive web application with an interactive canvas, allowing users to pan, zoom, and directly manipulate nodes. Most of the visual and interaction logic, as well as the structured output parsing from Codex, was produced through focused prompting sessions.

Challenges we ran into

The most persistent challenge was scope. It is easy to imagine a fully causal, real-time system in which every edit instantly regenerates downstream content with perfect coherence. In practice, I had to make careful trade-offs between expressiveness and what could be reliably delivered within the available time. The current implementation prioritizes making structural change visible over perfect semantic regeneration. Another difficulty was visual clarity. As branches multiply, the graph can quickly become difficult to read. I spent considerable effort on visual hierarchy, stale-state signaling, and interaction patterns that help users maintain orientation even as the reasoning structure evolves. Finally, there was the conceptual challenge of differentiation. Because I already work with graph-based provenance systems, it was tempting to fall back on familiar patterns. The breakthrough came when I stopped trying to extend existing provenance tools and instead focused on the live, generative, assumption-editing loop. That shift is what made RESONANCE feel like a distinct direction rather than an incremental improvement. In the end, the project reinforced something I have observed across multiple domains: the highest-leverage interfaces are often those that make previously implicit structures explicit and manipulable. RESONANCE is my first attempt at applying that principle directly to generative reasoning.

Accomplishments that we're proud of

We are most proud of creating a working, interactive system in which editing an earlier node visibly produces a new branch and marks outdated paths as stale, all within an extremely compressed timeline. Being able to move from concept to a deployed, playable prototype that demonstrates live structural reasoning in under two days feels like a meaningful achievement. We are also proud that the system already allows users to experience the shift from linear prompting to cumulative, forkable reasoning without requiring them to understand the underlying graph mechanics. Finally, we take pride in successfully differentiating the project from our own prior work in verifiable computation. Instead of extending existing provenance tools, we focused on the live, generative, assumption-editing loop, which gave RESONANCE a distinct character and direction.

What we learned

Working on this project forced me to confront how much of high-quality reasoning is actually implicit. In conventional prompting, assumptions, constraints, and success criteria are often buried inside a single block of text. By externalizing them into distinct node types, I discovered how much clarity emerges simply from making these elements first-class and editable. I also learned that branching is more powerful than I initially expected. When a user changes an assumption, the system does not merely update text. It creates a new lineage while preserving the old one. This small mechanism transforms the experience from “trying again” into “exploring alternatives.” The visual representation of stale versus active paths turned out to be surprisingly effective at communicating the consequences of conceptual change. Technically, I gained a deeper appreciation for the difference between static provenance graphs and live, generative ones. The former records what happened; the latter must also support ongoing causal influence. This distinction shaped many of the design decisions around node state and influence propagation.

What’s next for RESONANCE

In the near term, we plan to strengthen the causal connection between nodes. Currently, editing an assumption creates a visible branch and marks paths as stale, but the system does not yet regenerate downstream content in a semantically coherent way. Our next priority is to improve propagation so that changes to earlier nodes can meaningfully influence later generations while preserving user control over which branches to pursue. We also intend to improve visual and structural clarity as graphs grow more complex. This includes better support for comparing branches side by side, clearer lineage visualization, and mechanisms to collapse or summarize less relevant paths. These improvements are necessary if RESONANCE is to remain usable as reasoning sessions become longer and more branched. Looking further ahead, we see RESONANCE as a foundation for more trustworthy and cumulative forms of generative work. By treating the structure of reasoning as a first-class, editable object, the system opens possibilities for collaborative reasoning, versioned thought processes, and interfaces in which AI agents operate within explicit, auditable graphs rather than opaque conversations. Our longer-term ambition is to explore how this approach might extend beyond individual use into shared reasoning environments where multiple participants, both human and artificial, can contribute to and revise a common structure of thought over time. In essence, we see RESONANCE not as a finished tool but as an early step toward interfaces that treat reasoning itself as something that can be seen, edited, branched, and accumulated.

Built With

• ai-agents
• causal-systems
• codex
• generative-ai
• interactive-graphs
• next.js
• openai
• react
• react-flow
• real-time-reasoning
• tailwind-css
• thought
• typescript