On-device AI and cloud AI: where your voice notes go
When you dictate a note and an app turns it into a task, several separate things happen. Knowing which of them run on your phone is the difference between a private feature and a shared one.
On-device AI processes your data using models that run on your phone's own hardware, so the content never leaves it. Cloud AI sends your data to a server for processing. Most apps use a mix of the two, and almost none explain where the boundary sits.
This matters more for voice than for anything else you do on a phone. A voice note is not a sentence. It is your voice, the acoustics of the room, whoever else was talking, the twelve seconds of throat clearing before you got to the point, and the thing you said and then decided not to keep.
Text you can proofread. Audio captures what you did not mean to say.
One sentence, four separate steps
You tap a microphone and say: remind me to call the clinic about the results on Tuesday morning. It feels like one action. It is four, and each can run locally or remotely, independently of the others.
| Step | What happens | Can it run on device? |
|---|---|---|
| Capture | The microphone writes audio to memory or a temp file | Always local, by definition |
| Transcription | Audio becomes text | Yes on recent iPhones |
| Interpretation | Text becomes a task with a date and a reminder | Yes, with a small local model |
| Storage | The result is written somewhere | Depends on the app's sync model |
An app can transcribe locally and interpret in the cloud. It can do the reverse. It can send both away and still describe itself as private, quite truthfully, because the finished task ends up stored on your phone.
So the useful question is never does this app use AI. It is which of these four steps leave my phone, and what exactly is in the payload when they do.
What actually gets sent
This is where the detail matters, because the three common routes have very different exposure.
| Route | What leaves your phone | Exposure |
|---|---|---|
| Fully local | Nothing | None |
| Local speech, remote interpretation | The transcript, plus context the model needs | Your words as text, without your voice |
| Fully remote | The audio recording itself | Your voice, the room, anyone else audible |
The middle row is worth dwelling on, because it is the most common design and the least understood. Your voice never leaves, which genuinely matters. But the transcript often travels with context so the model can resolve references, and that context can include the note you currently have open or the name of the project you are in.
An app that sends context should be able to tell you what is in it. If it cannot, nobody has thought carefully about the answer.
What on-device buys you
When transcription and interpretation both run locally, the audio and the text never exist on anyone else's hardware. There is no server log, no retention window, no subprocessor agreement, and no breach surface, because there is nothing at the other end to breach.
It also means the feature works on a plane, on the Underground, and in a country where you would rather not push your calendar through an unfamiliar network.
Apple has moved a lot of this capability onto the device. Speech recognition and small language models now run locally on supported iPhones, which is what turned a fully on-device path from an aspiration into something an app can actually ship.
What on-device costs
Being straight about the trade is part of the argument.
- Hardware floor. On-device models need recent silicon. Older iPhones cannot run them at all.
- Language coverage. Local models support far fewer languages than large server models, and support arrives unevenly.
- Capability ceiling. A model small enough to fit on a phone is less capable than one running on a rack of GPUs. Unusual phrasing is where you feel it.
- Storage and setup. Local models take space and often need a one-time download that can fail on a bad connection.
- Battery and heat. Sustained local inference costs more power than shipping a request to a server.
This is why nearly every app keeps a server path available. Keeping one is reasonable engineering. The question is whether the app tells you when it takes that path, or switches silently and lets you assume the best.
How to test an app yourself
You cannot read the source, but three checks get you most of the way.
Run it in Airplane Mode
Turn the network off and use the voice feature. Full success means both transcription and interpretation are local. Total failure means at least one stage needs a server.
Partial success is the interesting result. If your words appear as text but nothing becomes a task, you have found the boundary precisely: local speech, remote interpretation.
Read the Audio Data line on the label
Apple's privacy labels have a specific category for Audio Data and another for Other User Content. An app that uploads recordings is required to declare the first.
A voice-first app declaring neither is either fully on device or has filed carelessly. Either way you have learned something, and the Airplane Mode test will tell you which.
Look for named subprocessors
A privacy policy that names the specific companies in the chain is a much stronger signal than one referring to trusted partners. Naming a subprocessor is a commitment somebody can be held to. Trusted partners is a phrase that survives any change of vendor without an update.
How Clarity handles voice
On a supported Apple Intelligence iPhone with a supported language, both transcription and interpretation run entirely on device. Nothing is transmitted, and the feature keeps working with the network off.
When a local stage is unavailable, Clarity uses a disclosed fallback for that stage only, and only for a voice action you started. If local speech works but local interpretation does not, your audio stays on the phone and only the transcript travels. That is the middle row of the table above, and we would rather name it than let you assume the best case.
There is no background listening, no wake word, and no always-on microphone. Voice starts when you tap the microphone and stops when you tap stop.
The short version
Ask which of the four steps leave your phone. Test it with the network off. Read the Audio Data line. Check whether the policy names names.
An app that can answer all four clearly has thought about the problem. An app that answers none of them has probably not, and the marketing page is unlikely to be where you find out.
Common questions
- Does on-device AI mean nothing is sent to the internet?
- For that processing step, yes. The audio and text stay on your phone. The app may still make unrelated requests, such as checking a subscription, so on-device describes the AI processing rather than the entire app.
- Is on-device AI less accurate than cloud AI?
- Usually somewhat, because on-device models are smaller. For everyday phrasing like scheduling a reminder the gap is small. For long, unusual, or heavily accented input, a large server model still has a real advantage.
- How can I test whether an app processes voice locally?
- Turn on Airplane Mode and use the voice feature. If it completes normally with no network, transcription and interpretation are both running on your device. If text appears but no task is created, only transcription is local.
- Which iPhones support on-device AI processing?
- Apple Intelligence features require recent iPhone hardware and a supported language. Apps relying on local models generally fall back to a server path on older devices, and a well-built one will tell you when it does.
- Is a transcript safer to send than audio?
- Meaningfully, yes. A transcript contains your words but not your voice, the background, or anyone else who happened to be speaking. It is still your content, so it is better than audio rather than harmless.
A quieter place to keep all of this
Clarity holds tasks, habits, notes, projects, and your calendar on your iPhone, with no account and no tracking. Free to start.
