Most product demos are a recording, a sales call, or a curated tour, and they run on frozen data: one canned dataset, captured once, the same for every viewer, wired up to look good and replayed on demand. They start when someone hits play and end when they close the tab. Nothing was happening in there before you arrived, and nothing happens after you leave. It is summoned for you, performs its one rehearsed scene, and goes dark.

Some vendors do better than a recording. They stand up a real backed sandbox, a live environment you can click around in, and credit where it is due: that is harder and more honest than a screencast. But a sandbox is still a room set up for a viewing. It waits for you to poke it, and until you do, nothing much is happening. It is a live building with no one living in it. The lights come on because you walked in.

We do the opposite. There is a system running right now, on a persisted grid, whether anyone is watching it or not. It behaves exactly like a real system: failures inject and clear, services degrade and recover, the graph rebuilds itself as the shape of the system changes, all on its own, all the time. It was running before you opened this page and it will be running after you close it. Our Twitch stream is simply a live window onto that grid, the 3D player pointed at it around the clock, so you can watch it build itself in real time. The system you are watching is always on. The broadcast is best-effort: the camera can drop, but the grid it was pointed at does not stop.

The telemetry driving those grids comes from TraceGen, our open-source trace generator, so it is generated rather than pulled from a real customer. That is the honest detail, and it changes nothing about the point: these grids are alive, not baked. They keep moving whether you are watching or not, exactly like the production system you actually care about. And when you want your production instead of ours, you point your own exporter at your own grid and the same living view renders your real system.

It is not one grid, either. A single scene, however live, is still a single scene. So we run seven distinct worlds and rotate through them, each a different shape of system telling a different story:

• A healthy e-commerce platform. The clean baseline: mostly green, low errors, an easy graph to read. What good looks like.
• An AI-native application, observed. An agentic stack (a RAG pipeline, an AI chatbot, content moderation, a multi-step agent) emitting full OpenTelemetry GenAI spans. Most tools cannot see inside agentic calls. This one shows that we can.
• AI, on a calm day. The same agentic topology at a low error rate, for a clean read of the AI story without the noise.
• The real world: traditional and AI together. Classic microservices and AI services sharing one trace graph, with realistic errors. What a modern application actually looks like.
• When the AI tier goes down. The full traditional platform while its AI backends are out, spans erroring on rate-limits and timeouts, showing the blast radius.
• Services you didn't know you had. Producers emitting to queues whose consumers are dead, so work piles up unconsumed. IAPM reads the gap in the topology and renders the missing, phantom services that should be receiving it.
• Everything is on fire. Maximum errors plus dead consumers: the root-cause and incident-response showcase.

Whichever one the rotation lands on when you arrive, you did not pick it and we did not stage it for you. It was just what was running.

On any given visit you might drop into a calm graph humming along or an incident mid-cascade. That is the point: you are not being handed the one scene we rehearsed.

That is not a marketing gimmick. It is the thesis of the whole product, made watchable.

A dashboard is a report you request. A system is a place that persists.

Think about what a dashboard actually is. It is a query. You open it, it fetches the last fifteen minutes, it renders a snapshot, and the moment you look away it stops meaning anything until you ask again. The system only "exists," in the dashboard's world, when someone pulls it up.

Production does not work that way. Your system does not pause when you close the tab. It is there, alive, humming or degrading, at 3am when no one is on call and at noon when everyone is. The request that failed to arrive failed whether or not a human was watching the panel it would have appeared on.

So the honest way to show a system is not to summon a demo. It is to point at one that is already alive and say: look, it is right there, it was always right there.

Flip the demo dynamic

The usual demo dynamic puts the vendor in control of time. The demo begins on our call and ends on our call. You see what we choose, when we choose, for as long as we choose.

We wanted the opposite. The demo begins and ends on your call. The system is standing there, running, and you decide when to look, how long to stay, and when to stop. There is no one on the other end deciding what you are allowed to see. You are not being shown the system. You are watching the system, the same way you would watch your own.

This is why the stream is unedited and continuous, not a produced segment. A cut, a highlight reel, a "best of" would put us back in control of the clock. A raw live feed hands the clock to you. You cannot cherry-pick a live system that has been running for hours; whatever it is doing when you arrive is just what it was doing.

From watching to entering

Watching is the first rung, not the last. The stream is the ambient proof: here is a living system, rendered spatially, behaving the way a real one does. But you do not have to stay on the outside of the glass.

The grid you are watching is joinable. Install the client from the downloads page, create a free account, and you enter the same running system and move through it yourself: no subscription, no sales call, and the AI assistant is on, not a locked "upgrade to try it" teaser. The gap between "watched a demo" and "stood inside it" is where most trials quietly die. We collapsed it: the thing you were just watching is the thing you can now walk into.

And when you are ready to see your own system instead of ours, you point your OpenTelemetry exporter at your own grid. Because everything here is OTel-native, that step costs you nothing you have not already built. The demo grid is the hook. Your own telemetry, rendered as a place you can enter, is the point.

The system is there whether you are looking or not

That is the sentence the stream exists to prove. A flat tool teaches you, quietly, that your system is a thing you summon and dismiss. A living system on a screen teaches you the truer thing: it was always there, it has a shape, and the shape is worth being able to see. Putting that shape back on the screen is the whole idea behind spatial observability, the category IAPM is built on.

The grid is running right now. You did not have to schedule it, and you do not have to ask. Catch it live on the stream, or walk into it yourself any time. Either way, it was already there.