-
-
OneCentDemo: one sentence in, a narrated product demo out.
-
The problem: a good demo takes hours, and goes stale the week the product changes.
-
Map, script, drive, record: Nemotron 3 Ultra on Nebius Token Factory writes the founder's script.
-
A live run on app.onecentdemo.com: five stages, and the founder's script it wrote.
-
A frame from the demo it made for Selvage, another of our products.
-
Architecture: Cloudflare Worker, a recorder container behind a request gate, Nemotron on Token Factory.
-
A demo you can make again every time the product changes. Open source, MIT.
Inspiration
Every founder needs a product demo, and every demo goes stale the week after it's recorded. Making one means writing a script, clicking through the product while recording, re-recording when you stumble, and recording a voice-over. That's hours of work, so most products ship with an old video or none at all. We wanted a demo you can make again in a minute, every time the product changes.
What it does
Type who the demo is for and what it should show, plus your site's address. For example: "Why verification is important and what's missing in coding agents today. Introduce Selvage to Developers."
- It explores your site like a visitor: pages, menus, listings and their filters. Pages behind a login are noted but never forced.
- NVIDIA Nemotron writes the founder's script. It reads the brief and what the site actually says, writes the voice-over a founder would give (the problem, why each screen matters, the payoff), and picks the pages to show.
- A real browser records it. Pages scroll smoothly, menus open, filters get ticked, and each element used is outlined.
- It's narrated in one take and fitted to what was recorded. You get an MP4 to download.
It's honest by design. If a step fails, the video ends on the error and the narration says so. It never signs up, deletes or works around bot protection. When the good part of a site is behind a login, the script tours what a visitor can see and ends on what signing up opens. It says this rather than faking a screen.
There are two ways to use it: the hosted app at app.onecentdemo.com (sign in, no install), or the open-source CLI on your own machine with your own keys.
How we built it
- NVIDIA Nemotron 3 Ultra on Nebius Token Factory does the thinking. It writes the founder's script and picks the shots, fits the narration to the recording, plans routes to a goal, and reads pages (filter values, form values, items worth pointing out). The script steps run with thinking on and the fast steps with it off; see below.
- Jev, a small decision model on Cloudflare Workers AI, makes each click decision in about a quarter of a second. A vision model checks the result.
- The recorder drives Chrome over the DevTools protocol, frame by frame, and assembles the video with ffmpeg. ElevenLabs speaks the voice-over.
- The hosted app runs on a Cloudflare Worker, with the recorder in a Cloudflare Container. Clerk handles sign-in (email code, Google, GitHub), D1 holds credits (a demo that ends without a video is refunded), and R2 keeps finished demos.
- Safety. In the container, Chrome reaches the web only through a gate that checks every request, redirect and subresource when it's made. A page can't steer the recorder into the container or a private network.
Using Nemotron: what we measured
- Thinking on vs off is a per-step choice. With thinking off, the founder's script came out as captions of the screen ("Select $126 to $150 range."). With it on, it keeps a founder's voice and sticks to facts on the page. The script runs only twice per video, so the extra seconds are worth it. Route plans run at every step, so there we turn thinking off.
- Model choice. We tried the four Nemotron models on Token Factory for route planning. Ultra with thinking off planned the GitHub route best (Open Source → Trending → This week → a repo) in about 1 s. With thinking on, every model took 4–15 s per plan.
- End to end: with Nemotron doing this work, a sentence becomes a narrated video in about 16 s.
Challenges we ran into
- Scripts that sound like a person. Early scripts narrated the route ("we open the menu, then choose…"). Writing the script first, from the brief and the site's own words, and recording to match it, fixed that. So did thinking on.
- Sites behind a login. On reafi.ai, the app pages sent a visitor to /login. The tour kept landing on the login page, and the voice talked about dashboards over it. Now the explorer notices a redirect to a sign-in form, skips those pages, and the script ends on what an account opens.
- Sites that scroll smoothly. On selvage.run,
scroll-behavior: smoothmade each jump to the top animate, so the tour clicked a link while the page was still sliding away. Every scroll the tool makes now lands at once. - Links that aren't pages. A link to selvage.run's .svg diagram made the browser navigate mid-read and stopped the whole map. Those links are now skipped and the map carries on.
- Pages drawn by JavaScript. React sites report "loaded" while the page is still empty, so the explorer waits for real content before reading.
- Running a browser for strangers safely. Checking the first URL isn't enough, since a page can redirect anywhere. That's why every request goes through the gate.
Accomplishments that we're proud of
- A full narrated demo in seconds, from one sentence, of a site the tool has never seen.
- The video never lies: no faked success, no faked screens.
- It's both a hosted product with sign-in and credits, and an MIT-licensed tool anyone can run.
What we learned
Treat the language model as a writer, not a pilot. Nemotron is best at deciding what to say and which screens make the point. The fast, repetitive work of clicking belongs to a small, quick model. Writing the story first made the demos feel human.
What's next
- Demos of logged-in screens on the hosted app, with a test account that's used once and deleted.
- Re-recording automatically when the product changes, so a demo is never stale.
- The same demo cut for different audiences: investors, customers, a new teammate.
Built on
The project started on 24 September 2026, during the submission period. It builds on browser-use's open-source jev-ultrafast and laya-ultrafast (MIT), which drive a browser with the Jev model, and on browser-harness (MIT). Everything else was built for this hackathon:
- the site explorer;
- the founder's script and shot list on Nemotron;
- the frame-by-frame recorder and narration;
- the Nebius Token Factory integration;
- the hosted app (sign-in, credits, the safety gate).
