In plain language — what each part is for, and why it's there. The screens are drawn rather than photographed — each one points at the single thing that matters on it.
A camera points at the TV and streams its picture to you with very low latency — so you see exactly what's on screen, wherever you are. To save bandwidth it only streams while someone is actually watching, with a short warm-up window so re-opening is instant.
A web remote sends key presses, volume and navigation straight to the TV over its LAN. Power is one smart button: it turns the TV off over the network, and wakes a sleeping TV with a Wake-on-LAN pulse — the button even reads the real on/standby state and relabels itself.
For developers: full Chrome DevTools for the web app running on the TV — inspect elements, watch the console and network — deep-linked straight to the right set, embedded in the page.
While you watch, the box can record the session locally — together with a synchronised track of every key you pressed. Later you can scrub the video, see exactly what was pressed when, and even replay those exact key presses onto a live TV — turning a recording into a repeatable test. You can also export a clip with the key labels burned into the picture.
A scenario is a short script: press these keys, wait, launch that app, then check the screen actually says what it should. You write it in a proper editor with a diagram beside the code — the two are the same document seen twice, so scrolling one follows the other and dragging a step in the diagram rewrites the code. Nothing has to be memorised: one button lists every step the language has and every key a TV can be sent. A broken document says what is wrong and on which line, and won't pretend it can be saved.
You can run the whole thing, walk it through dry with nothing reaching the TV, or start from the step your cursor is on — because the first forty seconds of setup are rarely what you are testing.
Point a scenario at one TV or twenty and give it a time: it runs itself every night, or every so many minutes, and tells you what happened. A round that failed posts to your webhook. A TV somebody was actually using is skipped rather than interrupted — and skipped is amber, not red, everywhere, because a scenario that never ran is not a scenario that failed. Every round is kept with its per-step timing and, when a camera check fails, the frame that failed it. Watches and runs are two screens: the plans live under Watches, and every run — scheduled, started by hand, or by an AI agent — lands in Runs, filterable by what started it.
And the news can be personal. Give your own account a channel and you hear about the runs you started — the scheduled ones and the one you just clicked — with a "let me know about this one" you can tick on the run itself. A team's admin can opt in to their own team's runs, one team at a time, and the people in it are told, in the app, that someone is listening. Failures always reach you; a pass only if you ask for it, and a round across twenty TVs arrives as one message rather than twenty.
Scenarios live in folders the whole team shares, built and rearranged by dragging. Every row says whose it is and where it came from — written by hand, or kept from a recording — and one recording is one scenario, not a new copy each time you open it. Labels you type become chips you can pluck off again, and the ones already used elsewhere sit underneath waiting to be clicked.
Choosing where something belongs is one control everywhere it is asked, and it browses in columns the way a system folder dialog does — with the last column showing what already lives in the folder you are pointing at, because you are not deciding where to navigate, you are deciding what this will sit next to. Typing filters, and every match carries the path it hangs under, so folders that share a name stay tellable apart. A new folder is made inside the picker, under whichever one is open, rather than by leaving what you were doing.
Because the folders are shared, someone else can rearrange them while you are looking at the same list — so the library is told when that happens and brings itself up to date, without you clicking anything or coming back to the window. That matters most in the case nothing else covers: two windows open side by side, neither of them ever brought back to the front, quietly disagreeing about where things are. The window that made the change is not disturbed by its own edit, and a list you are mid-drag through waits until you have let go.
A scenario remembers more than its last save. Every save that changes something becomes a version you can look back at — who changed it, when, and whether it came from the editor, the command line or an AI assistant — with the difference shown beside it, and going back never erases anything.
It can also have more than one version at once. A branch is a place to change something without everyone else seeing it half-finished: the row above the name says which one you are working on, one click switches, and the address carries it, so a link to work in progress opens exactly what you were looking at. The line above the run button says which version the next run will use — and it is a fact, not a label: the server takes the document from that branch, and refuses one it does not know rather than quietly running something else.
What runs at night is not simply the newest edit. A test suite has a production version, and a scenario reaches it one way: a promotion that somebody other than its author approves. Promoting is deploying, because production is exactly what the nightly watches run — so the review has its own address, and you can send it to the person who should look.
How far it reaches is on the screen before anything happens: how many scenarios change, how many watches will feel it, on how many televisions — and, the line worth the most, any watch whose scenario the promotion would delete, named while you can still do something about it. Otherwise that surfaces at three in the morning as a run that failed with nobody awake. Adding a commit cancels an approval, because what was approved was a particular shape and not an intention.
Watches say which version they run. New ones watch production; the other choice is offered with its consequence written out, so a freshly written test can be watched immediately if that is what you want — knowing that a mistake in it will also show up overnight.
A studio running work for several clients keeps them genuinely separate, not merely foldered apart. A switcher in the header decides which project you are in, and it follows you into the address — so a link you paste into a message means the same thing to whoever opens it. Scenarios, recordings, uploaded builds and watches each belong to exactly one project; televisions, people and teams belong to none, because a screen in the corner of the office is not a client's property. Rename a project and its address moves with it while every old link keeps working.
Each project is recognised without reading: a colour you can pick, or the client's own logo, framed by dragging and zooming it inside its square on a background that can match the logo exactly. Teams carry their own colour on the same principle. Nothing here is compulsory — a project without a logo simply wears a coloured dot.
And the client gets a screen of their own — Den. One day of a project's runs, written for somebody who does not use the rest of the app: what ran, what it found, and nothing about how any of it is wired. It speaks the app's own components rather than a second set built beside them, so what the client sees is the thing that actually ran.
The home screen: a glanceable summary of your devices, your favourites, recent recordings, and usage charts (activity, session lengths, busiest TVs) — plus a live bandwidth gauge for the operator.
Real logins with roles, two-factor authentication for everyone and 30-day trusted devices. Teams scope who can see which TVs; presence and hand-over stop two people fighting over one set; every meaningful action is written to an audit log. People have names, not just addresses — a first name, a surname and an optional second surname, which is also where the initials in the corner of the screen come from.
Joining a team is an invitation, not a list. An admin sends one to an address; the link opens a page naming exactly one team and nothing else. Signed out it offers an account with a password of your own — no handoff of a temporary one. A token that is expired, already spent, revoked or never issued gets the SAME neutral refusal, so the address cannot be used to find out which teams exist.
When a TV or its box stops responding, a smart plug on its socket can power-cycle it remotely. Discovered on the network, controlled by the box, gated to admins and audited.
A superadmin can scan a site's network from the box to find cameras, TVs and plugs — each picked up with its MAC address. Because devices are tracked by MAC, a TV or camera that gets a new IP overnight is followed automatically, with no manual fixing.
Get a Tizen app onto the (selected) Samsung TVs without a laptop or Tizen Studio. A superadmin uploads the
site's signing certificates once (kept encrypted on the box, never in the cloud); the box then signs a
.wgt and pushes it straight onto the TV over the network — install and launch in a click, with
each step reported. It even re-signs another company's app with your certificate so it installs, and reads
the TV's DUID for you. Proven end-to-end on a real Samsung TV.
Recordings are kept within a per-user quota with a system disk reserve. When space runs low, the oldest un-starred clips are evicted automatically — starred ones are never touched, and every eviction is logged.
Point an AI client — Claude, or anything that speaks the Model Context Protocol — at your sets. It can read their state, health, recordings and stats, and drive the TV: press remote keys, switch power, replay a recorded scenario. Each agent acts with the rights of the user who connected it — never more — and every action is audited as that person. A thin, stateless server forwards your token to the relay, which stays the single authority; it holds no standing credential of its own. How MCP works →
See these on the real screens in the app walkthrough, the technical design in architecture, or the deep dive on the MCP API.