Rodar um agente de voz no dispositivo
um pipeline, três orçamentos de memória.
Um agente de voz local não é um modelo — é um pipeline de quatro: detecção de atividade de voz, voz para texto, um modelo de linguagem e texto para voz, ligados por uma máquina de estados que gere os turnos. O pipeline é o mesmo num telemóvel e num portátil. O que muda é qual modelo entra em cada caixa, e isso é decidido por dois números: quanta memória tens e qual acelerador estás a alimentar.
O número a reter é o ciclo inteiro, não um único modelo: percepção da fala (STT) + geração da resposta (LLM) + síntese da fala (TTS) cabem todos lá dentro — ~1,2 GB no iPhone, ~1,5 GB num Galaxy S23 e abaixo de ~4 GB num Mac com um cérebro de conversa a sério.
O pipeline é a parte portável.
A orquestração vive no speech-core como uma máquina de estados em C++ puro, agnóstica ao modelo: as quatro etapas são interfaces onde ligas qualquer backend — ONNX, LiteRT, CoreML/MLX no dispositivo, ou até uma API na nuvem — por isso o mesmo pipeline corre um chamador de ferramentas de 270M num telemóvel e um cérebro Gemma 4 num Mac.
Um ciclo, quatro etapas. Uma palavra de ativação, AEC e realce são passos opcionais antes do VAD; são as chamadas de ferramentas do LLM que o deixam agir, não apenas responder.
O orquestrador é VoicePipeline no speech-core. Trata da detecção de turnos, interrupção, histórico de conversa, o ciclo de chamadas de ferramentas e a fila de fala — mas sem modelos próprios. Cada etapa é substituível atrás de uma interface (VADInterface, STTInterface, LLMInterface, TTSInterface) que implementas com ONNX Runtime, LiteRT, CoreML/MLX (via a biblioteca irmã speech-swift), ou até uma API na nuvem. Também há modos mais leves — Echo (VAD → STT → TTS) e TranscribeOnly (VAD → STT → texto).
Primeiro a NPU, e o ciclo inteiro cabe em ~1,5 GB.
Num telemóvel a restrição é memória, bateria e temperatura — não potência bruta. O alvo certo é a unidade de processamento neural (NPU): o Neural Engine da Apple no iOS, NNAPI / Hexagon no Android. Corre transformers quantizados a uma fração da energia da CPU ou GPU e deixa a CPU livre para o áudio e a interface.
Porquê a NPU e não a CPU ou GPU? Uma NPU é um motor de fluxo de dados de função fixa, construído para um só trabalho — a multiplicação-acumulação de baixa precisão de que são feitas as redes neuronais. Mantém os pesos em SRAM no chip, mesmo ao lado das unidades de cálculo, e salta a busca/descodificação de instruções e os caminhos de dados genéricos largos que consomem a maior parte da energia de uma CPU ou GPU. Mover dados custa muito mais do que fazer as contas, por isso manter ambos em local é o ganho: as mesmas multiplicações de matrizes correm a uma fração dos watts — sem throttling térmico, sem gasto de bateria, e a CPU fica livre para tudo o resto.
Por isso o pipeline móvel são modelos pequenos, quantizados e amigos da NPU: Silero VAD, Parakeet-EOU 120M (STT em streaming leve com deteção de fim de enunciado integrada), FunctionGemma 270M (o cérebro que chama ferramentas) e Kokoro-82M ou Supertonic-3 para a voz. Medido no dispositivo:
| Etapa · modelo | iPhone 16 Pro (CoreML / ANE) | Galaxy S23 (LiteRT / ONNX, CPU) |
|---|---|---|
| STT · Parakeet-EOU 120M | 0.04 RTF · 297 MB | 0.21 RTF · 232 MB |
| STT · Omnilingual 300M | 0.28 RTF · 495 MB | 0.15 RTF · 831 MB |
| TTS · Kokoro-82M | 0.08 RTF · 676 MB | 0.53 RTF · 640 MB |
| TTS · Supertonic-3 99M | 0.15 RTF · 956 MB | 0.34 RTF · 832 MB |
| LLM · FunctionGemma 270M | 128 tok/s · 236 MB | 118 tok/s · 611 MB |
RTF = tempo real ÷ segundos de áudio (menor = mais rápido; <1,0 é mais rápido que o tempo real). A memória de pico é por modelo, isolado.
Cada etapa bate o tempo real. Carregados juntos para um agente ao vivo, o conjunto residente é de ~1,2 GB no iPhone e ~1,5 GB no Galaxy S23 — a diferença é quase toda o LLM: o FunctionGemma ocupa 236 MB na ANE contra 611 MB na CPU do S23. O iOS já corre na NPU (daí os 0,04 RTF do STT e 128 tok/s do LLM); o Android hoje é tempo real em CPU, com os delegados NNAPI/Hexagon como extra, não como requisito.
Experimenta: Examples/iOSEchoDemo corre Parakeet + Silero + Kokoro como um ciclo de eco completo num iPhone; o lado Android vive em speech-android, a envolver o mesmo pipeline. (Examples/iOSBenchmark é a ferramenta por trás dos números do iPhone acima.)
Um LLM a sério que comanda a máquina — ainda abaixo de 4 GB.
Num Mac a restrição afrouxa: memória unificada partilhada entre a CPU e uma GPU Metal. As mesmas quatro etapas, modelos maiores e, sobretudo, um cérebro de conversa a sério em vez de um chamador de ferramentas de 270M — e o ciclo inteiro ainda cabe em ~4 GB.
O LLM é o cérebro, e é onde o tamanho do modelo deixa de ser opcional. Depois de testar, dois modelos ganharam o lugar: FunctionGemma 270M no móvel (suficiente para emitir uma chamada de ferramenta, tudo o que um agente de telemóvel precisa) e Gemma 4 E2B/E4B (4-bit MLX) no desktop (conversa multi-turno e raciocínio a sério que aguentam, mantendo-se leve). O tentador meio-termo — um modelo de chat compacto abaixo de 1B — parece de graça em pegada mas vacila em conversa multi-turno real, por isso não passou. O salto que importa não é 0,27B → 0,8B; é das chamadas de ferramentas do FunctionGemma para a conversa do Gemma 4.
O resto da stack também sobe: no desktop troca-se o leve Parakeet-EOU por Parakeet-TDT (multilingue completo), e o TTS fica em Supertonic-3 em todo o lado — rápido, 44,1 kHz, estável. Saltamos de propósito os modelos de TTS de clonagem zero-shot mais pesados; a clonagem não é fiável o suficiente para viver dentro de um agente sempre ligado.
| Etapa | Móvel | Desktop (Mac / MLX) |
|---|---|---|
| VAD | Silero v6.2.1 | Silero v6.2.1 |
| STT | Parakeet-EOU (streaming) | Parakeet-TDT (multilingual) |
| LLM | FunctionGemma 270M | Gemma 4 E2B/E4B |
| TTS | Kokoro-82M / Supertonic-3 | Supertonic-3 |
| Resident set | iPhone ~1.2 GB · S23 ~1.5 GB | ~4 GB |
Esse caminho de desktop é o que o Runner Agent entrega — uma app macOS notarizada que corre Mic → VAD → Parakeet-TDT → Gemma 4 → Supertonic TTS totalmente local, um DMG de 47 MB com o ciclo inteiro à volta de ~4 GB em Apple Silicon. E como o cérebro emite chamadas de ferramentas, o Runner não se limita a responder — comanda a máquina por voz: abre um browser e executa operações no DOM, abre o Telegram ou o WhatsApp para ler mensagens recebidas e escrever respostas, lança e controla apps — tudo a partir de comandos falados, tudo local. É a verdadeira razão pela qual o desktop quer o Gemma 4 e não um chamador de ferramentas de 270M: agir sobre a máquina exige raciocínio a sério, não apenas preencher campos.
Um pipeline, ajustado ao orçamento.
VAD → STT → LLM → TTS é idêntico em todo o lado. O interessante é ajustar cada etapa ao acelerador e à memória do dispositivo.
Bateria e temperatura escolhem os modelos. A ANE torna o iOS quase grátis em CPU; o Android hoje é tempo real em CPU, com margem de NPU a caminho.
O ciclo inteiro cabe em ~4 GB, e esse orçamento compra o raciocínio do Gemma 4 que comanda a máquina por voz, mais o Parakeet-TDT multilingue.
O áudio e o estado da conversa nunca saem do dispositivo — percepção, raciocínio e síntese correm no metal à tua frente.
Continuar a ler.
Os números de Mac, iPhone e Galaxy S23 por trás deste artigo.
O companheiro de voz local de macOS que comanda a tua máquina.
Compõe VAD, STT, LLM e TTS num ciclo em tempo real.
Mais artigos sobre voz no dispositivo à medida que saem.