Aller au contenu
← Insights

Nous avons tué notre moteur de workflow en pleine transaction. Exprès.

Le processus que personne ne dessine

Une demande de crédit n'est pas une suite d'appels d'API. Quatre contrôles tournent en parallèle. Un agent lit les pièces. Un analyste approuve trois jours plus tard. Un délai réglementaire de réflexion s'écoule. Viennent ensuite la comptabilisation, l'email, la mise à jour du CRM.

La plupart des frameworks d'agents modélisent les deux premières minutes de ce processus. Les trois jours restants sont l'endroit où vit réellement un processus d'entreprise : attendre, repartir après une panne, défaire ce qui a été fait. Rendre chaque étape « agentique » ajoute de l'incertitude là où la prévisibilité est exigée.

hwf, pour hybrid workflow, est le prototype que nous avons écrit en C++20 pour porter le processus entier.

Cinq types d'étapes

Un processus est un graphe d'étapes, et une étape est de l'un de ces cinq types.

  • Code : s'exécute sur un pool CPU.
  • Agent : s'exécute sur un pool d'entrées-sorties, sous une limite de ressource. Jamais plus de quatre appels de modèle en vol.
  • Humain : ne s'exécute sur rien. L'instance est mise en attente et une tâche arrive dans la corbeille de quelqu'un.
  • Délai : une échéance durable.
  • Notification : l'envoi de l'email.

Chaque étape peut déclarer ses dépendances, une condition, des reprises avec backoff exponentiel, et une fonction de compensation qui la défait. Les étapes indépendantes s'exécutent en parallèle sur un ordonnanceur à vol de tâches.

L'état, c'est le journal

Chaque changement d'état est ajouté à un journal avant que quoi que ce soit n'agisse. L'état d'un processus est le résultat du rejeu de ses événements, rien d'autre. La plupart des garanties découlent de cette seule décision.

  • Une étape est journalisée comme planifiée avant qu'un worker ne la voie.
  • Après une panne, les étapes qui étaient en vol sont marquées comme récupérées et relancées. Chaque effet de bord porte une clé d'idempotence : le système aval déduplique la seconde tentative.
  • L'arrêt annule les étapes en vol de façon coopérative et conserve le travail terminé. La reprise repart de là.
  • Le rollback compense les étapes terminées dans l'ordre inverse des dépendances. Si une compensation échoue sans cesse, le processus passe en échec pour qu'une personne intervienne.

Le script de démonstration déroule huit scénarios. Celui que nous montrons en premier : un kill -9 du moteur après que la comptabilisation du prêt a atteint le core banking simulé, mais avant que le journal ne l'ait enregistrée. Au redémarrage, l'étape est relancée et l'écriture est dédupliquée. Un prêt, pas deux.

Chronologie
Le moteur meurt entre l'écriture comptable et son enregistrement. Le prêt n'est comptabilisé qu'une fois.
Journal 01
L'étape de comptabilisation est écrite comme planifiée, avant qu'un worker ne la voie.
Moteur 02
L'écriture part vers le core banking avec sa clé d'idempotence.
Panne 03
kill -9. Le moteur meurt avant que le journal n'enregistre le résultat.
Redémarrage 04
Le journal est rejoué. L'étape était en vol : elle est relancée.
Core banking 05
Même clé, vue deux fois. La seconde écriture est écartée.
Journal 06
L'étape est enregistrée comme terminée. Un prêt, pas deux.
Le journal est écrit avant toute action, et chaque effet de bord porte une clé d'idempotence. Le rejeu après une panne relance l'étape, et le système aval écarte le doublon.

Ce que nous avons mesuré

Sur un Apple M5 Max, avec le benchmark du moteur.

50 à 70µs
par étape, chacune validée durablement avant la suivante
260 000
étapes par seconde sur une rafale de 5 000 instances de 18 étapes
7×
le coût de la durabilité, par rapport à l'ordonnancement brut en pointe

L'ordonnanceur brut, tâches vides et sans durabilité, traite 1,7 à 2 millions de tâches par seconde. La durabilité coûte donc environ sept fois l'ordonnancement brut en pointe. C'est très loin d'être le goulot dès qu'une étape appelle un modèle pendant des secondes ou attend une personne pendant des heures.

Une réserve. Sur cette machine, notre mode de synchronisation complète ne va pas jusqu'à l'écriture physique sur le disque : les chiffres pour une vraie sûreté à la coupure de courant seraient plus bas. Un serveur Linux sur stockage NVMe est le réglage honnête, et nous n'avons pas encore publié cette mesure.

Le moteur passe les analyses de sûreté des threads et de la mémoire sans aucun constat.

Ce qu'il n'est pas encore

C'est un prototype. La liste de ce que la production exige est longue.

  • Les étapes agent bloquent un thread d'entrées-sorties pendant l'attente. Des milliers d'appels de modèle simultanés demandent de l'asynchrone.
  • Il y a un seul processus moteur. Passer à l'échelle suppose de partitionner les instances entre plusieurs moteurs et de déplacer le journal vers un stockage conçu pour cela.
  • Les workflows sont du code C++. Un produit a besoin d'un format déclaratif.
  • Les instances sont attachées à une version de workflow, mais il n'existe aucun outil de migration.
  • Le journal n'a ni snapshot ni compaction pour les processus très longs.
  • Il n'y a ni API HTTP ni écran de corbeille.

Nous publions les limites à côté des chiffres parce qu'un architecte a besoin des deux pour juger une conception.

Pour notre recherche sur le modèle de workflow lui-même, lisez le rapport technique 2yFlow.

Structurons votre prochain système intelligent.

Que vous lanciez une initiative IA, modernisiez votre architecture ou cherchiez à aligner technologie et exécution, CMX vous aide à créer la structure nécessaire pour avancer avec confiance.