Most AI coding agents give you a conversation that works like a typewriter: a single line of text, marching forward. You can scroll up to read it, but you can't really go back — and if you do back up, whatever came after is gone. Try a different approach to a problem and you either start a fresh chat (losing all your context) or keep going and pollute the one you have.
Elyra works differently, and /tree is where you see it. Your session isn't a line. It's a tree. And once you've worked that way, the typewriter feels like writing in pen.
Under the hood, an Elyra session is stored as a tree: every entry knows its parent, and branches happen in place — no new files, no "save as." That sounds like a storage detail. It's actually the foundation for the most freeing way to work with an agent that exists right now.
Here's what it buys you. Every time you rewind, fork, or replay, you don't overwrite history — you branch off it. The path you were on is still there, intact, one keystroke away. /tree is the map of all those paths:
/tree
● Add user registration
├─ Use Lucia for sessions
│ └─ Write the migration
└─ Use a JWT approach ◀ you are here
├─ Add refresh tokens
└─ Add refresh tokens (Haiku replay)
That's not a mockup of a feature we wish we had. That's the session tree, drawn in your terminal, every branch navigable. Pick any node, hit enter, and you're back there — conversation and files restored to that exact moment.
The difference is the difference between exploration and commitment.
In a linear agent, every decision is load-bearing. Asked it to use JWTs and now you're curious about sessions instead? Your options are bad: undo and lose the JWT work, or start over and lose the context that got you here. So people don't explore. They commit early and hope.
In Elyra, exploration is free:
Tried an approach that didn't pan out? /rewind to before it, try another. The dead end stays in the tree — sometimes you come back to it when the "better" idea turns out worse.
Want to compare two designs head to head? Branch, build both, and flip between them with /tree. Two real implementations, side by side, not two vague memories.
Curious whether a cheaper model handles this turn? /replay haiku branches off and re-runs it on Haiku — the original stays put. Now you've got both results in the tree to compare, cost and all.
The typewriter forces you to be sure before you act. The tree lets you find out.
If you've used git, the mental model is instant: most agents give you a single mutable HEAD and no branches — every commit overwrites your working state and there's no git checkout - to go back. Elyra gives you git log --graph for your conversation, with branches you can actually switch between, and a working tree that follows along.
And like git, the value isn't that you'll branch constantly. It's that knowing you can changes how you work. You stop treating every prompt as irreversible. You try the risky refactor, the weird idea, the second opinion — because the escape hatch is always one /tree away.
A few touches that make it pleasant in daily use:
Filter the view. Long sessions get noisy, so /tree filters: everything, user turns only, labeled points only, or hide the tool calls. You see the shape of your thinking without the machinery.
Branch summaries. When you switch away from a branch, Elyra can summarize what happened on it first, so the path you're leaving doesn't become a mystery later.
Double-escape to open it. With an empty input, a quick double-Escape jumps you into the tree (configurable) — navigating your own history becomes a reflex, not a command you have to remember.
/tree shines in long, exploratory sessions — debugging, design, big refactors. For a quick one-shot fix you'll never touch it, and that's fine; it's there when the work gets branchy, not in your way when it doesn't. And branching keeps history, which means long sessions accumulate — but that's what the filters and /compact are for.
Most agents make you treat a conversation like something fragile: don't go back, don't experiment, don't lose your place. Elyra makes it something you can move around in freely — because the session is a tree, every path is preserved, and /tree is the map.
The best ideas rarely come from the first branch you try. An agent that lets you keep all of them, and walk back to any of them, isn't just more convenient. It changes what you're willing to attempt.
Set a goal, try the bold thing, and if it doesn't work — /tree, and you're somewhere better in seconds. Nothing lost. That's gold.
Happy building (and happy branching).