Skip to main content
In studio you build the interfaces, skills and integrations your Agents use. Save a file and the preview updates. It runs on your machine, reads your files off disk, and works offline. Node 20 or newer is all you need to build: no database and no Docker. Shipping what you build needs an account on the universe you are shipping to.

​
Start it

Terminal
unoverse create asks for your org’s name (it suggests the folder’s), turns the folder into that org’s own Git repo, and opens studio on http://localhost:4108. One folder, one org, one repo. Everything the org is made of sits at the top:
A new org starts with its tokens, its identity, Git with a first commit, and an empty folder for every kind you can author: components/, apps/, templates/, atoms/, skills/, blocks/, nodes/, agents/, objects/ and pipelines/. It also carries one check, run on every pull request: the same lint your universe runs. It holds no samples. For worked examples to read and copy, clone the demo org, Acme. It is all YAML. Components, apps, styles, skills and nodes are written in one language. Any AI tool you already use can author them. The linter checks its work, and the skills give it the rules. Nothing here needs a build step. unoverse studio reopens the org from anywhere inside it, always on the current version. There is nothing to update. A second org is a second repo, made in a new folder:
Already have an org repo? Clone it and open studio inside it.

​
What you can author

The main kinds of asset. Every one is a file in your own repository.
Build a micro app: a small AI-powered interface, served to your users. A chat window, a booking flow, a dashboard.An app owns its own states and layouts, and arranges components inside it.Lives in apps/. How apps work.
Build an arrangement with open sections a delivery fills: a shelf grid, an email, a comparison page. You place what you know and leave open what the Agent decides.Lives in templates/. How templates work.
Build a card, a form, a document. Write it once and it renders in your web app, in ChatGPT and in Claude. Change it, publish, and it is live everywhere with no rebuild.Lives in components/. How components work.
Build the buttons, headings and badges your components are made from. Compose these rather than hand-rolling a shape the design system already ships.Lives in atoms/. How components work.
Set colour, type and spacing once. Nothing else carries a hex code, so a rebrand is one change here instead of a sweep through every component.Lives in styles/. Tokens in full.
Tell an Agent how to behave, in plain markdown. What it should do, how it should answer, and what it must never say.Lives in skills/.
Write a piece of a prompt once, then reference it wherever it is needed. The same wording stops drifting across a dozen Agents.Lives in blocks/.
Give an Agent something new it can do: call an API, read a database, transform a payload. Written as YAML, not code.The Nodes tab runs one against the real service with no platform running. Fill in the settings, press Run, and the output appears beside them. Keys come from your own .env and are stored nowhere.Lives in nodes/. A node type is one per platform, so a node copied from Acme gets your own type. Building a node, and testing one.
studio also has Agents and Identity tabs, and two kinds have no tab yet: objects and pipelines. All four are folders at the top of your repo and ship the same way. Workflows are not authored here. They are built on the canvas.
unoverse studio editing a card component

A component, its live preview at every size, and its controls.

​
The design system comes with it

You do not start from an empty screen. studio ships a full design system: atoms, components and a token foundation, all there to build on. It grows with every release.
unoverse studio showing a component definition and its preview

Every asset is a YAML file, with its live preview beside it.

Buttons, avatars, callouts and choice tiles. Cards, carousels, charts, list pickers and composer bars. Colour, type and spacing as tokens, with themes on top. Your own components sit beside them and read the same tokens, so what you build matches what shipped. The Design section covers how to build components and apps on top of it.

​
Ship it

Push to Git. Your universe pulls your org’s repo, checks every commit with the same lint, and applies it with no restart. Nothing is pushed into a universe.
An admin connects the org to its repo once, on the org’s Source tab in the universe. They set the repo, the branch (or release tags) to follow, a read-only deploy key and a webhook. After that, a push arrives within seconds, or within five minutes without the webhook, and Sync now pulls at once. Connect a repo walks through it, and Environments covers dev, UAT and production. To undo a change, revert it in Git, and the universe follows.

​
Set up your editor

Everything you author is validated against a schema as you type, so a typo or an unknown field is underlined rather than surfacing later. This works for .json out of the box. YAML needs one extension: VS Code installs it from the Marketplace; Cursor and Windsurf install it from Open VSX.
Without the extension, YAML files get no validation at all. Nothing warns you: they simply stop being checked.
Your workspace carries a .vscode/settings.json that maps every file to its schema, which is what the extension follows. To confirm it works, open a node’s node.yaml and delete a required field such as type. A red underline should appear within a second. Undo, and it clears.

​
Next steps

Design a component

How components, apps and tokens fit together, and how to build your own.

Create your first node

Build an integration as a few small YAML files, and run it against the real service.

Get the skills

Let your AI tooling author all of this for you.