Pure cinema

Most of what we ship is there to make something work, or stop something going
wrong. A refusal that waits for a human. A graph that is also the firewall. A
rollback that never puts back an old password. Important, and none of it is
much fun to watch.

This one is fun to watch.

Twenty-six seconds, nothing sped up. On the left, Claude Code is deploying a project. On the right, the console has LIVE on and is left alone. Watch the recording on gagarin.cloud.

What you are looking at

On the left, Claude Code working through a deploy: a Postgres, an API, a web
page. On the right, the project page in the console, empty when the clip
starts. The agent runs gg resource add, and a Postgres plate fades in on the
right. It ships the API, and a second plate arrives above the first with an
arrow down into it. It ships the web service, the picture slides
to make room, and a third plate lands on top with its public tag. The three
read RESTARTING for a moment, then one by one turn green, and the line under
the project name goes from "nothing running" to "3 of 3 drifting" to
"3 services, in agreement".

Nobody pressed refresh. Nobody touched the console at all.

How it is done, briefly

There is no feed. The engine answers a status read and pushes nothing, so LIVE
is a re-read on a clock: every five seconds the page asks again, through the
same session and the same path as opening it would. The next read waits for
the last one to finish, so a slow cluster slows the clock rather than piling
reads on itself. A tab you are not looking at reads nothing, and catches up the
moment you look back. The switch is remembered per browser, and it is off
until you turn it on, because a status read asks the cluster about every
workload and we would rather not do that to everybody.

The motion is the part we spent the time on. A re-read that redrew the graph
from scratch would snap: a new service would appear fully formed and
everything under it would jump a rank. Instead a plate that stays slides from
where it was to where it now belongs, with its arrows following. A new one
fades in at its place. One that was destroyed fades out where it stood. When a
plate's reading changes, it rings once in its own colour. The ledger on the
left does the same: rows arrive and leave, and a cost or a replica count that
moves flashes as it does. If your system asks for reduced motion, all of it
settles without the choreography.

Why bother

Because the whole pitch of this platform is that you hand a repository to an
agent and it comes back with an address, and that pitch has a weak moment in
the middle. For a minute or two the agent is running commands and you are
reading a transcript, trusting that each line did what it says.

LIVE turns that minute into something you can see. The agent says it added a
database, and a database appears. It says web now reaches api, and an arrow is
drawn. It says everything is up, and everything is green. The transcript and
the picture agree, or they do not, and you know which before the agent tells
you.

That is a real thing, and it is still not why we built it. We built it because
the first time we watched a project assemble itself on screen while an agent
typed, everyone in the room went quiet, and that seemed worth keeping.

Try it

Open any project at my.gagarin.cloud, press LIVE
in the bar above the graph, and tell your coding agent to deploy something
into it. If you have nothing to hand, the chit-chat recipe
in the recording is a Postgres, an API and a web page, and takes an agent
about a minute.

Then sit back. It is the most relaxing minute in infrastructure.

Originally published at gagarin.cloud.