Most stories about AI writing for you end at a document. The agent produces a brief, a memo, a summary, a deck. You read it. Maybe you keep it. The story is over.
That ending is fine, and it is also where the genuinely new thing starts to get interesting.
Because a document is a snapshot, true on the day it is made and slightly less true every day after. The useful frontier is an artifact that runs: a dashboard sitting on top of live data, a small tracker the agent keeps current, a tool you open on a Tuesday because it answers a question you have right now, not the question you had last month.
A viewer renders files. A workspace runs them. That is the whole leap, and it is worth walking through slowly.
A page you read once
Start with a worked example, one constructed for these essays but shaped like work people do every week: an agent runs a customer-research pass for a feature called Smart Recaps. Four discovery interviews, different roles, same workflow gap. The raw material landed in the workspace as files: a customers.csv with the four companies and their call times, four transcripts, and a synthesis deck the agent wrote afterward.
The deck is good. It names three patterns across the calls. Length is the enemy. Speed beats depth. Land it in the work tool. It carries the quotes that make those patterns land. "Five bullets. In Slack. By the time I'm out of the building." It ends with a recommendation, pre-drafted follow-up as the wedge.
If you have used a capable agent, you have made things like this. It reads well, it is structured, and it is often better than what most people would have typed by hand. And it has the exact half-life of every document: it is a perfect record of what four people said in May.
Now it is June. Two more interviews happened. Someone asks which roles still have not been covered, and whether the "speed beats depth" pattern held up once sales ops was in the room.
The deck cannot answer that. It is not wrong. It is just finished. To get the new answer you go back to the agent, re-feed the material, and ask for a new deck. You now have two decks that disagree about the truth, and next month you will have three.
This is the ceiling of the document. It is the ceiling that hosting alone never breaks. You can put that deck on GitHub Pages and serve it to the whole company in seconds, and it will still be a snapshot. Pages hosts the file beautifully. It does not run it. The data behind it is frozen the moment it is published. Claude artifacts hit the same ceiling from the other side: the page can be interactive, but nothing it collects survives the session.
The same work, running
Here is the other version, built from the same material.
Instead of leaving customers.csv as a table you look at, the agent loads it into a small SQLite database in the workspace, one row per interview, with the role, the call length, the date, and the patterns each call surfaced. Then it writes a page that does not contain the answers. It asks for them.
The page is plain HTML. When it loads, it calls back to the workspace for the current numbers: coverage by role, total interview time, which patterns have shown up in which calls, how the picture has shifted since the first four. The agent does not hand-write those figures into the markup. It declares a handful of named queries, the page asks for them by name, and the workspace runs the SQL and returns rows. The browser never sees a query, only results. There is no framework in the page, no build step, just a fetch and a render.
That sounds like a small mechanical difference. It is the entire difference.
When the fifth and sixth interviews come in, nobody regenerates anything. The agent appends two rows to the same table. The next time anyone opens the page, the coverage count reads six, the role gaps are recomputed, and the "speed beats depth" pattern now reflects the sales-ops call that either confirmed it or complicated it. The page did not change. The data under it did, and the page simply reports what is currently true.
You stopped reading a record of the research. You started using an instrument that watches the research.
You do not have to take my word for the feel of this. The expenses app in Caipi's public demo workspace is built exactly the way described here: every tile, chart, and table on it is a named query against a SQLite file sitting in the same folder, and you can browse both the app and the raw database without signing up for anything.
Why this is the part that is hard to copy
The reason this matters is that almost everything else in the agent-writing story is becoming a commodity. Many tools can generate a clean deck. Several can render Markdown into something pleasant. A few will host the result on a public URL. None of that is a moat, and Caipi does not pretend it is.
The thing that is genuinely hard to assemble is the loop where an agent owns both halves at once: it maintains the data and it maintains the tool that reads the data, in the same place, over time. The agent that wrote the dashboard is the same agent that keeps the table current. There is no export, no handoff, no second system that has to be kept in sync. The source material and the running surface live together, and the agent works across both.
That is also why "just files in a viewer" undersells it. The dashboard is still made of ordinary parts: an HTML file, a tiny manifest naming the queries, and a SQLite file you could download and open in any tool that reads SQLite. Nothing here is a proprietary container. But sitting together in a workspace that can execute them, those boring parts stop being a document and become a tool. The file is still yours. It just does something now.
From "done" to "open it again"
The real test of any of this is not the moment the agent finishes. Finishing is cheap now. The test is whether you come back.
A document earns one read. You open it, you absorb it, and after that opening it again mostly confirms what you already remember. A running artifact earns a habit. The recaps dashboard is worth opening every Monday because Monday's answer is different from last Monday's. The question "which roles have we not heard from" has a live answer, and the place that answers it is the same place the agent has been quietly keeping current all week.
That shift, from a thing you read once to a thing you reach for repeatedly, is the leap. It is the difference between asking an agent to write you a report and asking it to run you an instrument.
The interesting agent output was never the prose. The prose was the easy part. The interesting output is the small tool that did not exist on Friday, that you open on Tuesday, that knows something today it did not know last week, because the agent has been keeping it true while you were doing something else.
Documents tell you what happened. Tools tell you what is happening. Once the author is an agent and the reader is you, there is no good reason to stop at the document.