Orb: a language for LLMs to write motion graphics in 20x fewer tokens

Orb is a small open-source programming language that AI models write to make motion graphics, slide decks and interactive animations. I released it on 9 November 2026 under the MIT licence, with a playground that runs in the browser. On six test briefs the Orb files total 1,026 tokens. The same briefs written as GSAP total 20,684 tokens, about 20x more. The architecture and the shared language layer were written with Claude Fable 5.2. This post explains what Orb is, what is new in it, what the numbers mean and where they stop.

Try it now, nothing to install: the Orb playground. Source: github.com/AnassKartit/orb.

Key facts (quick answer)

Fact	Orb
What it is	A small language AI models write for videos, decks and interactive animations
Released	9 November 2026, version 1.0.0-beta.1
Licence	MIT
Playground	kartit.net/orb, runs in the browser
Source	github.com/AnassKartit/orb
Tokens on six briefs	Orb 1,026. GSAP 20,684. Plain HTML 22,319. anime.js 23,978
One 10 second data video	12 lines of Orb. 193 lines of GSAP
What a model reads first	Two cheat sheets, 4,428 tokens together
Outputs	One interactive page, a video project, or an MP4
For AI agents	MCP server with 5 tools
Built with	Claude Fable 5.2 (architecture and language layer)

TL;DR

• Orb is a language for the model, not for the animator. The model writes 12 lines, the compiler writes the page.
• Six briefs: 1,026 tokens of Orb against 20,684 of GSAP, 22,319 of plain HTML and 23,978 of anime.js.
• The 20x holds when the compiler picks the look. Exact rebuilds of two real videos saved 4.5x and 5.8x.
• It is a real language: variables, typed expressions, components, modules, and a standard library written in Orb. The bar chart component is 18 lines of Orb.
• The compiler checks the file. Every error names the line and suggests the closest valid word.
• The launch video is 142 lines of Orb. It compiles to 117,838 tokens of HTML and GSAP.

What is Orb?

Orb is a short text file that says what should appear on screen and when. A compiler turns it into the web page or the video.

Here is a complete 10 second video with a title, a counter, a bar chart, a line chart, a donut and an end card:

motion "Launch Week" 1280x720 10s bg=slate
  scene 2.2s
    title "Launch Week" in=rise
    sub "Signups beat the plan" in=fade
  scene 3.2s
    count "Signups" 4800 in=pop
    bars 120 340 560 800 1100 980 900 in=grow stagger=0.08
  scene 3s
    line 62 58 55 54 53 52 in=draw
    donut ios=48 android=36 web=16 in=sweep
  scene 1.6s
    title "Thank you" in=blur

That is the whole file: 12 lines, 154 tokens. Paste it into the playground and it plays.

A real recording of the playground. The preview rebuilds after every change.

Why does a language for AI models matter now?

Because AI models now write most of the motion graphics people ask them for, and they write them the long way.

Ask a model for a short clip and it does not hand you a video. It writes a web page: about 200 lines of HTML, CSS and JavaScript for a 10 second chart. Three things follow.

1. It costs output tokens. Claude Fable 5.2 is priced at $8 per million input tokens and $40 per million output tokens (Anthropic, 9 November 2026). Output is 5 times the price of input, and output is where those 200 lines go.
2. It is slow to read. Nobody reviews 200 lines of generated timeline code. You watch the result and hope.
3. Nothing checks it. If a title is cut off or a box sits outside the frame, you find out when you watch the video.

Orb moves the long part out of the model. The model writes the short file. The compiler, which is ordinary tested code, writes the long page and checks it.

How many tokens does Orb save?

About 20x on six briefs, when the compiler chooses the look.

The same six briefs were written in one pass by the same model in four formats. Tokens are counted with tiktoken cl100k. The files are in the repository under benchmark/.

Format	Tokens written	Times more than Orb
Orb	1,026	1x
GSAP	20,684	20.2x
Plain HTML, CSS, JS	22,319	21.8x
anime.js v4	23,978	23.4x

For the first brief, the Launch Week video above:

Format	Lines	Tokens
Orb	12	154
GSAP	193	3,892
Plain HTML, CSS, JS	202	3,765
anime.js v4	209	4,293

What is new in Orb?

Five things that a template does not have.

One language, three outputs. A file with scene blocks becomes one interactive page: click through a deck, hover a character. A file of timed items (text, image, video, audio) becomes a video project and an MP4. The same video can also be built as a single web page.

It is a real language. Orb has variables, typed expressions (lists, conditions, functions such as max and lerp), components with named parameters and slots, and modules you import. The standard library is written in Orb itself. The bar chart is not built into the compiler. It is 18 lines of Orb on rectangles and text, and you use it with one line:

import "orb:std/charts" as c
c.bars [82, 64, 120] ['A', 'B', 'C'] at=2 badge='FASTEST'

The compiler checks the file. Every error names the line and suggests the closest valid word. The boxes and sizes you write are never changed behind your back. Text is fitted automatically, but never below 60% of the size you asked for. A text box placed fully outside the frame is reported.

Nothing is stuck with a default. Every element takes the same options: color, font, size, x, y, rotate, border, shadow and more. Charts take a colour per bar and a tag, images take a size and a frame, decks take a look, a background per slide and transitions, and the character comes as an owl, a robot, a fox or a cat. In the playground you can click an item, drag it, and change it in a panel while the source line rewrites itself.

It is built for agents. Orb ships an MCP server, a standard way to plug tools into an AI agent. The agent reads the guide once, writes Orb, checks it until it is clean, then builds or renders.

How did Claude Fable 5.2 help build it?

It designed the architecture and wrote the language layer that joined two half-finished languages into one.

Before, my repository had two separate things: a small format for interactive pages and another for videos. They shared nothing. I gave Claude Fable 5.2 the repository read-only and asked for an architecture. It came back with a plan: one pipeline, one set of language features for both kinds of file, components, a standard library, tests.

Then I let it build. It wrote the shared language layer (expressions, components with slots, modules) and the MCP server, and it directed the agents that built the web target and the playground. When I kept sending screenshots of cut-off titles, it turned each one into a compiler rule and a test. It also talked me out of writing “first” on screen, because we could not prove it.

The launch video is the proof I like most. It is one Orb file:

142 lines and 3,939 tokens go in. 15 files and 117,838 tokens of HTML and GSAP come out. Machine-written output is more verbose than a person’s, so do not read that as a 30x authoring saving. Read it as: this is the part I no longer ask a model to write.

How do I use Orb with my own AI agent?

Add the MCP server, or paste two cheat sheets.

git clone https://github.com/AnassKartit/orb.git
cd orb && npm install
claude mcp add orb -- node /path/to/orb/src/mcp.js

Tool	What it does
orb_guide	Returns the two cheat sheets. Read once per session
orb_check	Compiles and returns errors with a line number and a suggestion
orb_build	Writes the interactive page or the video project
orb_expand	Shows a file with every component expanded
orb_render	Renders an MP4

Without MCP, paste docs/SPEC.md and docs/SPEC-HF.md into the model’s context. They are 4,428 tokens together and they are the whole language.

What are the limits?

The 20x number is real and narrow. Here is where it stops.

• Six briefs is a small test. One model wrote all four formats. The tokenizer is tiktoken cl100k, a stand-in for each model’s own.
• Custom designs save less. When an Orb file dictates every position and size to rebuild an existing video exactly, I measured 4.5x (2,655 tokens against 11,883) and 5.8x (5,734 against 33,460) on two real videos.
• The cheat sheets are input. Count their 4,428 tokens once across the six briefs and the gap is 5,454 against 20,684, about 3.8x. Over a longer session the sheets are paid once and the gap grows back.
• Quality was scored blind on those six briefs. Orb 4.10 out of 5, plain HTML 3.67, GSAP 3.47, anime.js 3.30. The judges came from the same model family as the writer, and gaps under 0.3 are noise. I read it as no measurable quality loss, not as a win.
• It is a beta. A plugin interface, tests for video and a PowerPoint target are not built yet.
• The public test has not been run. Twelve new briefs are frozen with fixed rules: one try per brief, no retries, every result reported, failures included. I will publish it with the release candidate.

My take

Models are becoming the main authors of motion graphics, small games and interactive pages. They should not spend 200 lines on a bar chart, and I should not have to watch every render to find a cut-off title. A language is the cheapest place to put the taste and the checks once, so every model that writes it gets them for free. Orb is my bet on that. The playground is the fastest way to tell me I am wrong.

FAQ

What is Orb? A small open-source language that AI models write to make motion graphics, slide decks and interactive animations. Released 9 November 2026, MIT licence.

How many tokens does it save compared to GSAP? 1,026 against 20,684 on six briefs, about 20x. Exact rebuilds of two real videos saved 4.5x and 5.8x.

Can I try it without installing anything? Yes: kartit.net/orb.

Did Claude Fable 5.2 build it? It wrote the architecture, the shared language layer and the MCP server, and directed the agents that built the web target and the playground. Two older half-languages in the repository came before it.

How do I plug it into an agent? claude mcp add orb -- node /path/to/orb/src/mcp.js, or paste the two cheat sheets.

Is it finished? No. It is a beta, version 1.0.0-beta.1.

Sources

• Orb source, examples and benchmark data: github.com/AnassKartit/orb (measured 9 November 2026).
• Token counts: benchmark/runs/b1 to b6 in the repository, counted with tiktoken cl100k.
• The two cheat sheets: docs/SPEC.md (2,611 tokens) and docs/SPEC-HF.md (1,817 tokens), measured 10 November 2026 after the element options were added (3,188 together on 9 November).
• Claude Fable 5.2 pricing: Anthropic’s announcement on X, 9 November 2026, x.com/claudeai/status/2119867138987176141. Vendor-reported.
• Playground: kartit.net/orb.

By Anass Kartit. Not affiliated with Anthropic. The launch video on this page is written in Orb.