Regia

The Backstage Reality

At a concert or festival, the huge LED walls, live camera feeds, audio-reactive graphics, and glitch effects.

A lot of that work happens in tools like TouchDesigner and Resolume. They're incredibly capable, but they're 20 years old and lack many modern features.

Video gets moved through capture cards, SDI runs, switchers, and dedicated machines. A visual patch usually lives on one operator's computer. Getting another camera into the system can mean more hardware and cabling. Getting the same output onto another screen means routing another signal.

And when something stops working during a show, someone has to figure out which part of that chain broke.

We wanted to see what this workflow would look like if it were built with modern web technology .

What if cameras, operators, processing, and displays could all join the same production through a link?

And what if an agent could help in the entire process, from creating the shader to managing the event?

What We Built: Regia

Regia is a free and open source live visual engine and video router that runs in the browser.

The core of Regia is a shared visual node graph. Multiple operators can work on the same graph in real time using Yjs and CRDTs, with shared state and cursor presence.

Browsers can also become part of the graph itself.

A phone can scan a QR code and immediately become a WebRTC camera source. Its live video appears as a texture node that can be processed, mixed, or routed anywhere in the graph.

A laptop connected to a projector can open an output URL and become a display. Instead of sending the finished video across the venue, Regia can send the graph and media streams to that machine and render the final composition locally on its GPU.

This means cameras, operators, and displays can join a production without all of them being physically wired back to one machine.

Agents Can Operate the Graph

Regia exposes its production system to browser agents through WebMCP.

The agent can inspect the node graph, media connections, outputs, audio data, and engine state. It can also modify the graph using the same operations available to a human operator.

So instead of manually building every part of a signal chain, you can say:

"Put the crowd camera on the main stage, add a VHS effect that reacts to the bass, and send the ambient visuals to the hallway displays."

The agent can find the relevant camera and outputs, build the effect chain, connect audio FFT data to the shader, and update the routing.

WebMCP becomes more useful during failures as well.

If you ask:

"Why is the stage monitor black?"

the agent can inspect the live topology and respond:

"Camera 2 disconnected 20 seconds ago. The stage output is still routed to it. I can switch it to the backup visual."

Because the graph is collaborative state, agent changes are visible to every operator and can be reverted through the same history as human changes.

Regia turns the browser into part of the production infrastructure: a camera, a visual engine, an output, or a control surface.

Instead of building the entire show around one workstation and a physical signal chain, the production becomes a shared graph that can span every device in the venue.