Talking to the factory: from Telegram buttons to car voice

The first problem was getting away from the keyboard. A coding agent could keep working after I left my desk, until it needed permission or had a question. Then it waited. I built Claumon to put those interruptions on my phone.

It connected Claude Code and OpenCode to Telegram. A permission request became a few buttons. A question became something I could answer without finding the terminal it came from. Small machinery for a fairly ordinary ambition: go somewhere else while the computer gets on with it.

Its useful life, for me, was short. Then Claude Code got Remote Control, which connects a local session to the phone or browser. Much of the reason I had built my own bridge was suddenly a feature of the thing it bridged.

Claumon is still open source, and a Telegram bridge can still be useful, particularly outside Claude Code. But I no longer needed to treat it as my answer to remote access. A tool can solve a real problem and still have a very short run.

The computer speaks

Later I experimented in the other direction: getting text out as speech.

The local text-to-speech work used Qwen3-TTS through a C++ implementation. There were voice auditions, saved voices and longer narration experiments. The interesting part was keeping a voice recognisable across a passage long enough to hear its seams.

A written description of a voice wasn’t enough. The same brief and seed could give different speakers when the text changed. The practical route was to choose a voice, save its speaker representation, and reuse that for the next passage. Then listen across the joins between chunks. A convincing sample was only the beginning of the test.

The experiments also had to share a machine with the rest of the stack. Loading a speech model again for every chunk competed with the local language models for disk and shared memory. The narration script ended up sending work to an already-running server. It would fail if the server wasn’t there, rather than start another model on its own.

That was a useful distinction to learn in something as apparently harmless as reading a paragraph aloud. Giving the computer a voice still means making decisions about the computer it runs on.

I speak to the computer

Conclave Voice went the other way. It is a Windows dictation adapter around whisper.cpp: record speech, transcribe it locally, and turn the result into text another program can use. A dictionary helps with the names my projects have accumulated.

At the desk, speech fits alongside the scratchpad and direct typing in Control Tower. I can get a thought into a coding session without composing every word at the keyboard. The terminal and its work are still there to inspect.

But “the transcription is right” and “the right session received it” are different tests. A window handle doesn’t identify a terminal tab or a Tower tile. The adapter’s current delivery contract is conservative: plain text on the clipboard by default for those destinations, with a weaker paste option available by deliberate choice. It doesn’t press Enter for me. That describes the adapter’s contract; it doesn’t certify what every running listener has loaded.

Tower’s own voice input is a separate integration. That matters because a recording, a transcript, text in an editor and a submitted instruction are four different points in the journey. It is easy for a voice interface to make the middle two feel like the last one.

Then try it from the car

The car experiments changed the problem again. The path was Siri dictation, Telegram, Conclave mail, then an agent session, with an answer read back. The first version made me listen to a numbered list of sessions and pick one.

That works as a prototype. It is also a tedious way to say, “Ask the session working on this.”

Getting the iPhone end working took about two hours of tinkering. I had made a contact containing the Telegram bot’s details and given Telegram access to that contact. That seemed like the permission it needed. On my phone, it wasn’t enough.

I eventually had to allow Telegram to read my entire phone contact list before the setup worked. The bot’s details were already in the contact I had allowed it to see, but granting access to that one contact hadn’t done the job. Two hours to find the difference between those two permissions.

The devil is in the detail. The AI era still includes spending two hours on a permission setting. That part of computing hasn’t changed much since the days of the floppy disk.

The test notes have a better example than any abstract requirement: Siri turned “bittensor” into “Spencer session”. A router that requires an exact session name is already in trouble. So is one that confidently chooses the closest string when two similarly named sessions are working on different things.

The next version put routing in Conclave, where the session and coordination records already live. A clear name can identify a recipient. A less certain match asks for confirmation. A confirmed correction can teach it a spoken alias. Context about a session’s lane helps suggest where an unnamed note belongs.

My preference was one short question: “For this session?” A model could help when the deterministic matching was unsure, but the router didn’t need a model call for every note, or anything running while idle. If a recipient needed to pass a note to a better-fitting live peer, the design allowed one forward and told me about it.

There are physical-interface details here that disappear in a desktop demo. Siri doesn’t reliably announce a second message while it is reading the first. A long list can turn into another “read it?” prompt. The shape of the answer matters as much as the matching algorithm.

The routing code is built. The complete car experience is still experimental: the retained work list includes the next drive’s checks and a permanent home for the Telegram edge. I wouldn’t call it a finished hands-free control system.

Several doors into the same workshop

These experiments meet at the same stack. Claude Code and Codex do the work. Conclave keeps the shared coordination record. Tower lets me see the sessions and enter instructions. The local speech tools add ways to get words in and out.

Remote Control took over much of my original reason for Claumon. It didn’t remove the question that became more interesting as the fleet grew: which session should receive this thought, and what happened after I sent it?

That’s where car voice sits now. The next useful test is a drive with the router, a few deliberately awkward names, and a record of where the notes actually landed.

Tomorrow morning, on the drive to work, I have to choose: put the voice router through those tests, or listen to the AI Daily Brief podcast.

Tough choice.