Introducing Plain

One source,every view.

A document system built for humans and AI agents. No hidden state. No drift. Everything you see is everything there is.

1

What if your deck, doc, and sheet were not three files, but three windows into the same document?

Today they are three formats, three parsers, three failure modes. Plain makes them one.

The cost of format sprawl

3×
Files per project
doc + deck + sheet, each edited separately
74%
Of agent errors traced to format drift
from our 2025 pilot across 40 projects
6+
Formats an agent must parse
docx, pptx, xlsx, markdown, JSON, PDF…
The problem

An agent that edits documents is only as reliable as its ground truth.

01
Binary blobs hide meaning
An agent cannot see intent inside a .docx — it sees XML noise. Every edit is a guess mapped through a parser that was not built for reasoning.
0
visibility into structure
02
Each view forks reality
The doc says one thing, the deck says another, the sheet says a third. Three sources of truth means three sources of lies.
3
competing states
03
An agent's edit is a black box
Without a readable source, you cannot diff — you cannot trust. So the human re-reads everything, and the point of having an agent collapses.
100%
human re-verification
A document an agent cannot read is a document an agent should not edit.
— Plain engineering notes, 2025
The fix

Plain text is the one format an agent can hold in its working memory.

1
No more parsers
An agent reads a Plain file and sees exactly what a human sees — headings, cells, slides as typed structure. No speculation about what the file 'means'.
2
Diffs are honest
A Plain source diffs line-by-line. The agent's edit is a visible, reviewable change — not a blob swap.
3
Rendered views are derived
Deck, doc, sheet are generated from the same source. Edit once, see it everywhere — with no sync step to forget.

One model, three views

D
Deck
Slides are sections with an order. The same Plain source can reflow into a doc's narrative outline.
O
Doc
Prose is just content blocks. What renders as a slide in deck mode appears as a headed section here.
S
Sheet
Tabular blocks stay tabular. Formulas are plain-text expressions — readable by an agent, executable by a renderer.
Under the hood

How Plain keeps views in sync

  1. Edit
    One edit to the Plain source
    a cell changes, a heading moves, a list grows
  2. Derive
    Each view recomputes from source
    no stored state in the view — only the source is authoritative
  3. Verify
    Diff shows exactly what changed
    human or agent can inspect the line-level delta before accepting

Plain vs. traditional files

Traditional (docx + pptx + xlsx)
  • Three separate files with separate formats
  • Agent must parse binary XML to reason
  • Edits are opaque — cannot trust without re-reading
  • Sync between views is manual and always late
Plain
  • One plain-text source file
  • Agent reads the same structure a human does
  • Every edit is a reviewable line-diff
  • Deck, doc, sheet are derived, never divergent
Next steps

Try Plain with one real document.

Open a deck you care about. Watch an agent edit it — and read the diff. That is the whole pitch.