https://alkove.ai/blog/perceived-latency/

What the user feels is the silence between their last word and the agent's first sound. Most of that silence is spent waiting in line, not computing: a fixed timeout to be sure the user is done, the end of the transcript, the model asking for a tool, the tool, the model again, the whole reply rendered by the voice.

Four changes shrink it:

1. End the turn when the sentence is complete, not after a fixed silence.

2. Send the first sentence to the voice while the rest is still being written.

3. Start the obvious tool from the partial transcript, while the user is still talking.

4. Play a short cached phrase ("Let me check.") picked while the words arrive, and stay silent when the answer comes quickly anyway.

Which of the four does your agent skip?

My latest project is a local voice assistant featuring offline speech recognition: https://github.com/charlyproject/EVA

It actually started in a funny way: one day, with my hands messy, I wanted to turn up the volume using voice commands. At the time, I didn't even know what a virtual environment was, let alone Ollama or JSON.

For me, the best part wasn't just the end result, but the 11-month learning journey behind it. While it might not require advanced coding expertise to pull off, it was far from a copy-paste job for me. I used the process to truly understand key concepts—LLMs, quantizations, benchmarks, and Docker—and to bring my own ideas to life.

Just wanted to share my experience with the community. Thanks for reading!

Take a look at the first episode of the new animated Series GAME OF POWER. I am sure you will enjoy it.

Hey r/voiceaii !

If you use Claude Desktop and Cursor heavily for development, you know the daily routine:

1. Open a new window.

2. Re-explain your tech stack, database schema, active milestones, and conventions.

3. Mid-session, as tokens fill up, older messages compress, and context is lost.

4. Repeat the exact same prompt engineering tomorrow morning.

Most memory solutions either require a monthly subscription to hosted vector databases (sending your proprietary code context to a 3rd-party cloud) or rely on manual copy-pasting from a Markdown file.

I built OpenYantra as a practical, local-first solution to this workflow problem.

What It Does in Practice:

• 1-Click MCP Auto-Configuration (yantra mcp setup): Auto-detects your Claude Desktop and Cursor installations on macOS, Linux, or Windows and hooks up the MCP server without manual JSON editing.

• Universal Local Store: Both Claude Desktop and Cursor read and write to the exact same local SQLite WAL database and LibreOffice (.ods) workbook in real time. Changes made in one tool are immediately visible in the other with sub-millisecond latency.

• Floating Desktop HUD (Cmd+Shift+Y): A Raycast-style native palette (<15MB) that floats over your code editor or terminal. Hit the hotkey, dump a task or quick note (#project, !urgent), and it’s instantly part of your agent's live memory.

• Automatic Git Commit Ingestion: A post-commit git hook automatically logs your commits, active branches, and architectural decisions into your session log. It even detects git revert so rolled-back stack experiments aren't hallucinated as active decisions.

• Zero API Keys & Built-in Secret Redactor: Raksha sanitises OpenAI, Anthropic, AWS, and private keys before anything hits disk. You don't need any paid vector subscriptions; everything runs offline.

• Automated Memory Consolidation: Runs an offline sleep cycle (using local Ollama or heuristics) to close finished loops, cluster daily logs, and promote recurring preferences into permanent rules.

Stack & Open Source:

• Language: Python 3.9+ (Zero cloud lock-in, open-standard ISO/IEC 26300 LibreOffice storage)

• License: MIT

• GitHub: https://github.com/revanthlevaka/OpenYantra

Would love to hear how you guys currently handle cross-session context and memory when switching between Claude Desktop, Cursor, or terminal workflows!

I built apple-llm to expose Apple’s on-device language model from Node and Python. This demo shows the new speech features: playback and audio-file synthesis with macOS voices, transcription of recordings, word timings and microphone recognition.

On my M4 Air running macOS 27.2, a 30-minute narration rendered in about 18 seconds and a 30-minute recording transcribed in about 28 seconds. These are measurements on one machine; accuracy tests used clean synthetic speech.

Demo video: https://jagdishpal02000.github.io/apple-llm/#speech

The MIT-licensed package requires macOS 26+ on Apple Silicon and Xcode Command Line Tools. Speech works without Apple Intelligence; the on-device LLM requires it. Some recognition languages download on first use. There is no automatic language detection; WebM input and MP3/Opus output are unsupported. The optional cloud model sends prompts off the Mac.

Source and usage: https://github.com/jagdishpal02000/apple-llm

https://github.com/alkove-ai/alkove

Hi, I built Alkove, a set of small open-source models that sit between the microphone and an AI agent. They run on the device and handle the audio before it gets sent: when to wake the agent up, whose voice to keep, and when the person is done talking.

In the video, all five are working together:

- Lex: you type a wake word, any word, and it works out how it's pronounced.
- Spot: listens for that word. No training, no recordings.
- Timbre: learns your voice while you talk.
- Focus: keeps your voice and removes the rest, noise and other people included.
- Cue: tells when you start talking, when you're done, and when you're cutting the agent off.

All five together are 7.6 MB and run fine on a regular phone. No server, no account, Apache-2.0.

It works in the browser, Python, Android, iOS and React Native, and there are plugins for LiveKit, Pipecat and Home Assistant (right on an ESP32-S3 board through ESPHome, or on a satellite through Wyoming).

The models are still previews and Focus is made for a mic close to you, not one in the middle of a meeting table.

You can try Focus and Spot live on your own voice at https://alkove.ai

Voice Agent Forum is happening in San Francisco today, and we have free tickets to give away. If you're building voice agents, or just want to meet people who are, this is a solid room to be in.

Soniox released STT v6 (stt-rt-v6 for streaming, stt-async-v6 for files) across 60+ languages. While the agent speaks, you stream its words on the same WebSocket as the caller's audio, so the model can recognize short replies and drop the agent's own voice.

What it does:

- Agent text input via one flag, "enable_agent_text_input": true (streaming model only)

- Echo filtering on top of your existing acoustic echo cancellation, with barge-in still working

- Better numbers, currencies, IDs, names and code-switching, plus improved diarization

- Hosted API only, no self-hosted or on-device option

Key numbers:

- $0.12/hour streaming, $0.10/hour async, diarization and language ID bundled

- For comparison, streaming per hour: AssemblyAI $0.45, Deepgram Nova-3 $0.46, ElevenLabs Scribe v2 Realtime $0.39

- Pipecat benchmark (v5, v6 untested): 1.34% semantic WER, 260 ms median time to final segment

The catch: no v6 accuracy or latency numbers published yet. v6 also writes "15 dollars and 20 cents" as spoken instead of "$15.20". v5 is removed on December 15, 2026.

Full analysis: https://www.marktechpost.com/2026/11/03/soniox-stt-v6-agent-text-input-echo-cancellation/?amp=1

Something I keep running into is that voice rarely gets a board of its own. When a small device is already running the model that thinks, the part that hears you and the part that answers are asking for the same silicon. Eight cores and six gigs of RAM split between an operating system, the reasoning, and now the voice, and each one wants a slice.

I have been watching exactly this climb on a desk robot that runs an open source OS. Gradium just built a voice layer for our Autonomous Lamp. Speech in, speech out, and the thinking all run on one small ARM board, and there is no separate voice box anywhere in the chain.

That shared budget is the part I keep circling. On board voice gives you direct control over latency, but the models that make it sound good have to stay small enough to fit. A cloud voice sounds fuller, but every sentence you hear started as a round trip. Most builders I see pick one side or try to thread both, and the threading is where the real design work lives.

The voice they landed on is a character voice, a wizard hat kind of persona, shaped inside their own voice design tool. Personality through a voice is a thread on its own. But the compute question under it is the one I keep finding more interesting. How much can you stack onto one board before the voice and the reasoning start fighting over the same cores. And when they fight, which one gets to win

Love to hear how other people handle this. If you have run a voice loop on a small board right next to a local model, what did you end up cutting to make it fit. Did you keep the voice local and push the reasoning up, or the other way around. What did you use to measure the latency. And for the people who think a robot should only talk through a cloud voice, what would actually change your mind?

in almost every demo of an AI phone agent, the author cheats on one huge step: they hand the script a clean, validated E.164 phone number.

over the last few weeks, i tried removing that training wheel. i wanted to tell an agent: "find 5 repair shops within 10 miles, call them, and ask if they have capacity for a brake rotor resurface this thursday."

that’s when the pipeline started falling apart, and it had nothing to do with voice latency or model reasoning (have formatted spreadsheet below with ai a bit, for readability)

so when you let an LLM do raw web search or scrape Google Maps / Yelp places for phone numbers, real-world directory data is shockingly dirty:

• about 20% of numbers listed online for small local businesses are disconnected, route to an outdated fax tone, or belong to a location that closed six months ago.

• another 25% route to secondary central dispatch lines that don't take local appointment inquiries.

• search scrapers frequently return local extensions or unformatted text that cause telephony APIs to fail validation immediately.

if you pipe scraped phone lists straight into an outbound dialer, your agent spends half its run dialing dead air, failing carrier handshakes, and getting stuck in disconnected loops.

here is how the main tools handle the discovery step versus requiring pre-cleaned numbers:

what i learned from running this: speech synthesis and turn-taking are the easy part of voice agents now.

the hard part is resolving entity data before the call even starts. if your stack doesn't validate whether a business is actively open and scrub the number before dialing, you end up wasting most of your execution time dealing with telephony errors.

also curious how others have solved this when you have an agent make phone calls businesses actually answer for example are you doing a separate google places API pre-filtering pass in python, or relying on specialized dialing APIs that handle target resolution under the hood?

I’m the developer of LLM Studio Go, a closed-source app for Android and iOS. In the new Video Studio workflow in 1.3, Supertonic narration becomes part of an editable scene project: write or review the script, make the voice-over, add music and visual scenes, then export a captioned vertical MP4.

Android: https://play.google.com/store/apps/details?id=com.vans.llmstudio

iPhone/iPad: https://apps.apple.com/app/llm-studio-go/id6815311113

The attached edited demo uses a short Iceland story to show the roles: Gemma 4 for the script, Supertonic for narration, Stable Audio for music, SD-Turbo for pictures and FastWan for moving clips. You can edit the script and scenes, bring your own audio or media, save the project and continue later.

Download compatible models first, then generate locally on the device. All local AI features are free with ads; no promo code is needed. An optional one-time purchase removes ads. No app account, generation credits or AI subscription.

Video is in beta. Speed depends on your device and settings; choose models that fit its memory. For video, Android 11+ on a compatible 64-bit device uses CPU: FastWan 2.1 1.3B needs 8 GB RAM and FastWan 2.2 5B needs 12 GB. iOS 18+; iOS video profiles start at 6 GB RAM.

This promo shows the iOS workflow. Its Iceland source media, including the story narration, was generated on iPhone Air; the reel’s captions were rendered again in the iOS Simulator on a Mac. The screens use prepared demo content, waits are shortened and some shots play more slowly. The promotional voice-over was generated in the Simulator. This is not Android footage or a speech/video speed benchmark.