Anthropic's Google Docs killer is almost here

Luka Kladarić · The Chaos Guru ·

13 min read Original article ↗

I was doing some client work today and asked Claude for a dashboard in the wrong workspace. I was expecting an Obsidian dashboard, but instead I got a Claude Artifact listing the open topics on the engagement, each with a severity, a source, how many days it had been open, and who holds the next move.

Standard fare. I’ve made and published dozens of these since Artifacts launched. They’re a very neat tool with some really hard-to-swallow limitations, and I’ve spent the past month fighting them, falling back to GitHub Pages whenever I ran out of options.

But this one had something new... Every single row had an Open / Waiting / Done switch. At the top of the page, a big blue SAVE CHANGES button lit up when I toggled an Open item to Waiting. I pushed Save and not much seemed to change, except that refreshing the page showed the Waiting status had been recorded... somewhere.

Bewildered, I asked Claude how “Save changes” worked.

Apparently, Artifacts can now save a new version of themselves back to the system, to be served on later page loads. OK, neat, and definitely new. I’ve literally been asking for a way to add feedback interactivity to them, so I can fix data classifications and copy mistakes in place.

I got an itch to go digging, so I did. What I found is bigger than a Save button, and as far as I can tell nobody has written about it. Every article on “Claude Code artifacts” I could find still describes a static page with no backend.

An artifact is a single HTML page that Claude publishes to claude.ai. For most of its life it was a picture of work: Claude rendered something, you looked at it, a teammate looked at it. Anthropic’s own launch post calls it “a capture of work, not an application.”

When they say “not an application,” they are not kidding. The page is served to your browser in a way that blocks every external resource. You can’t reference an external image or an external script, and JavaScript won’t get you around it either. A Google Maps embed is denied, and so is fetching data from an open API.

As far as I can tell, that is still true. What changed is that a page can now declare runtime capabilities, and the claude.ai viewer grants them when someone opens it.

The page saves itself. The artifact capability lets the page publish a complete new version of itself. Edits stay in the tab until you hit Save, and Save rebuilds the page with the data embedded and publishes it at the same URL. Every version is kept with its author’s name on it, and every open copy reloads to the new one. If someone else saved first, their version wins and the page reapplies your edits on top as unsaved changes. There is no backend and no deploy step, and the page itself is the record.

The page has a shared realtime database. The db capability gives every artifact its own document store. It holds JSON documents at slash paths, gets created on the first write, and is deleted along with the artifact. You get queries, filters, ordering, and live subscriptions that update every open copy without a reload. Writes are last-writer-wins with no transactions, and a page can take a short lease when one person needs to own an edit.

The access model is unexpectedly serious. Rules set the minimum sharing level per path (can view, can edit, owner), separately for reads and writes. Each viewer gets a private subtree that nobody else can see, “the artifact’s owner included,” unless a rule opens it up. Claude can also read, query and write the same store from a terminal session, in batches if it wants. So an agent in a shell and a human in a browser tab can edit the same live data at the same time.

The page knows who is in the room. The room capability shows who has the page open right now and passes live events between them, such as cursors, selections, or a presenter’s reactions. Nothing in the room persists; that is what db is for. The contract also describes the Claude Code session that published the page joining the room as a peer of its own. It shows up marked as an agent and never takes on a viewer’s identity. That part is behind a flag and off by default.

The page can ask Claude. The sample capability lets the page call Claude on the viewer’s account, with a consent prompt the first time. Answers can stream in or come back as JSON, and the page can hand Claude its own functions to call as tools. You can build a summarize button that really summarizes, paid for by whoever clicked it.

The page uses the viewer’s own tools. Connector calls (mcp) run through the viewer’s own claude.ai connections, so the same dashboard shows each person what their own accounts can see. The page never touches a credential. This is the one capability Anthropic documents in detail.

Files go in and out. assets stores uploads for the artifact, like images, PDFs, CSV and Markdown files. downloads hands the viewer a generated file to save, behind a confirmation they can decline.

Comments reach Claude. On a page shared inside your organization, people can leave comment threads. An editor can send a thread to Claude with the Send to Claude button or an @claude mention. If the Claude Code session that published the page is still running, the comment reaches it right away. Claude reads the thread, replies, and edits the page if the comment asks for a change. Your permission mode decides whether it does that on its own or waits for you, and the reply shows up as coming from Claude “via” you.

Reading that list very much sounds like a deep integration of Claude into Google Docs and Drive. Except Google is nowhere to be found.

Live docs aren’t live for me yet 🥁, but they’re right there in the contract.

A live doc is a new kind of artifact, one “the platform created as a live doc.” It doesn’t have versions at all. Its content is an edit journal, and here is the key sentence, capitals theirs:

On a live doc THE PAGE’S MARKUP IS THE DOCUMENT.

Whatever a writer’s own click, keystroke or drag does to the page gets appended to the document as that viewer: edited text, changed attributes, elements added or reordered, a ticked checkbox, typing in an editable region. The edit reaches every other open view, and it also reaches “the watching Claude session.” When an edit lands, “Claude is told what changed … and typically answers with an edit of its own a second or two later, applied to this view in place.”

The budgets are 524,288 text characters per document, 131,072 elements plus attributes, and 8 MiB rendered. You won’t be group-writing a whole book in one, but it still fits a lot of content.

Two more pieces sit next to it. sendToClaudeSession lets a viewer hand whatever they selected on the page to their own Claude conversation open beside it. It arrives staged as an attachment they can see and remove before anything is sent. The contract also points at a comments capability with its own sendToClaude, for writing a comment and pulling Claude into the thread from inside the page. Then there are artifact types. An artifact made from a type keeps the type’s page read-only and only lets its own files change, which makes it a template system. When I asked for the type catalog, I was told it “isn’t available to” my account yet.

Both let several people edit at once, and live docs journal every edit per writer. Docs shows other people’s cursors, and room does the same. Both have comments, but only one of them routes a thread to a co-author who does the work. Docs keeps revisions, while artifacts keep every version with its author, or a full journal. Docs has templates, and types are on the way.

Then there are two things Docs doesn’t do at all. It has no structured data behind the page, and an artifact has a queryable database with per-path access rules. A Doc also can’t be an app. An artifact is HTML, so the document can be a form, a board, a tracker or a calculator.

Google has been bolting an assistant onto a document, with mixed results. Anthropic is building the document around the assistant, and so far the result is spectacular.

This wasn’t a single launch. It has been piling up, one quiet release note at a time.

2024 to 2025: chat artifacts. Artifacts started as the side panel next to a claude.ai conversation. In June 2025 they learned to call Claude from inside the page. In October 2025 they got persistent storage through window.storage: personal or shared, 20 MB per artifact, and only on published pages. That was real state, but it was a key-value box rather than a database.

June 18, 2026: Claude Code artifacts. Anthropic brought artifacts to Claude Code in beta for Team and Enterprise. The pages “update themselves as your session works,” keep versions at the same link, and are private by default. The launch post also says they are “viewable only by authenticated members of your org and cannot be made public.” VentureBeat covered it as live dashboards. It was a one-way street: Claude wrote and people watched.

July 13: public links and editors. Public sharing arrived, switched off for Team and Enterprise until an Owner turns it on. Editors arrived too, which the coverage called multiplayer. Read the docs closely, though. An editor still publishes by giving their Claude the URL and having it republish, so you get two people and two Claudes working on one page, taking turns.

July 14, v2.1.209: connectors. The next day, Claude Code let a published page call MCP connectors with each viewer’s own login, so a page could show live data instead of a snapshot. It also got its first hard boundary: a connector-backed page can’t have a public link on any plan.

August 4, v2.1.221: comments. Pages shared inside an organization started taking comment threads, and Claude could read them when asked. Public pages still can’t take comments. They say “Comments aren’t available while this Artifact is shared publicly.”

August 11, v2.1.228: comments reach Claude. The session that published a page now watches it. When someone uses Send to Claude or @claude, the comment lands in the running session, which replies and edits on its own if your permissions allow. It handles up to 60 of them per artifact per hour. This was the first time a person on the page could make Claude act without anyone opening a terminal.

August 17, v2.1.234: /design. The design canvas put Claude Design’s editor inside an artifact. You click an element, change it, and, where your account allows it, “Save publishes a new version for everyone.” That was the first public sighting of a page writing itself.

September 10, v2.1.268: the database surfaces. It showed up as a single changelog line: the artifact data-edit permission prompt became “a card that shows the document count and who can open the artifact.” That document count is the first public trace of db I can find. The next day, v2.1.269 let database reads land in the session scratchpad without stopping for approval.

Today: contract 0.2.46. My account has eight capabilities, and the contract already describes live docs, types, agent peers in the room, and handing selections to your own Claude.

Look at the direction of travel. In June, Claude wrote a page. In July, people could open it and their own Claudes could rewrite it. In August, people could talk to the page’s Claude through the page. In September, the page started holding its own data and saving its own state. If the contract is any guide, what comes next is people typing into the page and Claude typing back.

... which I’m sure will be gone tomorrow, or very soon.

It is organization-only. A page that declares the database, assets or connectors is organization-internal and “cannot be shared publicly, so every reader and writer is a signed-in member of the owner’s organization.” Google Docs’ killer feature is “anyone with the link,” and for a consultant that is the whole ballgame. The dashboard I started with lives inside my organization, and the client it’s about can’t open it. For now.

Comments stop at the org boundary too. Public pages get no threads.

Concurrency is naive. The last writer wins, there are no transactions, and you only get leases if you ask for them. That’s fine for a status board and not fine for two people rewriting the same paragraph, which is presumably why live docs journal edits instead.

The security story is unwritten. Pluto Security showed that nothing between the model and the browser inspects a page before it ships: 10 of 85 attempts got synthetic credentials into a published page. Their analysis explicitly left the runtime capabilities out. A comment that makes Claude edit a page is a new input channel into an agent with write access. Since v2.1.265 on September 8, Claude treats a page someone else wrote as untrusted content and flags any instructions embedded in it instead of following them. Nobody outside Anthropic has tested it yet, though.