Green Room: a breath coach for people who talk for a living
My entry for the Presage SmartSpectra SDK Challenge. #presagechallenge I started this project by reading the Presage model cards, and one line stopped me: breathing rate and the breathing traces do not work when talking That is the worst possible limitation for a speaking coach. The people who need

breathing feedback most are the ones who are mid sentence, and that is exactly when the camera refuses to measure their breath. So I built the app around the limitation instead of around the feature. Green Room is a breath coach for people who talk for a living. Teachers, pastors, sales people, podcasters, anyone whose job happens to be a long run of unbroken speech.
You open it, sit still for thirty seconds, then talk. It watches you through the camera. When you have been talking for too long without a pause and your pulse has climbed, the screen dims and one word appears: Breathe. Then you take a pause, and the app measures it.
Not notices it. Measures it, and tells you the length: 1.5s of air. At the end you get a summary. How long you actually talked, your longest stretch, how many times it had to nudge you, the average length of your pauses, and your resting breathing rate before the session compared with after.
Two badges sit on the dashboard the whole time and never go away: β NO MICROPHONE β RECORDS NOTHING That is the design thesis in two labels. The camera knows you are talking and it has never heard your voice. Under the hood: the Presage SmartSpectra Node SDK 3.5.0 doing on device measurement, an Electron shell for the desktop version, and a headless Node runner that serves the same dashboard at localhost:8787 for anyone whose machine will not run Electron. Requests three metric bundles, breathingMetrics, cardioMetrics and faceMetrics, turns SDK telemetry off, and decodes protobuf in the main process so the renderer only ever sees about a dozen plain numbers.
https://youtu.be/4dFoQk0SNGY Two minutes. What to look for: the consent screen before the camera opens the 30 second silent baseline, and why it is silent the ribbon filling while the talking badge is on the word Breathe, with the reason underneath it the pause being measured, 1.5s of air the summary at the end Honesty note, and please read this before judging the video. On my own Windows machine the SDK's device pairing step fails at the Windows crypto layer, so the encrypted models never load and the live signal never starts. The full log and everything I ruled out is further down.
The video therefore shows the app running in demo mode, where a scripted speaker is pushed through the identical coaching code. The interface, the timing, the cue and the summary are real code doing real work. The numbers are generated, and I say so out loud in the video. The summary the app serves at localhost:8787/summary, from the run in the video.
Fifty seconds of speech inside a hundred and thirty six seconds, one stretch of forty seconds, one cue, and one pause of 1.5 seconds. Resting breathing 14.17 before, 13.69 after. 5-DEMO.cmd and npm run demo are in the repo. Anyone with a working key can run 2-RUN.cmd instead and get the same thing driven by their own face.
https://github.com/hameedeeno/green-room git clone https://github.com/hameedeeno/green-room cd green-room npm install # with an API key in .env npm run headless # or double-click 2-RUN.cmd on Windows # no key, no camera, no SDK: scripted speaker through the real logic npm run demo npm test # 9/9 passing On Windows there are double click files, because I am not the only person who finds a terminal hostile: 1-SETUP.cmd, 2-RUN.cmd, 3-CHECK.cmd, 4-KEY.cmd, 5-DEMO.cmd, and 0-DIAGNOSE.cmd which writes a support report when something breaks. START-HERE.md is the plain English guide, including the mistake I made first, which was running the files from inside the zip without extracting it. The repo is organised so the interesting part is readable: src/coach.js is the entire coaching brain and it has no SDK import, no DOM, no timers and no I/O. scripts/test-coach.cjs is the suite that proves it.
Three signals, and the app treats each one according to what the model cards actually promise. Signal Valid while talking What Green Room does with it face.talking yes the primary signal. The streak of unbroken speech, and the pauses that end it cardio.pulseRate yes, if you stay still the tie breaker. A cue needs a pulse about 6 bpm over your resting baseline breathing.rate no read only in silence.
It builds the baseline before you start and compares it after you stop HRV context only not used for any decision, and not shown as a number So the loop is: Baseline. The first 30 seconds must be silent. The coach collects breathing samples, refuses every sample that arrives while you are talking, and takes the median of at least six good ones. Until it has that, it will not coach at all.
Thirty seconds of patience buys a number that means something. The streak. Talk and the ribbon fills. A gap shorter than 700 ms is still the same stretch, because people breathe mid paragraph and a mouth closing for a moment is not a pause.
The cue. It becomes possible at 25 seconds of unbroken talk, and it fires when your pulse is 6 bpm or more above baseline. If the pulse is unreadable, the app still coaches: at 40 seconds of unbroken talk it cues on the clock alone. Then it shuts up for 20 seconds, because a coach that nags is a coach you close.
The pause. When you finally stop, the gap is measured. Anything over 1.2 seconds is recorded as a real pause with its length. That number is the point of the whole thing.
Nobody knows how long their pauses are, and everybody is wrong about it. Here is the decision itself, from src/coach.js: if (streakMs < this.opts.cueAfterMs) return null; // too early const pulseIsUp = hasPulse && pulseRise >= this.opts.pulseRiseBpm; const tooLong = streakMs >= this.opts.hardCueAfterMs; if (!pulseIsUp && !tooLong) return null; // still fine, leave them alone Two of the nine tests exist purely because of the model cards. One asserts that a breathing sample reported while talking never enters the baseline. The other asserts that the coach still cues when pulse is unreadable.
The rest cover the ordinary things: no cue during baseline, exactly one cue per stretch, a 400 ms gap not breaking a streak, a real pause recorded with its length, the cooldown holding, and the before and after breathing buckets staying separate. One engineering note. The SDK hands out protobuf buffers. Rather than drag protobufjs and a Buffer polyfill into a renderer bundle, Green Room decodes in the main process and sends the renderer the numbers it draws.
The renderer therefore touches no Node globals and the bundle stays free of FFI. This is the section I care most about, because a camera based coaching tool can be creepy very easily and it does not have to be. Consent before the camera. Nothing opens until you tick the box that says the camera will be used to measure breathing, pulse and facial movement, that metrics are wellness information and not a medical assessment, and that nothing is stored.
The camera does not open while the box is empty. The preview stream is yours to see, so you always know the camera is live. What happens to the video. Frames go from the camera into the SmartSpectra SDK inside this app's own process.
My code never writes a frame to disk, never encodes a frame, and never sends one anywhere. There is no recording feature, and no code path that could produce one. When you close the window, the camera stops. There is no microphone at all.
Green Room never calls getUserMedia with audio, and never asks for the microphone permission. Windows will not show a mic indicator for it. Speech detection is visual: the SDK reads the face. What is stored.
Nothing. The metrics live in memory for the length of the session so the ribbon and the summary can be drawn. No database, no local storage, no log file of vitals. The only file the app ever writes is .env, which holds your API key, and you can delete it whenever you like.
Retention and deletion. Retention is zero seconds. There is nothing to delete because nothing was kept, and the summary disappears when the window closes. If you want the app gone entirely, delete the folder.
Sharing. None. No analytics, no crash reporting, no third party scripts, no fonts or assets fetched from a CDN. The dashboard is served from 127.0.0.1 by the app itself.
SDK telemetry, and why I turned it off. The SmartSpectra SDK has telemetry on by default. When it is on, each device readiness check sends Presage a diagnostic report: device and SDK details, requested metrics, camera settings, performance timings. It does not include video frames or vital signs, and Presage documents that clearly.
I still turned it off, with enableTelemetry: false, because a wellness tool should default to silence, and a user should not have to discover a setting to keep their hardware details to themselves. Anyone who wants those diagnostics can turn it back on. The one honest caveat. The SDK authenticates against Presage over HTTPS with your API key, and it fetches its encrypted measurement models from Presage.
That is the one time this app talks to the network, and it happens before measurement starts. No video, no audio and no vitals go with it. I would rather write that sentence than let someone find it out later. Bystanders.
Green Room measures the person in front of the camera. Do not point it at someone who has not agreed to it. The dashboard is visibly on screen, the badges say what is happening, and there is no hidden mode, because a tool like this only works if the person being measured is the person holding the laptop. Not a medical device.
Green Room does not diagnose, treat, score, or predict anything. It counts seconds of speech and compares a breathing rate before and after. Presage's own metrics are wellness information, not clinical measurements, and the app says so on the consent screen and in the README. No optional AI service is used.
There is no LLM in the loop, no requestInsight call, no cloud analysis. Every decision in the app is arithmetic in a file you can read in one sitting. I am early in learning to build software, and this project is the first time I have integrated a real vendor SDK. So the honest version of this section is: it did not work, and finding out why taught me more than the parts that did.
On my Windows 10 machine the install is fine, the tests pass, the key is saved, the camera opens, the SDK starts. Then it stops, at the step where it pairs the device with Presage so it can fetch its encrypted models: Device key provisioning did not complete; continuing with locally-available models. Remote EMD model delivery is unavailable this session: NCryptDecrypt(size) failed: Invalid flags specified. (-2146893815) ...
device_id is required for remote model download SmartSpectra::Initialize failed: SmartSpectra configuration failed. -2146893815 is 0x80090009, NTE_BAD_FLAGS, raised while persisting the device key. Before I blamed anyone, I checked the boring things: the API key is valid and the app authenticates the service is up: https://cont-api.physiology.presagetech.com answers {"msg":"HEALTHY"} TLS from this app is clean, h2 with a public certificate and no interception the pairing endpoint is reachable from here, it answers HTTP 403 without a token, which is correct Windows is not in FIPS mode, and both KeyIso and CryptSvc are running not a version problem: 3.3.0, 3.4.0 and 3.5.0 all contain the same WindowsProtectedDataDeviceKeyStore path not fixable with local models: requesting only face metrics still fails, because expressions-inference is also delivered remotely It is reported to support@presagetech.com with the log and the Windows build. If they come back with a fix, 2-RUN.cmd starts measuring and the demo mode becomes a fallback nobody needs.
What I refused to do was rebuild the same folder six more times and hope. Instead I made the failure legible. The runner now probes DNS, TLS, ALPN and the pairing endpoint at startup and prints the verdict in three lines, 0-DIAGNOSE.cmd writes a report you can send to support, and every error message says what to do next instead of dumping a stack trace. Then I built demo mode so the product could still be judged on its own behaviour.
Being blocked by a dependency is normal. Being unable to explain where you are blocked is the part that is my fault. I am entering both, and I will be specific about why. Most Creative or Delightful Use.
The moment is that the app knows you are talking and has no microphone. People assume speech detection means audio. Watching the talking badge light up while the mic badge sits there untouched is the entire idea in one frame, and it is unexpected in a way you can feel in two seconds. The second delightful thing is the restraint.
It waits 25 seconds, checks your pulse, and then says one word. In a category where everything shouts, a tool that says Breathe once and then goes quiet for 20 seconds is doing something different. And the twist underneath it is my favourite part: the limitation in the model card became the interaction. The camera cannot hear you run out of air, so the app counts the silence instead.
Best Thoughtful Real-World Use. The need is concrete and unglamorous: people who speak for a living lose their breath in the middle of a sentence and have no idea. No wearable, no app to remember to open, no microphone to feel self conscious about. The camera you already own, measuring what it can see.
The usability work is real: a thirty second silent baseline that explains itself, one cue with a written reason, a cooldown, and a summary with numbers you can act on tomorrow. Consent is a gate rather than a paragraph, telemetry is off by default because I think that is the right default, and nothing is stored, so there is no retention policy to trust, there is just no data. Responsible data handling is easier to argue when you can say "we kept nothing" and mean it literally. Six sessions of baseline data over a week, so the cue can compare you to you instead of to a fixed 6 bpm A pause rhythm view, because the length of pauses may matter more than the count A second person mode is deliberately not on this list.
The app measures whoever is in front of it, and I would rather keep that number at one I built this with an AI agent in the loop, so I want to be specific about the split, because "made with AI" tells a judge nothing. The agent wrote most of the code with me, and it wrote this post's first draft. I decided what to build, I hit the wall on Windows, I ran every test and every install, I took the screenshots, and I made the call to submit with the failure documented instead of the failure hidden. The design constraint that makes the app interesting came out of a model card neither of us was expecting to be the whole point.
presagechallenge
Key Takeaways
- β’So I built the app around the limitation instead of around the feature.
- β’This story was reported by Dev.to, covering developments in the dev space.
- β’AI advancements continue to reshape industries β read the full article on Dev.to for complete coverage.
π Continue reading the full article:
Read Full Article on Dev.to βShare this article



