[paldepind2]

Can you go more in depth on why LLM conversations should branch reddit-style? That doesn't seem immediately clear to me, and I'd be afraid that the different branches would step on each others toes? (also I'm assuming what you're describing here goes beyond the "fork" feature found in many agent harnesses).

[julesrms]

An agent like claude might run a subagent (e.g. to fetch and summarise a web page, or explore a code question) as if it's a tool, so you can't really see what's going on inside it. Juggler makes these sub-threads part of the overall structure, so you can navigate into them.

Another really elegant thing that pops out of subthreads is that to do a compaction, you simply move the entire conversation into a subthread, and let the subthread summarise itself (which they do anyway). So we get compaction as part of the architecture, and you can also dig into that old thread if you need to revisit any of it

[paldepind2]

Ah, ok. Visibility into subagents makes perfect sense. From the "reddit-style" description I was imagining something where the user was conversing non-linearly with the agent at different points in some big tree.

[gnarlouse]

Honestly even just a bookmarking system would go a long way to fix the problem, but getting "off-topic" in LLMs (3 years later and trillions of dollars of investment) still ruins my flow entirely. I end up playing an unwanted game of scrollbar warrior jumping back and forth between two points in chat. Could be that I'm studying a textbook and looking to enhance/check my understanding with Claude, or that I'm working on complicated tasks in my codebase. Side tangents always crop up. LLMs don't handle it well. Blows my mind that it doesn't bother anybody else, perhaps IATAH

[copperx]

You can go off topic and just rewind the context or edit it and delete the off topic messages. Not all harnesses let you do this as easily as you should.

If the off topic messages change files, then it's a bit more complex.

[kosolam]

Lol

[gnarlouse]

The best example that comes to mind is orthogonal "thread pulling," and the fact that it's not immediately evident that you'd want to do it like this, makes me wonder if I'm the weirdo.

Say you're studying something: STEM topics, Liberal arts topics, a codebase, a textbook, etc XYZ. You're in the flow of discussing a main topic. Invariably, the main topic is built on top of atomic subelements. For example, discussions about Bonds invariably invoke discussions of Present Value, Yield to Maturity.

The branching is because you have a side query that is a potentially unbounded stack of "wait, but why this?" You highlight a segment of text in the current chat, click a button that pops a new conversation over to the right, and continue your "related but off-topic question." You have both context threads in view at once: the main topic & the side topic. You should be able to do this N layers deep.

The alternative is that you get to play scrollbar warrior in the current regime of LLM-designs. It's not really conducive to deep understanding.

This kind of conversation applies naturally to software development too: "wait, so we're working on feature X/refactor X/bugfix X, but that requires us to answer this subthread. And sure these days Claude Fable can probably do it all with the right harness, but does that mean you _understand_ what it just did?