Tersa: A Visual Canvas for AI Workflows Built on the Vercel AI SDK Gateway

What Tersa Is For, and Who It Is Built For

Tersa is a visual AI playground. The README describes it as a canvas where you drag, drop, connect and run nodes to build AI workflows powered by the Vercel AI SDK Gateway. The intended user is someone who already understands model calls and wants to experiment with how they chain together, without writing a new script for every variation.

The feature list points at a specific kind of work. You get text, image and video models from more than 25 providers through the gateway, cost indicators that show relative pricing across models, reasoning extraction for providers that expose it, and streaming responses. Each of those is a prototyping concern rather than a production concern. Comparing relative cost across models before you pick one is a decision you make early. Reading a model's reasoning trace is a debugging move.

The project is a vercel-labs repository, which places it alongside other experimental work rather than a commercial product line. The package.json marks the package as private and gives it version 0.1.0, while the release list shows v2.0.0 tagged on 2026-02-20. That mismatch is normal for an app repository that is not published to a registry, but it means you should read the release tags rather than the package version when you want to know what changed.

How the Canvas, Nodes and Model Calls Fit Together

The architecture is a Next.js 15 application using the App Router with Turbopack, React 19, and ReactFlow for the canvas surface. The repository layout confirms this: app/, components/, hooks/, lib/, providers/, plus tunnels/ and scripts/ at the top level. The dependency list names @xyflow/react, which is the ReactFlow package, alongside jotai for state and nanoid for identifiers.

Data flow starts at a node. You add nodes from a toolbar, connect one node's output to another's input, and select a model from any supported provider. When you run the workflow, the model calls go through the Vercel AI SDK Gateway, which is what gives the app its multi-provider reach without a separate integration per vendor. Streaming responses come back into the canvas as they generate.

Two details are worth separating. Rich text editing is handled by TipTap, which is a large dependency block in package.json, so text nodes are real documents rather than plain textareas. Media storage goes to Vercel Blob according to the technologies section, which means image and video outputs are not purely local even though the canvas state is. That split matters: your node graph lives in the browser, but generated media may leave it.

Canvas state persists in the browser automatically. The README does not describe a server-side store, an export format, or a way to share a canvas between two people. If your mental model is a collaborative document, this is not that.

Installing Tersa and Running a First Workflow

The prerequisites are Node.js v20 or later and the PNPM package manager. Clone the repository and install dependencies first.

git clone https://github.com/vercel-labs/tersa.git
cd tersa
pnpm install

Before starting the server, create a .env.local file with your AI SDK Gateway credentials and any provider API keys you want to use. The README states this step but does not list the variable names, so you will need the AI SDK Gateway documentation for the exact keys. This is the point where the setup stops being copy-paste.

pnpm dev

The development script runs next dev with Turbopack. Open http://localhost:3000 in your browser and you should see the canvas. From there the usage steps are short: add nodes with the toolbar, drag from one node's output to another's input, pick a model, and run the workflow.

If you want a production build rather than the dev server, package.json defines build as next build with Turbopack and start as next start. The README does not walk through deployment, so treat those scripts as the entry points and work out hosting yourself. The repository does include a vercel.json, which suggests Vercel is the expected target.

Where Tersa Stops Being the Right Tool

The browser-local canvas is the sharpest limit. Because canvas state persists in the browser, a workflow is tied to the machine and browser profile where you built it. Clear site data and the graph is gone. The README does not document export, import, or a hosted account that would restore it. For a throwaway experiment that is fine. For anything you intend to hand to a colleague or rerun next quarter, it is a problem you have to solve outside the tool.

Media handling pushes in the same direction. Vercel Blob appears in the technologies list, so image and video nodes depend on a storage service that is not the browser. The README does not explain whether Blob is optional, whether a local filesystem fallback exists, or what happens to media when you have no Blob configuration. Anyone planning to use the image or video models should verify that path before building on it.

There is also the question of what runs the workflow. The README describes running a workflow from the canvas, and the app is a Next.js server plus a browser client. It does not describe a headless runner, a cron trigger, or an API endpoint that executes a saved graph. If your goal is an automated pipeline that fires on a schedule, Tersa is a design surface, not the runtime.

Finally, the maintenance signal. The last push to the repository was on 2026-05-01, and the most recent release is v2.0.0 from 2026-02-20. The repository is not archived. That is a recent enough history to suggest the project is still being worked on, but nothing in the README commits to a release cadence, and no support policy is stated.

Tersa Compared with Code-First AI SDK Usage

The obvious alternative is using the Vercel AI SDK directly in a script or a small Next.js route, without a canvas. That is not a lesser option; it is a different trade-off. In code, a multi-model comparison is a loop over model identifiers and a table of results. In Tersa, it is a set of nodes you rearrange and rerun, with cost indicators visible while you decide.

The difference shows up in what you can keep. Code lives in version control, diffs cleanly, and runs in CI. A Tersa canvas lives in browser storage, which the README presents as a convenience rather than a collaboration feature. If you need review, history, or reproducibility, code wins outright.

Where Tersa earns its place is the exploratory phase, particularly with non-text models. Wiring an image node to a text node and watching the result stream back is faster on a canvas than writing the equivalent plumbing, and the reasoning extraction view is something you would otherwise build yourself. The honest framing is that Tersa is a sketchpad for the AI SDK Gateway, and the AI SDK is the thing you ship.

Licence, Forking and the Cost of Staying Current

Tersa is MIT licensed, with the licence text in license.md at the repository root. MIT is permissive: you can use, modify and redistribute the code, including in commercial work, provided the copyright notice and permission notice are retained. This is not legal advice, and if you plan to redistribute a modified version you should read the licence file yourself rather than rely on a summary.

Because the package is private and versioned 0.1.0 in package.json while releases run to v2.0.0, there is no npm package to depend on. Adoption means forking or cloning the repository and tracking it yourself. The dependency set is broad and mostly pinned with caret ranges: Next.js 16.1.6, React 19, the AI SDK packages, a long TipTap block, ReactFlow, jotai, and Tailwind. Upgrading means resolving that whole graph, not one library.

The repository includes two scripts aimed at this. bump-deps runs npm-check-updates and reinstalls, and bump-ui refreshes shadcn components and migrates Radix. Those exist because the UI layer is generated rather than vendored, and regenerating it can overwrite local edits. If you customize components heavily, expect that script to be a merge problem rather than a convenience.

Editorial conclusion

Tersa suits engineers who want to sketch a multi-model AI pipeline on a canvas and see streaming output before committing to a backend design. It does not suit anyone who needs a hosted service, server-side persistence, or a workflow that runs without a browser tab open, because the README describes canvas state as browser-local. Before adopting it, confirm your AI SDK Gateway credentials and provider keys work in .env.local, and check whether Vercel Blob is required for the media nodes you plan to use, since the README lists it as a technology but not as a prerequisite.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. vercel-labs/tersa on GitHub