Introduction

Today's AI tools present conversations as long, linear threads. You type; the model replies; the history scrolls upward in a single list. If you want to explore an alternative idea, you scroll back or create a new thread. Over time your workspace fills with dozens of disconnected conversations that all began from the same starting point.

This linear experience hides the true structure of thinking.

NIT gives that structure a name. It introduces logs, timelines, and branches, so exploration becomes visible, navigable, and reproducible.

This document defines the conceptual foundations. A separate document will explain how NIT works in practice.

As of now, this is document describes the plan for nit, defining the concept and how it works. There is no reference implementation that is generally available. As this comes online, this documented will be updated. This has been published with the intention to inspire those developing command-line tools for AI, so that they will consider upgrading from a simple history to something more powerful.

Conversation Logs

A conversation log is an ordered sequence of turns, where each turn contains:

• a prompt
• a response

This pair is the atomic unit of AI work. Each turn depends on all turns before it. Conversation logs are sequential, contextual, and immutable.

Every chat interface already generates a log. NIT treats it as a real object with structure.

Message Arrays

Every LLM operates on a message array: a flat list of messages with roles and content.

[
  { "role": "user", "content": "..." },
  { "role": "assistant", "content": "..." }
]

A message array has no concept of branching, alternatives, or versions. It is a serialization of the past, not a map of possible futures.

NIT sits above message arrays. A message array is only one view of a deeper object: a timeline.

Timelines

A timeline is a single linear path through a conversation log.

*--*--*--*--*
1  2  3  4

Timelines represent one coherent version of a conversation. They are append-only: you move forward with new turns or navigate backward without modifying history.

A typical chat thread is just a timeline.

Branches

A branch is a new timeline that diverges from a specific turn in an existing timeline. It inherits the past up to a fork turn and then proceeds independently.

main timeline:  *--*--*--*--*
                       ^
                       fork
branch:                \--*--*--*

Branches allow exploration of alternative futures without losing shared context.

Threads vs Branches

Chat tools treat a thread as a single long timeline. If you want different directions, you create multiple threads.

NIT redefines this:

• A thread is a container for related work.
• A branch is a timeline inside that container.

Instead of scattering variants across multiple threads, NIT keeps everything together:

Thread A
  trunk:
    *--*
  idea-1:
    *--*--*
  idea-1-refinement:
    *--*--*--*

A thread becomes a structured workspace instead of a single scrollback.

Multiple Timelines: A Concrete Example

A traditional chat thread might appear like this:

Post 1
Post 2
Post 3
Post 4
Post 5
Post 6
Post 7
Post 8

Under NIT, the actual structure could be:

Thread A
  trunk
    Post 1
    Post 2

  branch-1
    Post 3
    Post 4
    Post 5
    Post 6

  branch-2
    Post 7
    Post 8

This thread contains three timelines:

Timeline: trunk

Post 2
Post 1

Timeline: branch-1

Post 6
Post 5
Post 4
Post 3
Post 2
Post 1

Timeline: branch-2

Post 8
Post 7
Post 2
Post 1

Each branch shares the same past but explores a different future.

Where the Next Post Goes

It depends on the active branch.

> nit switch branch-2

The next post goes after Post 8.

> nit switch branch-1

The next post goes after Post 6.

Branches determine timelines. Timelines determine context. Context determines model behavior.

Time Operations in NIT

Timelines give you a way to manipulate time in a conversation.

Time Jump

Append a new turn to the current timeline.

before:  *--*--*--*--*
after:   *--*--*--*--*--*

Rollback (realistic: rollback + new branch)

When a conversation goes off the rails, you roll back to a safe point and immediately begin a clean new branch.

main timeline:  *--*--*--*--*--*
                       ^
                       rollback point

clean branch:          \--*--*--*

Rollback is undo without deleting history: the old future still exists, but you stop building on top of it.

Time Travel (intentional divergence)

Create a new branch from a past turn to explore a different future on purpose.

*--*--*--*
       \
        *--*--*

Fast Forward

Rollback, change a variable (prompt, settings, or model), and replay the future to see how outcomes change.

original:  *--*--*--*--*--*
rollback:       ^
replay:         \--*--*--*--*

Fast forward is parallel world simulation for conversations.

Why NIT Matters

NIT transforms conversations by giving them:

• structure
• alternatives
• explicit divergence
• comparable timelines
• reproducible reasoning
• clean context control
• a workspace for experimentation

It turns a single-threaded chat into a structured exploration environment.

A companion document, "How NIT Works," will walk through commands and usage.

More by the author

How I Built a Time Machine