zv1 can see your sketches
Whiteboards are usually where context goes to be invisible: the diagram that explains everything exists only as pixels nobody's AI can read. Napkin closes that gap. Ask zv1 about a sketch — from any tool or full-screen at chat.zerowidth.ai — and it finds the board and actually looks at it: the layout, the arrows and what they connect, the handwriting, the sticky notes, the reference cards and what they point to.
That means you ask about what's drawn:
- "Look at my triage sketch — which path has no failure handling?"
- "The stickies on the retro board — group them into themes."
- "Does the architecture we sketched yesterday match how the flow is actually wired?" — the sketch names the real flow via its reference card, so zv1 can compare the drawing against the thing.
zv1 looks with your access: it can only see sketches you can see, and a reference card resolves for it exactly as it would for you.
Sketch cards in chat
When zv1 refers to a sketch, its reply carries the board as a clickable card with a live thumbnail — the conversation and the drawing stay attached, and one click drops you onto the canvas. The same card appears when you paste a sketch's URL on its own line in chat, and in a Compass page body — so a workflow page can show the diagram that explains it, thumbnail and all.
Whiteboard-to-work patterns
The point of an AI that reads the board is that a sketch can be the input to structured work:
- Sketch review
Rough out an agent architecture in a working session, then ask zv1 to critique it: unhandled branches, steps that belong in one node, the place a classifier should sit. You're getting review on the napkin version — before anything is built.
- Whiteboard to dataset
Sketch a grid of tricky cases during a brainstorm — inputs down one side, expected behavior on stickies. Ask zv1 to read the board and draft the Caliper dataset from it. It proposes; you approve what it adds.
- Diagram to documentation
After the sketch settles, ask zv1 to turn it into prose — a Compass page describing the workflow the boxes and arrows show — and attach the sketch to the page so the drawing and the write-up travel together.
The common shape: the sketch is where the thinking happened, so pointing zv1 at the sketch is faster than re-explaining the thinking.
zv1 and decks
Decks get the same treatment, both directions:
- Reading — ask about a deck and zv1 reads it slide by slide: titles, text, speaker notes, what's drawn where, and which text areas are still empty. "What's slide 3 missing?" is a fair question, and so is "does this deck actually say what we decided?"
- Making — ask for a deck and zv1 builds one: real slides, real layouts, your workspace's brand color on the titles, handed over as a clickable card. From there it's yours — every slide is an ordinary Napkin canvas to reshape, draw over, and present. It can also work on a deck that exists: add a slide, or fill in the text areas a layout left open.
- Drawing — zv1 can also pick up the pen: strokes, shapes, arrows, and labels, on a slide or on a sketch. Ask it to circle what's weak on slide 2, mark up the diagram you drew, or rough out a quick figure of its own. What it draws is ordinary ink on the board — attributed, movable, and undoable like anyone else's.
A deck zv1 drafts and a deck you build by hand are the same thing on the same canvas — there's no separate "AI deck" format to escape from.
The rest of Napkin
It isn't only sketches and decks. zv1 can work on every surface here:
- Sheets — build one and fill it in, change cells in one you already have, run SQL against your tabs to answer a question, and pin a chart of the answer.
- Docs — draft, continue, or tighten a doc, editing the same document you're looking at.
- Diagrams — make a flowchart from a process you describe, or change one that exists.
Asking about a sheet gets you a query rather than a guess: zv1 reads the table definitions and answers by running SQL over your data.
Programmatic access
Everything above is reachable through the MCP server, so your own tooling gets what zv1 gets. With read scopes, an agent can list boards, render a board or a single slide to an image, read a deck as a markdown outline, and query a sheet. With write scopes, it can create boards, author decks, draw, write docs, set cells, add charts, and build diagrams.