A file you embed — not a service you call.

What it detects — three levels, one engine

Start where your product is today; move up when it's ready. The upgrade path is built into the same engine.

• Snore detection — snore episodes with start, end, intensity, and confidence. The broad, easy-to-verify signal you can hear yourself. The low-friction way in.
• Breathing pauses — pause events with start, end, duration, and confidence. The signal that matters for apnea screening, and the one most products can't do well — validated against PSG. This is the part others don't have.
• Both, plus nightly indices — full detection plus per-night summary indices (sleep regularity, breathing patterns) computed on-device. The turnkey tier when you want indices, not just raw events.

Any level can run as a real-time stream — emitted per event as the night runs — or be read as a nightly summary.

The contract — what goes in, what comes out

The whole interface, on purpose: raw mic frames in, structured events out. The hard part — validated detection — sits inside; fitting the stream to your product is the part you own.

Your audio — your device, your call

The engine is stateless: it never holds, stores, or uploads audio. And because you own capture, the night's raw audio is already in your hands — keep it on-device if your use case needs it (research re-analysis, building your own corpus, audit playback), or drop it. "Audio never leaves the device" is the privacy story; "you can retain it on-device" is the research one — both are true at once. Whatever you store, the data-handling responsibility sits cleanly on your side.

What never leaves the engine

Separate from your audio — these stay inside, for anyone: extracted features, per-frame scores, model weights, thresholds, and the gating internals. That single boundary is both the privacy line and the IP line.

What ships

• The engine — the 56.4 KB model (9,416 INT8 parameters, 0.064 ms inference) plus the event pipeline, built for your platform: CoreML, TFLite, or an embedded chip. You embed an engine, not a raw model to interpret.
• The integration kit — a clean API, a sample app, and the docs. Mic frames in, events out.
• The validation pack — the methodology, per-seed metrics, and code behind the numbers: your team verifies before committing, and you have evidence to support your own filing if you ship in a regulated product.
• Source in escrow — you embed a compiled engine; the source sits in escrow, so you're never dependent on us still being here.

How integration goes

Mic frames in, events out. It runs on the device, so there's no inference server to stand up and nothing to scale. Most integrations are measured in days, not quarters — the model is the easy part; fitting the event stream to your product is where the real work is, and that's yours to own.

• On-device — runs on the phone or chip
• No cloud — audio never leaves the device
• Every night, real-time — a live stream your product can build on, not a morning batch

ApneaSense is detection only. What your product does with the events — surface them, log them, act on them — is your product, and your call. We don't respond, treat, or intervene.

Start with a small pilot

The first step isn't a contract. It's a focused, paid pilot — your device, your environment, a few nights of real data — from $15k, and creditable toward the license if you go ahead. That's where you benchmark it in your context, on your hardware, against your bar; we cover our time and prove the fit. Not a big commitment, not a long procurement.

If it proves out, the standard next step is a license — you embed the engine and integrate it yourself. That's the path that keeps you fast and keeps us out of your way.

Compliance

ApneaSense is a detection engine — not a medical device, and not FDA-cleared. If you ship it inside a regulated product, the regulatory responsibility is yours, and we write that into the license. If you go that route, we'll hand you the validation evidence to support your own filing.