oMyTree - Capture AI process assets

Large language models are getting more capable every month.
But the way we talk to them hasn’t really changed.

Most of the time, an “AI conversation” still looks like a long vertical chat. We scroll, and scroll, and scroll. Somewhere above there was an important answer, a key assumption, a side question that turned out to matter — but it’s now buried in the log.

We ask models to help us learn, design systems, explore ideas and make decisions. Yet the interface we use was built for quick replies, not for actual thinking.

The models are powerful.
The surface we think on is still flat.

Thinking is a tree, not a line

Human reasoning rarely moves in a straight line.

We start from a root question. We follow one path, then back up and try another. Side ideas appear and turn into their own threads. We compare alternatives, collect examples, park open questions for later.

If you draw that process on paper, it doesn’t look like a chat log. It looks like a tree.

There is a root: what this is really about.
There are branches: different directions, themes, and approaches.
There are leaves: concrete details, snippets, formulas, code, decisions.

Today, most AI tools compress that structure into a single chat column. The tree is there, but it’s invisible. All the paths, detours, and connections exist only as “previous messages”. We can’t see how we got from the first question to the current answer.

We’re asking models to help us reason, but we’re viewing that reasoning through a keyhole.

A different surface for thinking

oMyTree started from a simple question:

What if AI conversations could grow into something you can see and navigate, instead of just scroll past?

Instead of treating a conversation as a flat list of messages, oMyTree lets it unfold as a living tree:

Each meaningful turn becomes a node.
Related ideas form branches.
You can return to any node and continue from there, creating a new branch.
Over time, you get a visual map of how an idea developed.

You’re still talking to a model. But you’re also building a structure you can come back to: not just what you discussed, but how your thinking evolved.

Seeing a conversation as a tree

In oMyTree, a node is more than a message bubble. It’s a small piece of reasoning you can inspect, return to, and grow from.

Clicking a node reveals its full context: the question that created it, the model’s response, and any summaries or notes you’ve added.

Paths matter as much as nodes. When you’re trying to understand how you got somewhere, you can follow a highlighted route from the root question through each branch to a particular conclusion. Other branches stay in the background, ready to be revisited.

Instead of a single endless thread, you begin to see:

where the main line of thought actually is
which questions became side explorations
what you decided to keep, and what you set aside

The conversation stops being ephemeral. It becomes a map.

Working with AI at the scale of real work

Making structure visible doesn’t change what the model can do. It changes what you can do with it.

oMyTree is built for people who live with AI every day — for long-form learning, complex planning, multi-step analysis and ongoing projects. That’s why a few practical details matter.

You can favorite important replies as you go. A single click pins a response as a “keystone” in the tree, so you can jump back to it without hunting through history. Over time, a tree becomes a mix of exploration and anchors: the moments that actually changed your mind, or moved the work forward.

You can bring your own API keys for multiple model providers. oMyTree is designed around the idea that different models are good at different things, and that serious users often work with more than one. You connect the providers you trust, and choose which model to use while staying inside the same tree.

Because the structure lives above any single provider, you can switch models while keeping context. Explore a branch with one model, then continue from the same node with another, without starting over. The tree remembers the conversation; you decide which engine drives it.

Not every task needs the same amount of context. Sometimes you want the model to see the whole path; sometimes you want a very narrow window. oMyTree lets you tune how much of the surrounding tree is fed back into the model, so you can keep small tasks focused and give bigger investigations the context they deserve.

And trees don’t have to stay locked inside the product. You can export a tree, keep it as a snapshot, share it with collaborators, or bring it into your own tools. Later, you can import it back and continue growing from where you left off.

Branches can be pruned when they’re no longer helpful. Deleting a branch doesn’t rewrite history; it simply keeps the structure honest and workable, so large trees remain something you can actually navigate, not just admire from afar.

These are small pieces, but together they support a simple goal: to make oMyTree a place where you can do real work with AI, not just have one-off conversations.

Early patterns we’re seeing

Some of the first use cases we designed for:

Learning something new.
You start from a core question, branch into definitions, examples, counter-examples and edge cases, then come back later and review the whole tree as a compact, structured summary of what you learned.

Designing or debugging systems.
Architecture discussions, trade-offs, alternative designs and rejected options can each live on their own branches. The main branch holds the decisions; the side branches preserve the paths you didn’t take — and why.

Planning and reflection.
Goals, constraints, risks, and scenarios can be explored as parallel branches instead of mixed into one thread. Looking back, you see not just the plan you chose, but the landscape you navigated to get there.

These patterns aren’t fixed. We expect them to change as people bring oMyTree into their own workflows and combine it with their own models.

What oMyTree is — and what it isn’t

oMyTree is a visual thinking layer on top of large language models. It’s a way to organize conversations as trees of ideas, so that complex work with AI stays clear, navigable, and revisitable.

It is not a replacement for thinking, or a promise that the model will always be right. The goal is simpler, and in some ways more ambitious: to give your reasoning a shape you can see.

We want AI to be more than a stream of answers.
We want it to be a place where your thoughts can grow.

Growing with us

oMyTree is still young. The core idea is in place: turn linear chats into living trees of thought, and let people move through them as easily as they scroll today.

From here, we’ll keep refining:

how trees grow as you talk
how summaries, timelines and lenses make large trees easier to understand
how importing, exporting and sharing should work when what you share is a structure, not just a transcript
how multiple models can cooperate inside the same tree, instead of living in separate tabs

If you care about reasoning, learning, and staying oriented in long-form work with AI, we’d love for you to join us early — whether that means trying the beta, sharing feedback, or simply following along as the product evolves.

This is one step toward a different kind of interface for thinking with machines.
We’re building it in the open, and we’re just getting started.