NAOMS can speak now. When it has something to tell you, it can say it out loud, in a warm, natural voice instead of the flat robotic one most computers reach for. You set it up with a single command, and from then on the system talks.

That's a nice little feature. But it is not the interesting part, and we'd be selling you short if we stopped there. The interesting part is a question almost nobody asks about a talking computer: where does the voice actually get made?

The detail almost every talking assistant gets wrong

When your phone, your speaker, or your favourite assistant reads a sentence aloud, here is what is usually happening behind the curtain. Your text gets packed up and sent across the internet to a company's servers. A model there turns it into audio. The sound travels back. You hear a voice.

It works beautifully and it's easy to build, which is exactly why nearly everyone does it that way. But notice what just happened: the sentence got sent away. And the sentences a personal system speaks are not neutral. They're the reminder about your health appointment. The name of the person you're meeting. The thing you asked it to read back to you in private. For a normal assistant, shipping those words to a server is a footnote nobody reads.

For NAOMS it would be a contradiction. The entire reason this system exists is a single promise: your stuff stays yours, on your own device, not pooled on someone else's computer. A system built on that promise cannot turn around and quietly mail every spoken sentence to a cloud voice service. That would be a betrayal hiding inside a friendly feature — and a friendly feature is the easiest place in the world to hide one.

So we made the voice the same way we make everything else here: at home.

Making the voice in the room with you

The voice you hear is generated by a text-to-speech model — a piece of software that turns written words into spoken audio — called Qwen3-TTS. The important word isn't its name. It's where it lives: on your machine, running on your computer's own graphics chip (or its plain processor if there's no graphics chip to spare). No account. No server. No round trip. The words become sound right there, and the sound never leaves.

This is the same shape as the listening side of NAOMS, which we wrote about when we taught it to hear you without phoning home. Hearing stays local; now speaking does too. The system can have a full spoken conversation with you and, at no point in it, does a single one of your words touch a stranger's hardware. The loop is closed, and it's closed on your side of the wall.

That's the whole pitch. But pitches are cheap, and this one came with a real engineering problem we had to solve before it could be true and pleasant to use.

The catch: a local model is slow to wake up

Here's the uncomfortable tradeoff that a cloud service quietly hides from you.

A cloud voice service feels instant because the company keeps a giant, expensive model running around the clock, ready for anyone. You're borrowing a machine that's always awake. When you run the model on your laptop instead, you don't have a giant always-on machine. You have your laptop. And the model has to be loaded — pulled into memory and made ready — before it can say a single word.

We measured this honestly. On the developer's laptop, loading the model takes about seventeen seconds. That load cost dominates everything: a completely cold request — wake the model, then speak — took roughly twenty-seven seconds end to end. Twenty-seven seconds to hear one sentence is not a voice. It's a punishment. If that were the cost every time, nobody would turn the feature on.

The honest local-first path was at war with the experience.

The fix: keep the voice warm

The answer is a small idea with a big payoff: don't make the model wake up every time. Keep it warm.

Instead of loading the model fresh for each sentence, NAOMS runs a tiny helper in the background on your own machine that loads the model once and then just sits there, ready. It listens only on your computer's internal loopback address — the software equivalent of a phone line that only connects to itself, reachable by nothing outside your machine. When the system wants to speak, it hands the text to that already-awake helper, which skips the seventeen-second wake-up entirely and goes straight to making sound. A warm call came back in about ten seconds instead of twenty-seven.

flowchart TD
    A["NAOMS wants to say a sentence"] --> B{"Warm voice helper
awake on 127.0.0.1?"}
    B -- yes --> C["Hand it the text
(~10s, model already loaded)"]
    B -- no --> D{"Voice model
installed locally?"}
    D -- yes --> E["Cold path: wake model,
then speak (~27s)"]
    D -- no --> F["Fall back to the
built-in system voice"]
    C --> G["You hear it.
Nothing left the machine."]
    E --> G
    F --> G
    style C fill:#1f6f43,color:#fff
    style G fill:#1f6f43,color:#fff
    style F fill:#7a5c00,color:#fff

Notice the diagram has three rungs, not one. That's deliberate. The warm helper is the fast happy path, but a personal system can't require a background process to be perfectly healthy to make a sound. So speaking degrades gracefully: try the warm helper first; if it isn't running, fall back to waking the model cold; if the voice model isn't installed at all, fall back to the plain built-in system voice your computer already has. Speaking is best-effort, and it never hard-fails. The worst case is a less warm voice — never silence, and never an error in your face.

And the entire setup — the model, the background helper that keeps it warm, the plumbing that wires it into how NAOMS talks — installs from one command: naoms setup tts-voice. One line, and the system has a voice that lives at home.

A small honesty detail we're proud of

There's a touch in here that we love because it's exactly the kind of thing a less careful system would get wrong without noticing.

The voice has a bit of butler-like politeness to it; by default it'll round off what it says with a courteous honorific, the way a good butler would. Pleasant. But here's the rule we wrote for it: that politeness is added to the spoken audio only. The system also keeps a plain written log of every message it was actually asked to say — a record other parts of NAOMS rely on to reconstruct what you were told. That log keeps the literal message, with none of the voice's flourishes added in.

Why fuss over something so small? Because politeness is a performance for the ear, and a record is a fact. If we let the charming spoken version quietly rewrite the honest written one, we'd be mutating a record to make it sound nicer — and "no silent rewrites, the record is the record" is close to the soul of this whole project. The voice can be warm. The ledger stays literal. We don't blur the two, even by a single courteous word.

The honest catch we found after we celebrated

This one genuinely shipped. It cleared the project's close-gate and got celebrated, with ten passing tests and the voice auditioned out loud and approved. We're allowed to be happy about that.

We're also obligated to tell you what we learned the day after — because the same honesty rule that governs the log governs how we talk to you here.

"Warm equals fast" turned out to be true only up to a point. The model generates speech the way you read aloud: one piece after another, in sequence, so a longer sentence takes proportionally longer to say. A short phrase came back in about six seconds. But a normal-length sentence — seventy-odd characters, nothing exotic — sometimes didn't finish within ninety seconds, even with the model fully warm. On top of that, the original code was willing to wait that full ninety seconds, and while it waited it held a lock that made every other attempt to speak line up behind it. One slow sentence could jam the whole voice.

So "warm" was the right architecture, but it was not the same thing as "always quick," and we'd quietly let ourselves believe it was. The fix that followed caps how long the system will wait on the warm helper before it stops holding its breath and falls back down the ladder to the plain system voice — so a slow sentence is, at worst, a less fancy voice, not a frozen one. We're logging that here in the same breath as the celebration on purpose. A feature you only hear the good half of is a feature you can't trust.

Why a voice was worth this much care

We've argued before that the best technology is the kind you don't notice, and a voice is about as unnoticeable-when-it's-right as anything gets. You hear a sentence and move on. You're not supposed to think about where the sound was made any more than you think about where a friend's words come from when they speak to you across a room.

But that easy, unnoticed moment is exactly why it was worth the trouble. The convenient way to build a voice is to rent one from the cloud and let your sentences travel. The honest way is to make the voice where you are, eat the wake-up cost, solve it with a warm model, and own up to the spots where warm still isn't instant. It's a small surface. It's also the whole philosophy of NAOMS, shrunk down to something you can hear: the system saying a sentence to you, in a voice that was made in the room with you, and told no one else what it said.

Written by AI agents from real project logs; owned and edited by Mujo.