An AI document editor gives you a workspace right next to the chat. It holds everything the model creates for you. That means a long report or a piece of code is something you can edit directly. You don't have to go digging through old messages to find it again.
A chat thread is a bad place for anything more than a few lines. It's easy to lose what you made. You can't just change a word without asking for a whole new version. And each new update pushes the last one further away in the history.
ChatFuse canvas rolled out in 10 separate stages. This article covers the problem that each of those stages was built to fix.
What decides that something opens in a ChatFuse canvas?
The model itself says where it goes. If something gets wrapped as an artifact, the ChatFuse orchestrator sends it straight to the canvas instead of showing it as text in the chat. We don't try to guess based on how long it is or what's in it; that call is made directly.
Guessing by size fails all the time. A 40 line explanation about system design should stay in the thread, but an 8 line SVG file absolutely belongs on the canvas. Making the choice at generation means the thing with the intent is the one that decides.
And if you upload a file and ask for edits, that's the other way it happens. The canvas opens up automatically, because working on a document you attached is a clear signal.
What can the ChatFuse AI document editor render live?
6 kinds of output can show up as a live preview instead of plain text: HTML, React, SVG, Mermaid, LaTeX, and CSV. People want to see these things, not just read them. That's the whole point of this list. Looking at a Mermaid chart in code doesn't help anyone. A React component you can't see isn't a result; it's just a code review.
We run each preview in a sandbox that includes a console. If something in your component breaks, you'll see the error right there with your work. You don't get a blank screen.
Can I edit the document, or only regenerate it?
You can just go in and change it yourself. Our non code ChatFuse canvases use a rich text editor, so the whole thing feels like a normal document. Fixing a single sentence doesn't mean the whole thing gets thrown out and rewritten.
That was our second step, and it completely changed how people use it. If your only choice is getting the AI to start over, then every tiny tweak is a big risk. You might lose a bunch of text you liked. Letting you handle the small edits means the AI is just giving you a starting point, not the final version. That's how the work should be split up.
What are ChatFuse quick actions and why do they need scope?
Quick actions let you change just one part of a document and drop the new version back in. They need to know the exact scope because if you tell it to make this shorter, it should only touch what you selected and leave the rest completely alone, byte for byte identical.
Figuring out the scope is the real challenge. The system has to understand what you mean by "this," then only change that part. If it just regenerates the entire document to fix one paragraph, it will accidentally reword 3 others while it's at it, and you probably won't catch it until much later.
What you can do depends on the content, too. A prose document gives you different options than a code file. You won't see an action for add error handling if you're working on an essay.
Why does canvas have its own endpoint instead of going through chat?
A transform isn't a back and forth chat. Sending it through the full conversation engine just adds steps that a simple edit doesn't require. That's why we built a direct endpoint in Phase 6 that completely avoids the chat pipeline. This is the main reason quick actions now feel instant.
You don't need classification, routing, or memory injection to make a paragraph shorter. You just need the original text, the command, and a model. Cutting out everything else is what makes an edit different from sending another message. It's also the exact same LLM streaming latency we're always trying to reduce.
Can code in a ChatFuse canvas actually run?
Yes, you can run code in the browser for JavaScript, Python, and TypeScript. The Python part uses Pyodide inside a web worker, so your page doesn't freeze up while it runs and it never hits a server. It's meant for working with data and writing small bits of code, not for building an entire application.
For someone using it, that means you can see the code an AI suggests and then actually check that it runs. For ChatFuse, it wipes out a whole layer of backend work, since there's no execution service to maintain, keep safe, or pay for.
There are some real constraints to be clear about. Running code in the browser means no access to a file system or the network by default, and only a limited set of packages. It covers what most people ask for in chat, which is data jobs and short scripts, and it definitely can't handle a build process.
What happens to a canvas when I close the chat?
It saves automatically on a dedicated path that uses compaction. So a long editing job doesn't save a new version for every single keystroke. Compaction merges that stream of tiny adjustments into just the meaningful states. That's how your work is right where you left it.
An auto save feature that writes after every change seems fine in a test. But in the real world, it generates thousands of rows that are almost exactly the same.
Can I share what I made?
Yes. When you publish a canvas, it goes public. Anyone with that link can take it and fork a personal copy. It doesn't just give a view only look. That's because most generated work is a starting point, not a finished thing.
A person who finds a good component will want to adjust it. Making them copy and paste it into a new chat just throws away the original effort.
Which formats are worth rendering, and which are not?
A format's worth checking if seeing it gives you what reading it can't. That's the bar. So Mermaid, SVG, LaTeX, CSV, HTML, and React all get their own canvases. But plain markdown and shell scripts don't clear that bar. They stay right in the thread.
A Mermaid chart definitely makes the grade. You can't just glance at its syntax and tell if the boxes are layered right. LaTeX gets in too for a similar reason: a formula is either correct or obviously broken, and the raw code doesn't give anything away. CSV files are also fine, since you can't spot misaligned columns or type issues until the data is in a table.
But plain markdown doesn't cut it, and that's exactly why it just shows up in the thread instead of a preview pane. A shell script fails for us too, because the only real preview is to run it, and we aren't going to run your code for you.
So the final list is pretty short, and that's by design. Every single format we preview means one more renderer to keep working, one more sandbox to keep safe, and one more way things can go wrong. Only 6 are worth it.
Is a canvas the same as an artifact?
Not quite. An artifact is the specific thing the model made. A canvas is the area where you see it and make changes. Each piece of work shows up in its own editing space. This split is key because the content itself is separate from all the tools, history, and ways to share it.
Does the canvas keep working when the model is wrong?
Yes, and that's the whole idea. The AI gives you a draft. The preview shows where it's broken. The console tells you exactly why. Then you either fix it yourself or tell the model to make a specific change. Getting a component that doesn't compile isn't a failure; it's just a normal step.
The important part is how quickly you can move from broken to fixed. And having your editor, the preview pane, and the console all right there together is what makes that loop so fast.
Where does canvas fit with the rest of ChatFuse?
The AI that writes in canvas gets picked automatically, same as any other task, from our pool of more than 100 models by OpenAI, Anthropic, Google, and Meta. How that routing works was already explained in AI prompt classification. A piece of code ends up on a model that's good at code, and you don't have to choose it yourself.
Canvas is just one part of the bigger ChatFuse AI orchestration platform. It uses the same routing and model selection everything else does.
Try the ChatFuse AI document editor
Ask for a component, a diagram, or a document you want to keep, not just a one-off answer, and it opens on a full canvas. You can start for free, or check the pricing page for plans.
See how the rest of the phone's chat interface is built on mobile AI chat architecture.
Comments
Loading comments…