The Collapse of Linear History

Why Undo/Redo Fails in the Age of AI

The Problem: Undo/Redo Was Built for a Different Era

The undo/redo mechanism—one of the most fundamental user interface conventions—is breaking down in the age of AI. Built for a world where one person edited one document at a time, it assumes a simple linear model that no longer matches how we work.

Today, multiple agents (humans, AI, collaborators) simultaneously edit shared documents. The linear stack model that powers traditional undo/redo becomes not just inadequate, but actively harmful to user experience.

This essay demonstrates why this breakdown is inevitable, shows the technical depth where it breaks, and proposes two UX solutions that can restore user control.

Hello, this is Nils 👋. My research is part of ongoing work at Legit, where we're building infrastructure for AI collaboration with control. If you're working on similar challenges in design, engineering, or product development, I'd love to hear your thoughts.

Why Stacks Work: The Foundation of Good Undo/Redo UX

The Linear Stack Model

Traditional undo/redo systems work because they implement a simple, elegant stack:

javascript
1
2
3
4
5
6
7
// Traditional undo stack
const undoStack = [operation1, operation2, operation3, ...];

// When user presses Ctrl+Z:
const lastOperation = undoStack.pop();
const inverseOperation = lastOperation.getInverse();
inverseOperation.apply();

This creates predictable UX because:

• One user, one timeline: Clear "last operation"
• Sequential operations: Each undo moves backward in time
• Atomic changes: Each operation is self-contained

The stack model works perfectly when one person edits one document. Users can predict exactly what will happen when they press Ctrl+Z.

Why We Need Graphs: The Multi-Agent Reality

The Problem: Multiple Agents, Multiple Timelines

Modern collaborative software operates under fundamentally different constraints:

javascript
1
2
3
4
5
6
7
8
9
// Concurrent operations from multiple agents
const operations = {
  user: [op1, op2, op3],
  ai: [op4, op5],
  collaborator: [op6, op7, op8],
  background: [op9]
};

// When user presses Ctrl+Z: which operation to undo?

The stack model cannot resolve this ambiguity because it conflates temporal order with causal responsibility. In a multi-agent system, the "last operation" may not be the operation the user wants to undo.

Where UX Breaks: The Attribution Problem

Consider this scenario:

1. User edits paragraph A
2. AI rewrites paragraph B
3. User edits paragraph C
4. User presses Ctrl+Z

User expectation: "Undo my paragraph C edit" System behavior: "Undo the AI's paragraph B rewrite"

This creates a trust breakdown because the user loses the ability to predict system behavior.

The Technical Depth: Why Redo Becomes Impossible

While undo navigation is complex, redo becomes fundamentally impossible in graph-based systems:

schematic
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Graph State After Undo:
    A (user edit)
   / \
  B   C (AI edit) ← UNDONE
  |   |
  D   E (collaborator edit)
  \   /
    F (merge)

Question: What should redo do?
- Redo the AI edit (C)?
- Redo the collaborator edit (E)?
- Redo the merge (F)?
- Redo along which path?

The Fundamental Issue: Redo assumes a linear future, but graphs have multiple possible futures.

Two UX Solutions: How to Make Graphs Work

The technical foundation exists—version control systems have proven graph-based history works. The challenge is translating these concepts into intuitive user interfaces.

Solution 1: Multi-Path Undo Systems

Concept: Each agent (human, AI, collaborator) maintains a separate undo path that syncs when reviewed.

How it works:

• User presses Ctrl+Z → only undo user operations
• AI changes stay in a separate layer until reviewed
• Collaborator changes are clearly attributed
• Users can selectively undo by agent type

UX Benefits: Users maintain personal control while benefiting from AI assistance.

Solution 2: Visual History Graphs

Concept: Every change becomes a node in an interactive graph. Users can hover to see attribution and roll back to any branch.

How it works:

• Timeline shows change flow and branching
• Hover states reveal change context and reasoning
• Users can navigate to any point in history
• Merge conflicts are clearly visualized

UX Benefits: Change becomes a story, not a dump. Users understand causality.

Conclusion

The linear undo/redo model, while elegant in its simplicity, is fundamentally incompatible with the multi-agent, concurrent nature of modern software systems. As AI becomes increasingly integrated into creative workflows, we must adopt graph-based history models that make causality explicit and enable granular control.

The technical solutions exist—version control systems have proven the viability of graph-based history. The challenge lies in translating these concepts into intuitive user interfaces that maintain the simplicity users expect while providing the control they need.

This is not merely a technical problem, but a fundamental shift in how we think about human-computer interaction. The tools that succeed in the AI era will be those that make every action legible, every change attributable, and every decision reversible.

The future of creative tools depends on our ability to design for trust through transparency—and that future begins with reimagining the most basic interaction pattern in computing: undo.

This research is part of ongoing work at Legit, where we're building infrastructure for AI collaboration with control. If you're working on similar challenges in design, engineering, or product development, I'd love to hear your thoughts.