⬆️ Flowvox update : Symfony devient une plateforme d’agents vocaux temps réel

le 17 mai 2026

En février 2026, j’avais publié un premier prototype expérimental autour de la transcription vocale en PHP avec Whisper.cpp.

https://blog.darkwood.com/article/i-m-building-a-dictation-engine-in-php-flow-symfony-whisper-cpp

L’objectif était simple :

enregistrer sa voix, la retranscrire localement, puis exporter le résultat.

Trois mois plus tard, le projet a énormément évolué.

Flowvox n’est plus seulement un POC console.

C’est désormais une plateforme de workers vocaux temps réel construite avec Symfony 8, Messenger, Mercure, Symfony UX, OpenAI Realtime et Hotwire Native.

Pourquoi cette mise à jour maintenant ?

La raison est très simple : OpenAI vient de faire évoluer massivement son API audio temps réel.

Dans leur démonstration récente, plusieurs nouveautés ont été présentées :

traduction multilingue temps réel
transcription fluide en streaming
agents vocaux capables d’appeler des tools
raisonnement en arrière-plan
conservation du contexte conversationnel.

Ce n’est plus simplement de la reconnaissance vocale.

La voix devient une interface programmable.

Et c’est précisément la direction dans laquelle Flowvox évolue.

Le prototype initial : Whisper.cpp + terminal

La première version de Flowvox était extrêmement minimaliste.

Architecture :

Microphone
→ ffmpeg
→ whisper.cpp
→ transcription locale

Le système fonctionnait entièrement en ligne de commande :

php bin/console voice:start
php bin/console voice:stop
php bin/console voice:worker

Il n’y avait :

aucune UI
aucun temps réel
aucune orchestration distribuée
aucune notion de session.

L’objectif était uniquement de valider qu’il était possible de faire de la transcription locale en PHP avec Whisper.cpp.

Passage à une architecture distribuée

La nouvelle version change complètement de philosophie.

Le cœur du système repose maintenant sur :

Symfony Messenger
darkwood/flow
Mercure
Doctrine
Symfony UX
providers de transcription interchangeables.

Architecture simplifiée :

flowchart LR
    UI["Symfony UX"]
    MQ["Messenger"]
    W["Voice Worker"]
    F["Flow Pipeline"]
    OAI["OpenAI Realtime"]
    WC["Whisper.cpp"]
    M["Mercure"]

    UI --> MQ
    MQ --> W
    W --> F
    F --> WC
    F --> OAI
    W --> M
    M --> UI

Le point important :

le worker n’est pas l’interface.

L’UI ne fait que piloter des workers vocaux indépendants.

Chaque session possède sa propre queue Messenger :

voice_demo
voice_mobile
voice_conference
voice_stream

Cela permet d’avoir :

plusieurs workers
plusieurs appareils
plusieurs sessions simultanées
une architecture distribuée.

Flow orchestration

Le pipeline repose toujours sur Darkwood Flow.

Trois étapes principales :

Étape	Rôle
InputProviderFlow	Lecture des événements START / STOP
RecorderFlow	Enregistrement audio
TranscribeFlow	Transcription

Le worker reste long-running et écoute les événements Messenger.

Lorsqu’un START est reçu :

le worker démarre l’enregistrement
ffmpeg capture l’audio
la session est suivie
les événements sont publiés via Mercure.

Lorsqu’un STOP est reçu :

le fichier WAV est finalisé
la transcription démarre
l’UI reçoit les mises à jour.

Symfony UX + Mercure : le temps réel

Une des plus grosses évolutions du projet est l’arrivée d’une vraie interface web temps réel.

Stack utilisée :

Twig
Symfony UX
Turbo
Stimulus
Mercure.

Le dashboard permet maintenant :

de voir les workers actifs
de démarrer/arrêter une session
de suivre les événements live
d’afficher les transcriptions
d’accéder à l’historique.

Architecture temps réel :

sequenceDiagram
    participant Worker
    participant Mercure
    participant Browser

    Worker->>Mercure: publish event
    Mercure->>Browser: live update
    Browser->>UI: refresh transcript

L’intérêt est énorme :

Symfony peut maintenant faire du temps réel moderne sans React ni frontend séparé.

Providers de transcription

Une autre évolution importante est l’introduction d’une couche DDD avec providers interchangeables.

Flowvox peut maintenant fonctionner avec plusieurs moteurs :

Provider	Type
whisper_cpp	Local
whisper_cpp_stream	Local realtime
openai_batch	Cloud batch
openai_realtime_whisper	Cloud realtime

La sélection se fait via une variable d’environnement :

FLOWVOX_TRANSCRIPTION_PROVIDER=

Le moteur peut changer.

L’UX reste identique.

OpenAI Realtime Whisper

C’est probablement la nouveauté la plus importante.

Avant :

START
→ parler
→ STOP
→ transcription

Maintenant :

START
→ streaming audio
→ transcription live
→ partials
→ UI temps réel

Le fonctionnement :

flowchart LR
    MIC["Micro"]
    FFMPEG["ffmpeg"]
    WS["WebSocket OpenAI"]
    WORKER["Worker"]
    MERCURE["Mercure"]
    UI["Symfony UX"]

    MIC --> FFMPEG
    FFMPEG --> WS
    WS --> WORKER
    WORKER --> MERCURE
    MERCURE --> UI

Le worker envoie les chunks audio à OpenAI Realtime via WebSocket.

Le modèle retourne des transcriptions partielles.

Le worker publie ensuite ces événements vers Mercure.

Et Symfony UX met à jour l’interface en direct.

Traduction multilingue temps réel

OpenAI introduit aussi GPT Realtime Translate.

Cela permet :

de parler en français
de traduire en anglais
ou même de changer dynamiquement de langue pendant la conversation.

Le modèle suit la structure de la phrase et attend parfois les verbes avant de traduire, ce qui rend le résultat beaucoup plus naturel.

C’est extrêmement intéressant pour :

conférences
podcasts
support client
éducation
médias.

Symfony UX Native + iOS

Autre grosse évolution : l’intégration native mobile.

Flowvox utilise maintenant :

composer require symfony/ux-native

L’idée est de conserver :

Twig
Symfony UX
Turbo
Stimulus

tout en utilisant un shell mobile natif basé sur Hotwire Native.

Architecture :

flowchart LR
    Twig --> Turbo
    Turbo --> WebView
    WebView --> SwiftUI
    Stimulus --> NativeBridge

L’application iOS repose sur une WebView connectée au serveur Symfony local.

Le résultat :

même application
même backend
même UI
version web + version native.

Darkwood Navi : traçabilité des workflows

Flowvox intègre aussi Darkwood Navi.

L’objectif :

enregistrer les événements
suivre les exécutions
tracer les workflows
rendre les traitements reproductibles.

Cela prépare surtout les prochaines étapes :

agents vocaux
tool calling
workflows déclaratifs
orchestration IA.

Vision long terme

Flowvox n’est plus seulement un moteur de transcription.

La direction devient beaucoup plus ambitieuse :

une plateforme vocale programmable pour Symfony.

Les prochaines étapes :

GPT Realtime Translate
agents vocaux
tool calling
orchestration Flow
workflows Navi
intégration Uniflow
automation pilotée par la voix.

L’objectif n’est plus simplement :

“parler à son application”.

Mais plutôt :

“avoir une application qui réagit, raisonne et agit en temps réel à travers la voix”.

Conclusion

En quelques mois, Flowvox est passé :

d’un POC terminal Whisper.cpp
→ à une plateforme vocale temps réel Symfony

Avec :

workers distribués
orchestration Flow
Symfony UX
Mercure
OpenAI Realtime
Hotwire Native
providers interchangeables
traçabilité Navi.

La voix devient progressivement une interface programmable.

Et je pense que Symfony possède aujourd’hui toutes les briques nécessaires pour devenir une excellente plateforme pour ce type de systèmes.

Flowvox continue d’évoluer comme terrain d’expérimentation autour :

des workers vocaux
de l’orchestration temps réel
des agents pilotés par la voix
de Symfony UX
de Symfony AI
et des workflows déclaratifs avec Flow et Navi.

L’objectif n’est plus simplement de retranscrire de l’audio.

L’objectif est maintenant de construire des interfaces vocales programmables capables :

d’écouter
de raisonner
de traduire
et d’agir dans des systèmes externes en temps réel.

Ressources

Tu peux ajouter cette section à la fin de l’article.

Ressources & projets

Le code source et les expérimentations autour de Flowvox sont disponibles publiquement :

Technologies utilisées :

Annonces et documentation OpenAI :