AgentGraph - Graph-based Context Management

Visualize, checkpoint, and fork your LLM agent conversations

AgentGraph - Proof of Concept

AgentGraph is a quick, vibe-coded tool that I built to illustrate my vision for solving a problem I keep running into while using Claude Code. The idea generalizes to other LLM providers as well. I have no idea whether a tool like this already exists—I just wanted to express the vision, and maybe hear what others think.

The Problem

I’m a big fan of LLM agent models, and I’ve been using them heavily since they first appeared. Through that daily use, I’ve noticed that tools like Claude Code don’t quite scratch all my itches—and while I appreciate the simplicity of the terminal, there’s a real problem with state management and session poisoning.

Often when I’m using Claude Code, a single prompt comes back with several points of interest at once—and I have no clean way to tackle each of them while still keeping track of my work.

The Stone Age Solution

If the multiple points of interest are manageable, I usually go with an approach like using quotes (>).

I quote a phrase Claude Code produced and then write my response or feedback beneath it. This works nicely for shallow stuff—but once you’re dealing with recursive splitting points, once you go further and further into the divide-et-impera of a complex problem, breaking it into sub-problems and sub-sub-problems and so on, it just doesn’t work anymore.

The Bronze Age Solution

When things got more complicated—when the splitting work needed more than quotes (>) could hold, and I had to go deep, in parallel, on more than one topic—a quick solution I used was to ask the agent to handle context saving for me and to tell me how to load it into another session.

It was good for a while. But at some point I noticed the context starting to produce “weird statements”: out of nowhere, the LLM would add random, off-base requirements. The discussion was drifting and I couldn’t understand why—until I “debugged” it and printed out some very unexpected rules.

The Iron Age Solution

There are also the /fork and /branch commands, but they're fairly limited when it comes to depth, management, and so on.

The Modern Solution

A visual graph of conversation checkpoints that lets you mark diverging points and move back and forth to tackle problems separately, in depth.

You start from the Root node—the initial one—where you’ll mostly keep the opening conversation: the big plan you want to implement.

Once you feel the discussion is about to split into two (or more) different directions, you can create a checkpoint—a point in time—where you take one of those threads and focus on it alone in its own session. And the forking is unlimited: you can fork as much as you want. Say a new session raises further points you want to handle separately, in isolation—that way, messages tied to one topic don’t spoil the context for the others you’re trying to solve.

There’s also a cost advantage. Trying to solve everything in one place means you keep growing a single context—most of which is useless for any given point, and more expensive to process.

And some points may call for different models. Some are simple questions that Haiku can handle; others are hardcore problems that need Opus.

Bonus

You don't have to blend unrelated concerns in the same graph. Say you want to focus on a product made up of multiple services, while also working in parallel on some non-technical things—you're covered. You can keep separate tabs, each holding its own graph, with a clean separation of concerns.

Conclusion

There's a lot of potential in applying divide-et-impera with LLM agents—but with the current tools (that I'm aware of), there's also a lot of friction in actually doing it. At some point, the terminal interface may simply not be able to offer the kind of tools we need to work with this technology.