Documentation vivante · historique des décisions
Chaque décision d'architecture, de la première à la dernière, racontée en quelques phrases et reliée aux briques qu'elle a façonnées.
Version 4.6.010 novembre 2026tenue à jour à chaque commit, depuis les données du dépôt
Vue d'ensemble
Chaque barre empile les décisions d'un mois, colorées par thème. Clique une barre pour y aller.
Chronologie
Chaque décision en quelques phrases, avec les briques qu'elle a façonnées. Filtre par thème, cherche un mot, ou suis une brique.
Chapitre 1 · 1 oct. 2025 – 31 déc. 2025 · 48 décisions
Le graphe d'agents, les sessions tenues côté serveur, le planificateur, le registre de données, la mémoire, l'observabilité, les six langues et le déploiement sur un Raspberry Pi : la charpente sur laquelle tout le reste repose.
LIA a besoin d'un moteur capable de mener une conversation en plusieurs étapes, de s'arrêter pour demander un accord puis de reprendre. LangGraph fournit ce graphe d'exécution : l'état de chaque conversation est sauvegardé en base et les réponses arrivent mot à mot.
Les jetons stockés dans le navigateur étaient exposés au vol et impossibles à révoquer. Un serveur intermédiaire (BFF) garde désormais la session côté serveur et ne confie au navigateur qu'un cookie inaccessible au JavaScript — une session se révoque instantanément.
Envoyer tout le catalogue d'outils au modèle à chaque question décuplait la taille du prompt et le coût. Le routeur détecte les domaines concernés et seul leur sous-ensemble d'outils est chargé, avec un repli sur le catalogue complet en cas de doute.
Plutôt que d'interrompre l'exécution outil par outil, LIA présentait son plan à approuver avant de commencer. L'approbation du plan est aujourd'hui automatique : la validation se fait sur chaque action sensible.
Les premiers plans étaient trop simplistes et échouaient souvent. Le planificateur analyse désormais l'intention, décompose la demande, puis écrit un plan d'exécution justifié étape par étape.
L'exécuteur parallèle lançait en même temps le plan principal et son alternative de secours : double appel, double coût. Les étapes écartées sont désormais retirées avant de lancer chaque vague.
Demander « tous les contacts » pouvait ramener des centaines de fiches et exploser le coût. Trois barrières — avertissement du planificateur, plafond dur dans l'outil, journalisation — empêchent désormais une liste non bornée.
Certains nœuds du graphe faisaient des centaines de lignes et étaient devenus illisibles. La logique métier part dans des services dédiés ; un nœud se contente de coordonner.
Un fichier de configuration de près de 1 800 lignes regroupait tous les réglages. Il est éclaté en modules par domaine, réunis en un seul objet de réglages validé au démarrage, sans changer la façon de l'importer.
Le domaine s'appelait Gmail, comme s'il n'existait qu'un fournisseur. Il est renommé de façon générique pour accueillir Outlook, Apple Mail et d'autres sans tout renommer à chaque ajout.
Faut-il un faux « connecteur » pour les outils internes (contexte, mémoire) ? Non : les outils qui parlent à un service externe et les outils utilitaires restent deux catégories distinctes, chacune avec son patron simple.
Les outils renvoyaient du texte brut que rien ne conservait. Un registre de données garde désormais chaque élément retourné, avec ses métadonnées, pour qu'une question suivante puisse y faire référence et qu'un brouillon puisse être confirmé.
L'assistante oubliait tout d'une session à l'autre. Une mémoire long terme, isolée par personne et interrogée par le sens, conserve préférences et faits importants — y compris les sujets sensibles à traiter avec tact.
Exécuter les outils l'un après l'autre additionnait les délais. Un plan d'exécution exprime dépendances, conditions et secours, et lance en même temps tout ce qui peut l'être.
Chaque outil de connecteur répétait 150 lignes identiques (authentification, erreurs, cache). Une classe de base factorise ce socle ; un nouvel outil n'écrit plus que ce qui lui est propre.
Chaque domaine identifie et affiche ses éléments différemment. Un registre de types de contexte décrit chaque domaine une fois, et la résolution de « celui-ci » ou « le troisième » fonctionne partout de la même façon.
Il fallait protéger à la fois les utilisateurs contre les abus et les quotas des API externes, même avec plusieurs instances. Une limitation distribuée par Redis, par personne et par catégorie, se replie localement si Redis tombe.
Attendre dix secondes une réponse complète est pénible. Le serveur diffuse chaque mot, les étapes du plan et les demandes d'accord au fil de l'eau par Server-Sent Events.
Le planificateur doit savoir quels outils existent, ce qu'ils coûtent et ce qu'ils exigent. Des manifestes typés servent à la fois de documentation et de configuration, filtrés par domaine pour économiser des jetons.
Aucun outil ne couvre à lui seul métriques, traces et suivi des appels aux modèles. Prometheus, Tempo et Langfuse travaillent chacun de leur côté, et l'application continue si l'un d'eux tombe.
Les accès Google devaient rester illisibles en base, se renouveler avant expiration et ne jamais être rafraîchis deux fois en même temps. Chiffrement au repos, rafraîchissement anticipé sous verrou distribué et PKCE en couvrent le cycle de vie.
Pour reprendre après une interruption ou un redémarrage, l'état du graphe est enregistré en PostgreSQL par fil de conversation, avec des règles de fusion qui tronquent l'historique au budget de jetons.
Chaque partie gérait ses erreurs à sa façon. Un format commun pour les outils, une hiérarchie d'exceptions journalisées et des messages traduits en six langues rendent les erreurs cohérentes et mesurables.
L'interface, les messages du serveur et les URL doivent parler la langue de la personne. i18next côté navigateur, gettext côté serveur, six langues et des adresses localisées pour le référencement.
Les instructions données aux modèles doivent pouvoir évoluer et revenir en arrière. Elles vivent dans des fichiers versionnés, chargés selon une version configurable et remplis par des variables.
Le routage, la planification et la réponse n'ont pas les mêmes besoins. Chaque composant reçoit son modèle, derrière une abstraction qui permet de changer de fournisseur sans toucher au code.
Pour être exploités, les journaux doivent être lisibles par une machine. structlog produit du JSON contextualisé (requête, personne, conversation) et filtre les données personnelles avant écriture.
Identifiants UUID, dates toujours en UTC, suppression logique et métadonnées JSONB : les conventions du schéma PostgreSQL sont fixées une fois pour toute l'application.
Sessions, états OAuth, limitation de débit, verrous et caches passent par Redis. Chaque usage a sa base, ses expirations et ses opérations atomiques, et l'indisponibilité se dégrade sans bloquer.
Une conversation est pleine de références implicites : « le deuxième », « celui-ci », « lui ». La résolution de contexte détecte le type de tour et relie ces mots aux bons éléments, sans mélanger les domaines, dans six langues.
On ne peut pas appeler de vrais modèles à chaque test. La stratégie simule le fournisseur à sa frontière, isole la base de chaque test et couvre le code asynchrone.
L'API REST suit une convention unique : préfixe de version, schémas Pydantic validés, routeurs par domaine et un format d'erreur commun, documentés automatiquement.
Une quinzaine de services doivent tourner en développement comme sur un Raspberry Pi 5. Docker Compose orchestre le tout, avec contrôles de santé, limites de ressources et images pour deux architectures.
Un service externe en panne ne doit pas entraîner toute l'application. Disjoncteurs, nouvelles tentatives espacées, sondes de santé et dégradation contrôlée maintiennent le service.
Enthousiaste, professeure ou amie : chacun choisit le ton de LIA. Les personnalités sont stockées en base, traduites en six langues et injectées dans les prompts.
Pour personnaliser vraiment, LIA extrait en arrière-plan ce qui compte dans les conversations, le retrouve par le sens et module son ton selon la sensibilité du sujet, sans jamais bloquer la réponse.
Rendu côté serveur, réponses diffusées en direct, six langues et authentification par cookie : l'interface repose sur le routeur d'applications de Next.js.
Chaque évolution du schéma passe par une migration Alembic nommée, datée et réversible, qui détecte automatiquement tous les modèles.
Les conversations sauvegardées doivent rester lisibles quand leur format change. L'état porte un numéro de version et se migre automatiquement au chargement.
Une conversation naît au premier message, peut être supprimée logiquement, laisse un journal d'audit et disparaît en cascade avec le compte, conformément au RGPD.
Chaque domaine (mail, contacts, agenda…) a son agent et ses outils, supervisés par un graphe parent qui partage un état unique et propage l'observabilité.
Envoyer un mail ou créer un rendez-vous exige un accord. Le brouillon est présenté, modifiable ou annulable, et n'est exécuté qu'après confirmation — chaque décision est tracée.
Référentiels, services et routeurs s'enchaînent par injection de dépendances FastAPI, avec des sessions de base ouvertes et fermées au bon moment et faciles à simuler en test. Une erreur de route atteint la session pour annuler sa transaction ; la fermeture se termine avant de laisser passer une annulation.
Gmail, Agenda, Contacts, Drive et Tâches partagent une base commune : portées OAuth centralisées, jetons renouvelés sous verrou et quotas respectés service par service.
Chaque appel aux modèles doit être compté et optimisé. Comptage précis des jetons par fournisseur, coût en temps réel, mise en cache et sélection sémantique des outils ont divisé par dix le catalogue envoyé.
Taux de change, nettoyage des souvenirs, envoi des rappels : certaines tâches doivent tourner seules. Un ordonnanceur asynchrone les lance selon des expressions cron, s'arrête proprement et publie ses métriques.
Des listes de mots-clés par langue donnaient des scores faibles et demandaient un entretien sans fin. Le routeur compare désormais le sens de la question à celui des domaines et des outils, dans plus de cent langues.
Un rappel se crée en langage naturel, se stocke en UTC et part en notification push sur tous les appareils, avec un message personnalisé — sans jamais être envoyé deux fois, même avec plusieurs workers.
Chapitre 2 · 1 janv. 2026 – 31 mars 2026 · 18 décisions
Un premier durcissement de sécurité, la dictée vocale, les espaces de connaissances et la synchronisation d'un dossier en ligne, les carnets de bord de LIA, le navigateur piloté, les limites d'usage — et la première version publique en open source.
Cookies HTTP-only, requêtes paramétrées, protection CSRF, mots de passe hachés : l'application aligne ses défenses sur les recommandations OWASP.
Les résultats d'agents peuvent être des contacts, des mails, des lieux… Une validation explicite de cette union de types empêche toute perte silencieuse de données lors de la conversion.
Après chaque réponse, LIA repère en arrière-plan un ou deux sujets qui intéressent la personne, sans ralentir la conversation, pour personnaliser ses réponses puis ses initiatives.
Mot d'éveil « OK Guy », bouton micro, détection de fin de parole et transcription multilingue gratuite sur le serveur : la saisie vocale arrive sans coût d'API récurrent.
Chacun peut déposer ses documents ; LIA les découpe, les indexe et les retrouve par recherche hybride (sens + mots) pour enrichir ses réponses, dans des espaces strictement isolés.
Plutôt que télécharger puis déposer ses fichiers, on relie un dossier Drive : LIA réutilise le connecteur existant et indexe les documents avec le même pipeline, fichier par fichier.
L'assistante écrit ses propres réflexions et observations, à la première personne, colorées par sa personnalité, et les relit par le sens pour mieux raisonner avec chacun.
À « Que sais-tu faire ? », LIA répondait de façon générique. Un espace de connaissances système, indexé depuis la FAQ, lui donne des réponses exactes sur ses propres fonctionnalités.
Remplir un formulaire, chercher un produit, lire une page dynamique : un agent autonome pilote un navigateur Playwright isolé, décrit une tâche en langage naturel et la mène à bien.
Chaque appel aux modèles coûte de l'argent réel. Des plafonds par personne — jetons, messages, coût — par période ou au total protègent l'opérateur d'une dépense incontrôlée.
Une application MCP désactivée continuait de recevoir des requêtes. Les domaines renvoyés par l'analyseur sont désormais filtrés contre ceux réellement disponibles, à chaque étape.
Un plan figé ne pouvait pas réagir à ce qu'il découvrait. Une phase d'initiative relit les résultats et propose des vérifications utiles, et un sous-agent itératif sait explorer un serveur MCP complexe.
Avec quatre processus, un réglage modifié n'atteignait qu'un seul d'entre eux. Une invalidation diffusée par Redis Pub/Sub recharge le cache dans chaque worker.
La personnalité conversationnelle contaminait les notes du journal. Une persona d'analyste fixe écrit désormais des observations cliniques et des directives actionnables, quelle que soit la personnalité active.
Les nœuds d'agents par domaine n'étaient plus jamais traversés. L'analyse le documente, pour que l'administration ne propose plus de réglages qui ne servent à rien.
Pour ne plus payer ni attendre un service externe à chaque recherche sémantique, un modèle d'embeddings multilingue tourne sur la machine, y compris sur un Raspberry Pi.
Deux stockages différents imposaient cinq calculs d'embedding par tour. Mémoire et journaux passent sur PostgreSQL avec pgvector, et un seul embedding sert tous les usages.
Actif, désactivé, supprimé, effacé : un compte suit un cycle de vie qui préserve l'historique de facturation après suppression et efface tout sur demande au titre du RGPD.
Chapitre 3 · 1 avr. 2026 – 30 juin 2026 · 23 décisions
Le mode ReAct, une psyché qui évolue, les compétences, les données de santé, le briefing du matin, la voix de LIA, les sous-agents et un raisonnement réglé par fournisseur.
La personnalité était un texte figé. Un moteur psychologique en cinq couches — traits, humeur, émotions, relation, motivations — fait évoluer l'état de LIA au fil des échanges.
La recherche sémantique passe sur Gemini, avec deux espaces distincts pour stocker et pour chercher, et deux vecteurs par élément (contenu et mots-clés) pour mieux retrouver.
Un plan rigide ne s'adapte pas à un résultat inattendu. Un second mode, au choix de la personne, laisse le modèle appeler un outil, lire le résultat et décider de la suite, dans une boucle intégrée au graphe.
Deux mécanismes concurrents identifiaient les compétences. L'analyseur de requête compare désormais la demande à la description de chaque compétence active : un seul signal, sémantique.
Le gestionnaire de contexte gardait trois vues par domaine dont une inutile. Il ne garde plus que la dernière liste et l'élément courant, ce qui simplifie la résolution des références.
Les alertes météo parlaient du domicile même en voyage. Une dernière position connue, conservée sur demande, permet aux notifications de suivre la personne là où elle se trouve.
Plusieurs champs de sortie étaient confondus. Les entités métier passent par un seul contrat explicite et plat, que les consommateurs lisent sans deviner.
Une carte, un tableau de bord, un QR code : une compétence peut renvoyer, en plus du texte, un cadre interactif ou une image, par un contrat JSON typé.
Un raccourci iPhone envoie chaque jour pas et rythme cardiaque par lot, authentifié par un jeton personnel révocable, pour suivre les tendances et détecter les variations.
La page d'accueil devient un briefing du jour : météo, agenda, mails, rappels… lus en parallèle hors du graphe d'agents, avec un cache par section et une synthèse rédigée.
Les capacités et prix des modèles étaient figés dans le code. Le catalogue vit désormais en base de données, éditable par l'administrateur sans redéploiement.
Le journal devient l'organe de méta-cognition de LIA : observations brutes, directives, synthèses et portrait de la personne, chacun avec son statut de preuve et son auto-évaluation.
Une synthèse vocale neuronale, multilingue et diffusée phrase par phrase donne une voix à LIA, avec un premier son en moins de trois secondes et une activation au choix de chacun.
En option, la reconnaissance vocale peut passer par ElevenLabs Scribe, plus précis ; les prix gagnent une unité à la minute ou à l'heure d'audio pour être comptés justement.
Quatorze variables d'environnement pilotaient la synthèse vocale. Elle devient un rôle du catalogue, choisi dans l'administration comme n'importe quel modèle.
Client HTTP persistant, découpage en phrases pendant la génération et envoi immédiat : la voix commence à parler avant la fin de la réponse écrite.
Un résumé de cinq mails avait consommé près de 500 000 jetons. La délégation à un sous-agent passe par une boucle ReAct paramétrée et bornée, et l'ancien mécanisme est supprimé.
« Mes rendez-vous médicaux » ne donnait aucun résultat : le mot « médical » était cherché tel quel. Un principe de planification sépare ce qu'un service sait filtrer de ce que le modèle doit juger.
Après confirmation, trois rappels supprimés s'affichaient comme trois lignes identiques. Un registre déclaratif par type de brouillon, vérifié au démarrage, fixe l'affichage de chacun.
Une conversation trop longue empêchait tout nouveau message. La compaction gagne délais, reprises, observabilité, et une troncature visible plutôt qu'un blocage.
Un client maison de 1 800 lignes est remplacé par le client natif ; la façon de demander du raisonnement devient une configuration par fournisseur.
Le journal produisait des entrées inutiles. Il écrit moins, garde ses mécanismes de découverte, et chaque niveau sert un usage précis à la lecture.
Chaque processus exposait ses propres compteurs. Le mode multiprocessus de Prometheus les agrège, et chaque jauge déclare comment se combiner.
Chapitre 4 · 1 juil. 2026 – 31 juil. 2026 · 101 décisions
Un mois de cent décisions : un audit de bout en bout, la sécurité et les sauvegardes, une CI qui exécute exactement ce que le développeur lance, des alertes qui réveillent pour une raison, et les premières règles d'honnêteté.
Les liens entre types de données et outils avaient deux sources désynchronisées. Ils sont désormais l'union de l'ontologie et des manifestes, et des tests en garantissent l'intégrité.
La réponse attendait la fin de l'initiative avant de charger son contexte. Les deux se chevauchent désormais, ce qui retire plusieurs secondes aux tours avec outils.
Reprendre après un accord rejouait des appels coûteux. Chaque nœud ne pose plus qu'une interruption et boucle par le graphe, ce qui rend la reprise sûre.
L'adresse du client pouvait être falsifiée et du HTML injecté. Ports liés à la boucle locale, en-têtes de proxy vérifiés et assainissement du HTML ferment ces deux brèches.
Trois fonctions de fenêtrage n'étaient plus appelées nulle part. Elles disparaissent avec leurs réglages et leurs tests : un sous-système mort coûte à chaque changement.
Un audit a trouvé sept familles de défauts discrets. Chacune est corrigée et reçoit une garde permanente — un test, une métrique ou une règle écrite — pour ne jamais revenir.
Un audit a ciblé trois frontières : le code synchrone qui gelait la boucle asynchrone, les services internes joignables depuis le réseau local, et la sortie des modèles affichée sans filtre. Chaque défaut est corrigé et mesuré avant/après.
Certains défauts n'apparaissent qu'en parallèle ou à la suppression d'un compte. Une session de base par tâche parallèle, une purge RGPD complète et un bac à sable de compétences durci les éliminent.
La politique de sécurité du contenu cassait les widgets MCP. Chaque widget tiers reçoit désormais son propre document, donc sa propre politique, sans affaiblir celle de l'application.
Un reverse proxy nginx livré dès la première version n'avait jamais été relié à rien. Il est supprimé, parce qu'un fichier qui ne sert pas trompe celui qui le lit.
Un modèle répondait parfois en JSON dans son texte au lieu de la structure attendue, et la demande échouait. Un filet de secours récupère ce JSON, et une convention d'écriture des prompts évite le conflit.
« Mes prochains rendez-vous médicaux » échouait au hasard selon le mode. L'outil liste la période puis filtre lui-même, remet les dates à zéro et plafonne le volume lu.
Chaque domaine porte un nom au singulier et une clé de résultat au pluriel, tous deux tirés d'un registre unique : plus aucune table maintenue à la main.
Des pans de la validation humaine restaient en français pour tout le monde. Les consignes aux modèles passent en anglais neutre et tout ce que la personne lit est traduit dans ses six langues, garde de parité à l'appui.
L'humeur de LIA restait bloquée dans quelques états. La cause — les émotions créées à chaque tour — est traitée à la source, avec des seuils réglables sans reconstruire.
L'état psychologique restait décrit par des adjectifs abstraits et ne se sentait pas. Il passe dans la façon de parler — rythme, longueur, registre — sans jamais dire « je me sens ».
Les modes Pipeline et ReAct déclenchaient les confirmations de deux façons différentes. Un contrat unique, typé, sert désormais toute validation, quel que soit le mode.
Des moteurs d'autonomie et un cadre d'approbation n'étaient plus appelés. Ils sont supprimés en cinq groupes vérifiés, sans rien perdre de vivant.
Brave, OpenWeatherMap et Perplexity limitaient leur débit processus par processus, donc faux en multi-workers. Ils héritent d'une base durcie, au cycle de vie déterministe.
Aucune sauvegarde de la base n'était versionnée. Un conteneur dédié exporte chaque nuit avec rétention, et un script prouve la restauration dans une base jetable.
Les options de chiffrement des sauvegardes sont analysées et comparées ; la décision est de différer, avec un chemin tracé vers une copie hors site.
Chaque worker partageait une seule connexion pour sauvegarder toutes les conversations. Des pools de connexions suppriment ce goulot, le premier du système.
Les versions installées dérivaient d'une machine à l'autre. Des fichiers de verrouillage universels, générés par uv et vérifiés en CI, fixent chaque dépendance transitive.
250 tests d'intégration ne tournaient dans aucun job. Ils rejoignent la CI avec une vraie base, les quarantaines sont interdites et la couverture ne peut plus reculer.
La couche client levait des exceptions HTTP brutes. Elle lève des erreurs du domaine, avec exactement la même réponse pour l'appelant.
La sonde de santé ne pouvait jamais signaler une panne. Elle est séparée en « vivant » (toujours 200) et « prêt » (503 tant que la base et Redis ne répondent pas).
Le cœur du chat n'était protégé que par le typage. Des centaines de tests couvrent désormais le streaming, les validations et la voix, avec des seuils de couverture qui ne reculent pas.
Fermer l'onglet interrompait la génération. La réponse est désormais produite à part, diffusée par Redis Streams, et reprend en direct quand on revient.
Le générateur de compétences demandait quatre manipulations manuelles. La compétence s'installe directement, par un pipeline d'import unique et durci.
L'alerting avait été désactivé sans décision écrite. Un noyau minimal d'alertes vitales repart, évaluées par Prometheus et envoyées par e-mail, chacune avec sa procédure.
Un trajet vers « mon frère » partait parfois vers un lieu arbitraire. Des preuves déterministes de référence à une personne et une garde de paramètres à l'exécution ferment chaque maillon de la panne.
Seuls 14 % des paramètres portaient un type sémantique. Une campagne d'annotation relie enfin participants, expéditeurs, adresses et dates d'un outil à l'autre.
La fonction qui diffuse chaque réponse faisait plus de 1 100 lignes. La coordination de la voix en est extraite dans une machine à états typée.
Le démarrage de l'API faisait 780 lignes. Chaque sous-système reçoit son module d'initialisation, et une seule fonction décide de l'ordre.
Les routeurs et services lèvent désormais des erreurs centralisées, avec une réponse identique pour les clients : la règle vaut maintenant pour tout le backend.
Le rendu des aperçus de confirmation était une cascade de conditions. Une table de rendu par type de brouillon la remplace.
Le domaine le plus sollicité dépendait de trop d'autres. Authentification et comptes sont séparés pour que l'identité reste un socle stable.
LIA peut appeler un tiers pour vérifier une disponibilité, puis rapporter un résumé dans le chat. L'appel passe par ton propre connecteur, reste confirmé, borné et en lecture seule.
L'analyse des échecs d'un plan reste un conseil : elle nourrit l'observabilité, sans relancer d'elle-même un nouveau plan.
Un redémarrage laissait des documents bloqués en cours de traitement. Documents et sources deviennent des tâches à bail, reprises automatiquement.
Onze constats d'audit sont traités sans délégation et sans régression : chaque refactoring commence par des tests qui figent le comportement actuel.
La moitié des notifications parlaient du même sujet. Les intérêts sont regroupés par sujet perçu et tirés selon leur rareté, mesures à l'appui.
Les demandes de validation n'étaient qu'un texte à interpréter. Elles deviennent des cartes avec boutons, après correction de défauts latents.
Un connecteur révoqué produisait une excuse vague. Un bandeau propose la reconnexion en un clic, grâce à une classification par type d'exception, jamais par message.
Le heartbeat revenait sans cesse aux mêmes intérêts sans rien de concret. Échantillon varié, registre commun, anti-répétition sur le contenu et enrichissement concret corrigent le tir.
Sur iPhone, cartes et applications MCP restaient vides sans message. Une posture d'isolation adaptée et des états d'échec visibles règlent l'affichage.
Des widgets apparaissaient en double ou se perdaient. Le modèle n'écrit plus jamais leur balisage : l'hôte les place et ils voyagent avec leur message.
Les étapes d'exécution disparaissaient au premier mot de la réponse. Elles sont désormais conservées avec le message et consultables après coup.
👍 ou 👎 sous chaque réponse, avec un commentaire facultatif : le verdict est conservé et réinjecté dans l'apprentissage, jamais pour régénérer la réponse à ta place.
« Je dois rappeler le plombier » mourait avec la conversation. Un registre des engagements les garde, et le heartbeat relance avec mesure.
« Fais-moi ça tous les matins » aboutit désormais dans le chat, après confirmation, et LIA suggère une routine quand elle voit une demande revenir.
Les espaces documentaires deviennent un domaine que le planificateur interroge, et une vue à 360° rassemble tout ce que LIA sait d'une personne.
Les réglages psychologiques avaient été livrés sans mesure. Un instrument d'observation vient d'abord, et les propriétés voulues deviennent des tests.
Passkeys, second facteur TOTP avec codes de secours et nouvelle vérification avant toute action sensible : la sécurité maximale et le confort maximal, sans jamais exposer de secret au navigateur.
Chacun voit les appareils connectés à son compte et peut en révoquer un à distance, avec un minimum strict de données (familles de navigateurs, IP tronquée).
Au titre de la portabilité RGPD, chacun télécharge l'intégralité de ses données, préparées par des tâches durables et sans jamais exporter un secret.
Un service worker unique gère les notifications et le hors-ligne, avec une page d'absence de réseau aux couleurs de LIA.
Quand un tour ne produit pas de données, la réponse s'appuie sur les entités récentes, sans jamais laisser une ancienne donnée contaminer une autre question.
Le heartbeat transférait 30 000 lignes par passage pour quelques chiffres. Une agrégation journalière côté base renvoie une ligne par jour.
Isoler un script en changeant d'utilisateur ne protégeait que si l'API tournait en root. Chaque script de compétence s'exécute désormais dans un conteneur jetable, sans réseau.
Réindexer un espace le rendait partiellement vide. Deux générations cohabitent, et un pointeur ne bascule qu'une fois la nouvelle prête.
Le workflow d'intégration continue contenait près de cent commandes écrites en ligne. Chaque étape appelle désormais une tâche du Taskfile : la CI exécute littéralement ce que chacun lance en local.
Des hooks frontend que rien n'utilisait sont retirés, la compilation le prouve : moins de code à entretenir, aucune fonctionnalité perdue.
Classer une réponse libre à une demande d'accord (oui, non, modifier) se trompait sur certains noms d'outils. La classification se fait par verbe d'action, avec des exemples qui couvrent tous les cas.
La voix coupait au milieu d'une URL ou d'un nombre décimal. Un délimiteur ne ferme une phrase que s'il est suivi d'une espace ou en fin de texte, dans les deux implémentations réunies.
Dix suites de tests s'éteignaient faute de clé d'API, donc ne tournaient jamais en CI. Le fournisseur est simulé ou le test est marqué visiblement, et une garde empêche la rechute.
Neuf modules et leurs traductions orphelines sont supprimés, clé par clé, sans toucher à celles qu'un composant vivant partage encore.
Une vulnérabilité d'une dépendance JavaScript exigeait une version incompatible. Un petit correctif d'interopérabilité applique le vrai correctif amont sans casser l'outillage.
La parité des clés ne voyait pas qu'une traduction était tronquée. Les troncatures sont réparées et un cliquet empêche qu'elles augmentent.
Un seul thème du journal recevait presque toutes les entrées. Le classement se fait par sujet, et un harnais de mesure vérifie que chaque thème reste vivant.
Six demandes d'image consécutives avaient échoué : le modèle écrivait le mot « null » comme nom de compétence. Les sorties sont normalisées et deux plafonds qui rendaient la fonction impossible sont levés.
Sur mobile, une réponse pouvait rester bloquée sur « Génération… » alors qu'elle était prête. Un chien de garde côté navigateur détecte le silence et reprend automatiquement le flux.
Quatre workers réindexaient la connaissance système en même temps et saturaient le fournisseur. Un seul prend le droit d'indexer, et son cache survit au déploiement.
Au premier démarrage, chaque worker recalculait les mêmes embeddings. Une revendication par fichier désigne un seul calculateur ; les autres attendent son résultat.
Chaque décision d'extraction vers la mémoire, les intérêts ou le journal est désormais comptée, pour vérifier qu'aucun type de tour n'est ignoré par erreur.
Pour ajuster une compétence, l'assistante relit la version actuelle et régénère le paquet complet, confirmé dans l'outil, plutôt qu'appliquer un correctif partiel.
Chaque sujet mentionné devenait un centre d'intérêt. La question devient : la personne a-t-elle montré un lien durable ? Demander n'est pas aimer, et chaque création exige un fondement cité.
Le texte écrit par un tiers — un mail, une invitation, une page — doit rester une donnée, jamais une instruction. La confiance est déclarée par type de donnée, et appliquée partout où le modèle la lit.
Une recherche hybride de la mémoire n'était plus utilisée depuis des mois. Le module, ses réglages et ses métriques disparaissent, preuve d'inactivité à l'appui.
Les consignes du tour ReAct étaient ajoutées comme messages et disparaissaient au fenêtrage de l'historique. Elles deviennent de l'état, recomposé en tête à chaque itération.
Le temps passé à attendre ton accord était compté comme du calcul. Le budget ReAct ne compte que le vrai calcul, et une garde arrête une boucle qui répète le même appel.
Une règle CSS globale rendait tous les éléments « collants » inopérants depuis toujours. Une autre valeur de débordement clippe la page sans casser l'accroche.
Trouver un réglage dont on connaît le nom demandait de tout déplier. Un champ de recherche indexe les sections et dit clairement quand une destination n'existe pas.
La révision 2026-07-28 du protocole MCP est une refonte. LIA parle les deux époques et lie son OAuth à l'émetteur découvert, sans régression.
Un lien qui préremplit le champ et un lien qui envoie la demande ont désormais deux paramètres distincts, pour ne jamais envoyer un texte que la personne n'a pas validé.
Après un appel, seuls un résumé et quelques données survivaient. Engagements, suites proposées et incertitudes sont désormais conservés dans un débrief structuré.
Une routine peut se déclencher sur une condition — une tâche en retard, un changement de météo — vérifiée à chaque tick, et ne s'exécute qu'une fois par fait nouveau.
LIA rassemble ce qu'elle sait déjà des personnes — engagements, appels, souvenirs — dans une vue relationnelle en lecture seule, sans nouvelle table.
Callouts, puces, tableaux, blocs repliables : un vocabulaire de composants permet des réponses mises en page, assainies selon un schéma étendu.
Au-delà de la technique, un tableau de bord mesure les résultats utiles, l'activation, la rétention et le coût par résultat, à partir de données durables en base.
Un retour d'appel arrivait en anglais et sans son débrief : un chemin contournait la porte commune. Toute sortie structurée passe désormais par elle, garde AST à l'appui.
Se découvrir par nom exact, se connecter après accord mutuel, s'écrire d'assistant à assistant et partager en lecture seule : un contexte dédié organise ces liens.
L'espace public adopte une identité cosmique et des chorégraphies pilotées par le défilement, appliquées par une portée CSS sans réécrire les composants.
« Est-il disponible demain ? » répondait qu'aucun service n'était configuré. Le routage connaît désormais les connexions, et un échec est rapporté tel qu'il est.
Une même demande échouait puis réussissait au hasard. Un catalogue filtré doit être clos : tout ce qu'un outil exige doit être produit par un autre outil du catalogue.
Le planificateur ne voyait pas les limites que l'outil appliquait en silence. Toute contrainte appliquée est publiée à celui qui produit la valeur, et un verdict de validation ne vaut pas échec.
Un nombre affiché doit être exact ou ne pas exister : compter sur une page tronquée sous-estime en silence. Agrégat sur tout l'ensemble, pagination des seules lignes, total exact à côté.
Le contenu d'un message relayé était effacé dès sa remise. Il est désormais conservé un temps borné, comme les appels, avant d'être purgé.
Chercher un pair par nom ou par adresse passe par un seul champ, et c'est le serveur qui décide de quoi il s'agit.
La vue relations peut lire contacts et anniversaires chez le fournisseur, à condition de dire ce qu'elle a regardé et de vérifier chaque correspondance.
Accepter d'être découvert ne veut pas dire montrer son adresse e-mail : c'est un second consentement, désactivé par défaut.
Chapitre 5 · 1 août 2026 – 31 août 2026 · 62 décisions
L'accessibilité par contrat, les réglages et les capacités affichés, les coûts à l'heure, l'installateur pour l'auto-hébergement, un catalogue de modèles qui dit vrai, les yeux expressifs et l'auto-diagnostic.
Un outil annoncé mais absent du registre répondait à vide. Une garde compare les deux, et la fiche contact affiche tous ses champs.
Un point 360° revenait amputé : l'outil n'était pas joignable depuis le domaine demandé. Chaque outil déclare les domaines qu'il sert, et un clic n'est pas une phrase.
Un second point 360° restait figé sur le premier : le routeur du navigateur réutilisait l'URL. Un lien profond du chat devient une navigation complète.
Un domaine qui ne sait qu'écrire pousse à écrire. Trois capacités de lecture (appels, engagements, messages) sont ajoutées, et l'identité d'une personne se corrige.
Un chemin de référence faux entre étapes n'était découvert qu'à l'exécution. Une garde CI vérifie que chaque exemple publié est réellement produit.
La clarification affichait la description technique d'un problème. Chaque type de problème a sa question, dans six langues, vérifiée au démarrage.
Le 👍/👎 d'une notification proactive visait parfois la mauvaise ligne. L'identifiant est choisi par le producteur avant l'envoi et sert partout.
Pour ne plus recevoir de notifications tirées des mails, il fallait déconnecter les mails. Onze interrupteurs séparent désormais la connexion de la permission d'interrompre.
En calculant les cinq prochaines exécutions, un défaut de changement d'heure est apparu. Une routine s'exécute au plus une fois par jour local, par construction.
Le chat vide propose des amorces tirées du briefing déjà en cache, jamais d'une récupération : une suggestion n'existe que si la preuve existe.
Les panneaux de proactivité réglaient fréquence et sources sans montrer les notifications produites. Elles y sont désormais visibles, repliées.
Un souvenir affirmait une préférence sans dire d'où il venait. Chaque conclusion garde une référence à son origine, et une suppression laisse une trace datée.
Messages relayés, notifications, rappels : cinq flux n'avaient pas de lieu de lecture. Une destination « Alertes » les rassemble, sans rien régler.
Les suites d'un appel envoyaient le message immédiatement. Elles préremplissent désormais le champ, pour que rien ne soit accepté sans toi.
Le poids d'un centre d'intérêt s'explique par ses composantes, jamais par un score : on montre le raisonnement, pas une note trompeuse.
Trois composants codaient leurs propres couleurs de statut. Un statut nomme désormais un ton, rendu par un seul composant qui hérite de la garde de contraste.
Un audit UX a montré que l'accessibilité n'était vérifiée que sur une fraction de l'interface. Le contrat d'un champ vit à un seul endroit, et un écran vide propose toujours une porte de sortie.
Des actions de même nature avaient des formes différentes d'un écran à l'autre. Quatre altitudes d'action, quatre formes de bouton, et rien d'autre.
Trois écrans similaires exposaient leurs actions de trois façons, parfois invisibles au clavier. Un composant unique les rend toujours visibles et accessibles.
Le panneau de debug affichait les étapes dans le désordre. Chaque appel porte désormais son instant mesuré depuis le début du run, et le panneau suit l'ordre réel d'exécution.
Revenir sur une page ré-exécutait une action de carte déjà faite. Chaque clic reçoit un identifiant à usage unique, vérifié au moment de la consommation.
Le déploiement effaçait le répertoire vivant sous les conteneurs en service. La nouvelle version se prépare à part et ne bascule que prête.
Promouvoir des champs variés en labels Loki multipliait les flux indexés. Seuls les champs à petit ensemble fermé de valeurs deviennent des labels ; le reste se filtre à la lecture.
Trois endroits lisaient l'adresse de l'appelant, et un visiteur pouvait la falsifier. Un seul résolveur préfère l'en-tête que Cloudflare écrase, ce qui ferme le contournement des limites.
LIA apprend quand tu fais quoi par des statistiques déterministes et explicables, calibrées par simulation. Chaque habitude se voit, se corrige, se bloque, et un seul interrupteur ferme tout apprentissage.
Un installateur guidé construit l'application localement ou utilise des images vérifiées par empreinte, et ne lit jamais un secret ailleurs que sur l'entrée standard.
Des limites par utilisateur ne bornent pas une instance : N comptes font une dépense non bornée. Un budget journalier d'instance, mis à jour atomiquement, borne le déploiement lui-même.
Transcription, synthèse vocale, images… chaque capacité non connecteur a son interrupteur d'administration, qui retire réellement la capacité à l'assistante.
Les tests du démonstrateur figeaient ce que le code faisait le jour de la livraison. Chaque promesse est recalculée depuis la source de vérité ; une nouveauté non classée fait échouer la CI.
La dernière position connue ne servait qu'aux notifications. Toutes les fonctionnalités la lisent désormais, et son âge est toujours annoncé.
Certains fournisseurs ne renvoient la consommation que si on la demande. Chaque fournisseur déclare son mode de comptage, vérifié au démarrage, et un appel payant sans compte déclenche une alerte.
Le délai d'attente par modèle était éditable mais jamais appliqué. Il devient la borne transport de chaque appel, confrontée aux latences réelles, et rien autour d'un appel ne le coupe plus tôt.
1 200 lignes de stratégie de reprise n'avaient jamais été appelées. Elles sont supprimées : du code mort coûte à chaque changement.
DeepSeek facture selon l'heure UTC. Chaque ligne de tarif porte ses fenêtres horaires, et chaque appel est valorisé à son propre instant.
LIA installe des plugins portables au standard Agent Plugins : compétences et serveurs MCP en un geste, avec un rapport composant par composant.
« Fais une recherche puis formalise en CSV » : un modèle rédacteur produit le contenu structuré, et des moteurs locaux construisent le fichier Excel, Word, PowerPoint ou PDF.
Cinquante et une sections repliées en accordéon, c'était beaucoup. Un rail liste les sections, un panneau affiche la sélection, rendus depuis une table unique.
La page des capacités décrivait le produit d'il y a six mois. Une seule agrégation répond à « où en est cette capacité », et un assert oblige chaque nouveauté à y figurer.
Administrer 124 modèles une boîte de dialogue à la fois n'est pas tenable. Le catalogue s'exporte en classeur Excel et se réimporte, avec un aperçu des changements avant écriture.
« Voir tout l'historique » menait à une page qui ne l'avait pas. Une page publique, rendue côté serveur, publie chaque version.
L'auto-évaluation du journal ne produisait aucun signal depuis des mois. Seuils adaptatifs par personne, garde de l'initiative et boucles enfin fermées la réactivent.
Des fonctions de raisonnement sur l'ontologie n'étaient consommées par rien. Elles sont supprimées selon la doctrine : une capacité non branchée disparaît.
Une chronologie d'activité rassemble ce que LIA a fait de sa propre initiative, lue en parallèle depuis les journaux d'audit existants.
Quand un fait change, l'ancien souvenir n'est plus effacé : il est marqué remplacé et relié à son successeur.
LIA retient les consignes explicites sur sa manière de travailler pour toi — une septième catégorie de mémoire, aux critères stricts.
L'état émotionnel de LIA module les paramètres de la voix de synthèse — expressivité, stabilité — avec des gains doux et une zone neutre.
Les propositions de LIA s'affichent dans une boîte dédiée, sans aucune autorité nouvelle, et le budget ReAct s'adapte au travail réellement produit.
Le programme d'évolution se clôt sur un inventaire prouvé : la proactivité ambiante existait déjà sous forme de routines conditionnelles, dont la création vaut consentement. Les missions de plusieurs jours, un critique automatique et la transformation de routines en compétences sont réservés à l'arbitrage du propriétaire, preuves à l'appui.
Des yeux animés traduisent ce que fait LIA — réfléchir, chercher, parler, attendre ton accord — à partir de signaux qui existaient déjà, sans aucun backend nouveau.
Trois versions de Python coexistaient entre images, CI et postes. Un seul interpréteur, CPython 3.14 sur Debian Trixie, pour tout l'environnement.
Le score lexical écrasait le score sémantique et rejetait de bons passages. Le seuil porte d'abord sur le sens, et le lexical n'ajoute qu'un bonus borné.
Un noir absolu pour les écrans OLED : un raffinement du mode sombre porté par un attribut, pas un quatrième thème qui casserait les autres.
89 modèles sur 114 portaient des capacités par défaut jamais vérifiées. Deux registres publics alimentent le catalogue, et chaque ligne dit d'où viennent ses capacités.
Les applications mobiles sont publiées une fois pour tous les serveurs auto-hébergés. Android reçoit les notifications par le Firebase de chaque serveur ; iOS passe par un relais qui ne transporte aucun contenu.
Demander à un modèle de réfléchir passait par quatre formes stockées et sept constructeurs. Une seule intention, un profil dérivé et une seule couture de traduction par fournisseur.
LIA produisait des centaines de métriques sans en lire aucune. Un auto-contrôle périodique, une mémoire d'incidents diagnostiqués et des réponses qui contournent une panne connue.
« Donne-moi une minute » n'est pas une réponse. La boucle ReAct partage la mémoire du pipeline, gagne son budget en produisant, et ne publie jamais un message qui annonce un travail qu'elle ne fera pas.
L'identité d'un tour voyageait dans un dictionnaire non typé. Elle passe dans un contexte typé et figé de LangGraph — sans adopter Agent Server, incompatible avec LIA.
Pour les calculs qu'un modèle fait mal, l'agent écrit un court script et l'exécute dans le bac à sable existant, en mode ReAct seulement, avec des données passées sans être recopiées.
Le déploiement se terminait sur une erreur qu'on avait appris à ignorer. Le verdict distant est désormais lu dans un fichier, jamais déduit d'un code de sortie SSH.
53 sections de réglages avaient la même couleur et parfois la même icône. Les icônes en collision sont corrigées, et douze tons de groupe, mesurés, aident à s'orienter.
Les yeux avaient atteint le plafond du CSS. Un moteur TypeScript calcule chaque canal à chaque image et publie des propriétés que la feuille de style se contente de lire.
Chapitre 6 · 1 sept. 2026 – aujourd'hui · 135 décisions
Des registres scellés, des comptes exacts, le tableau de travail, les réunions, le téléphone et le mode Live — et des échecs dits plutôt que devinés.
Le modèle qui écrit la réponse déclare lui-même son registre — rassuré, désolé, enjoué… — dans un vocabulaire propre à l'animation du visage.
Six tâches de fond partaient à la même seconde. Un décalage aléatoire à la source, un amortisseur court côté fournisseur et une attente qui expire ouverte absorbent la rafale.
La lecture des schémas JSON des outils MCP était dupliquée. Un seul module lit la déclaration à la lettre du standard, pour l'adaptateur comme pour le planificateur.
Le budget ReAct ne comptait que le raisonnement. Le temps des outils devient un second budget nommé, chaque appel a sa borne, et une délégation ne peut plus tout consommer.
Une revue de la littérature a servi de grille de lecture : la provenance survit à la compaction, l'ancre du tour tient, les comptes de trace sont honnêtes, la validation vérifie la couverture et le contexte livré est mesuré.
Le bouton « + » transforme le téléphone ou l'ordinateur en enregistreur : l'audio part par segments, et LIA rend un compte rendu structuré — date, participants, décisions, actions.
Trente modèles intégrés ou les tiens, choisis automatiquement selon la réunion, et un compte rendu qu'on peut reformater dans un autre modèle.
Réinitialiser une conversation effaçait aussi des apprentissages. Chaque famille de clés déclare sa portée, et la purge ne retire que ce que sa famille déclare.
Une notification push de Gmail ou de Drive met un réveil en file d'attente. LIA le sert sous toutes ses règles d'éligibilité, et Drive ne resynchronise que ce qui a changé.
Un espace de connaissances suit un libellé Gmail, jamais toute la boîte. Retirer le libellé retire le document : le consentement, c'est le libellé.
Chaque outil déclare s'il lit, rédige, demande confirmation ou agit. Chaque action est inscrite avant d'avoir lieu puis soldée depuis son résultat, et trois registres, que l'instance peut sceller par compte, retracent ce que LIA a fait, lu et décidé.
Les sourcils ont une courbure, une même respiration porte le visage, et la bouche a une vie propre : le visage de LIA bouge sans jamais sortir d'un budget de quelques pixels.
Une grille hebdomadaire montre quand chaque routine a tourné et avec quel résultat, à partir d'un historique écrit au moment du résultat.
Le diagnostiqueur collecte ses preuves au moment où l'incident se produit, source par source, et un texte envoyé à un fournisseur d'embeddings est toujours une chaîne exacte.
Ollama est servi par son client natif, et son serveur déclare lui-même ce que ses modèles savent faire : outils, vision, raisonnement, taille de contexte.
Un seul moteur de récurrence sert les routines et les rappels : « tous les deux mardis à 8 h » devient possible, et un rappel peut enfin se répéter.
Pour chaque relation, LIA écrit une fois par jour une synthèse datée — où tu en es, quoi aborder —, relue par le chat sans jamais la faire passer pour un fait vérifié.
Chaque module qui appelle un modèle déclare où sa dépense est enregistrée, et chaque ligne du registre déclare qui en est l'auteur : toi, une routine ou LIA d'elle-même.
Le tableau de bord lisait tes sources deux fois par chargement. Les demandes simultanées partagent désormais le même travail, y compris entre plusieurs processus.
Tout appel payé par la plateforme est borné à la fois par le plafond du compte et par le budget journalier de l'instance, à la porte la plus intérieure.
Les registres téléchargés étaient plafonnés en lignes. Un curseur côté serveur les diffuse en entier, avec un total exact annoncé d'avance.
Le modèle dit ce qu'est un contenu — liste, citation, alerte, tableau — et le moteur de rendu le dessine avec les mécanismes natifs de Word, PowerPoint, Excel et PDF, sans jamais déborder.
Une réponse structurée tronquée par la limite de jetons n'est plus recollée en document plus court annoncé comme réussi : c'est un refus, dit comme tel.
Un ticket a un cycle de vie, un porteur et un résultat. LIA peut exécuter un ticket, poser ses questions dessus et attendre ta réponse, seule ou avec un pair.
Tu épingles tes sections de réglages favorites dans un dock flottant : la liste suit ton compte, la position suit ton appareil.
La taille de contexte n'est plus un réglage global de l'instance : chaque poste configuré a la sienne, pré-remplie depuis ce que le serveur déclare.
Images, documents et captures produits par LIA ont leur galerie, et réinitialiser une conversation n'efface plus les fichiers des autres.
Vingt-cinq capacités ont chacune leur interrupteur. Couper une capacité retire la fonction, jamais tes données, et la carte des capacités ne compte que ce qu'elle nomme.
Une réunion se termine à 15 h : LIA peut demander comment elle s'est passée juste après, et une veille sur un e-mail attendu est servie à la minute.
Une réponse conservée est une copie qui t'appartient : elle survit à la réinitialisation de la conversation, se relit, s'exporte.
Chaque processus déclare et publie la mémoire qu'il occupe : le superviseur ne charge plus l'application, les bibliothèques lourdes se chargent à l'usage et le cache vocal est borné.
L'audit des prompts a trouvé six endroits où le texte disait autre chose que le code. Chaque variable a un producteur, chaque borne vient d'une seule constante.
Un modèle qui réfléchit par défaut dépensait tout son budget à penser et rendait des rappels vides. Une réponse courte se demande sans raisonnement, et une famille de modèles se déclare une fois.
Un résultat d'outil est projeté élément par élément sous un budget de jetons, et la coupe est annoncée : l'agent lit des e-mails entiers au lieu d'en-têtes techniques.
Un e-mail arrive nettoyé — sans historique cité ni signature —, à trois niveaux de détail, et son résumé est calculé une seule fois puis mis en cache.
Deux e-mails indépendants dans un même tour sont présentés l'un après l'autre, chacun avec sa décision ; seul un lot déjà approuvé reste groupé.
Une carte de brouillon est décrite une seule fois et dessinée selon la surface : carte visuelle dans le chat, texte lisible sur un ticket.
LIA t'appelle sur un numéro vérifié par un code prononcé, lit tes données pendant l'appel, et ce que tu dis devient ton propre message dans le chat.
Chaque réponse conservée est indexée dans un espace de connaissances personnel : LIA peut la retrouver quand tu lui en reparles.
Ton portrait se nourrit de quatre sources — souvenirs, intérêts, habitudes, relations — et dit lesquelles il a pu lire.
Au lieu d'un catalogue coupé dans l'ordre d'enregistrement, la boucle ReAct lie les outils les plus pertinents pour ta question, en couvrant chaque famille.
Sourcils posés sur l'œil, parole générée syllabe par syllabe, gestes variés et petites scènes au repos : l'avatar ne joue jamais deux fois la même chose.
Un document d'un espace de connaissances, même en pause, se joint à un message comme une copie, sans toucher à l'espace.
LIA ouvre une pièce jointe : son texte quand elle en a un, le modèle de vision quand c'est une image ou un scan.
Un dossier Drive lié s'indexe avec ses sous-dossiers, et au-delà d'un seuil LIA annonce le nombre exact de fichiers avant de synchroniser.
Un script peut appeler un service à travers un seul proxy, avec des jetons qu'il ne peut pas lire. Un hôte inconnu donne lieu à une question que LIA ne peut pas sauter.
Un modèle vocal écoute et répond dans le même souffle, sur ta propre clé ; chaque demande de données ou d'action est déléguée au moteur de LIA, avec les mêmes règles que le chat.
Chaque fournisseur déclare son mode de connexion et sa façon de déléguer, sans aucune branche sur son nom : Gemini Live, GPT-Live puis ElevenLabs passent par la même couture.
Au téléphone comme dans le navigateur, « Live » délègue chaque demande pendant la conversation et « Live direct » lit sans agir puis relaie tes mots à la fin : une seule clôture pour les deux.
Reconnecter ses services Google ou Microsoft demande un seul parcours OAuth par compte, vérifié par une identité signée, et chaque service garde son propre état.
Quand un outil échoue, LIA le dit avec la vraie raison au lieu d'inventer un diagnostic, et les métriques comptent enfin les échecs comme des échecs.
Une connexion à la base n'attend plus jamais la réponse d'un fournisseur : les réveils bloqués, les verrous tenus et les connexions « en transaction » inactives disparaissent.
Chaque famille de modèles d'image déclare ce qu'elle accepte et comment elle est facturée : OpenAI et Qwen Image passent par un seul client, et une image peut être retouchée.
La surface de requête des modèles Claude est déclarée une fois, et le cache de prompt est façonné et facturé exactement comme le fournisseur le mesure.
Wikipédia, la navigation, Places, la météo et l'environnement ne demandent rien à la personne : c'est l'administrateur qui les active pour tout le monde.
Une option fait réutiliser à chaque tour ReAct le préfixe du tour précédent — tous les outils, puis le contexte du tour après la question —, pour payer moins cher les jetons déjà envoyés.
Le stable avant le variable, une seule frontière, aucune écriture de cache que personne ne relit : chaque fournisseur traduit la même règle dans son propre mécanisme.
Ce que la boucle part chercher finit obtenu ou déclaré manquant. Un manque déclaré ouvre une passe de rattrapage bornée, et la réponse dit ce qui n'a pas pu être obtenu.
Chacun choisit entre échanges fréquents et échanges ponctuels. Fréquents : LIA garde tous ses outils et prépare chaque tour pour que le suivant relise le précédent en cache, un premier message plus coûteux puis des suivants bien moins chers. Ponctuels : elle choisit les outils par pertinence, pour un coût stable.
Un message envoyé à quelques comptes choisis était ensuite montré à tout le monde à la connexion suivante : la liste des destinataires n'était pas gardée. Elle l'est désormais, et l'administrateur relit sous le formulaire l'historique paginé de ce qui est parti — date, destinataires, délai d'expiration.
Jusqu'ici, LIA ne se souvenait que de ce que le message évoquait. Elle peut maintenant chercher un sujet découvert en chemin — l'expéditeur d'un e-mail, un lieu, une consigne donnée un jour. Au téléphone, cette recherche répond enfin à la question posée, au lieu de rendre les derniers souvenirs.
Écrire à sa propre boîte ne demande plus de valider un brouillon, comme l'appel téléphonique à soi-même : « chaque matin, envoie-moi la météo par e-mail » peut tourner en routine. Le destinataire n'est jamais un paramètre : la boîte connectée, ou l'adresse vérifiée du compte.
Pour qui l'active, un modèle dédié réécrit la description de chaque nouvelle image avec les techniques que les fournisseurs recommandent : cadrage, lumière, objectif, style. Ce qui est demandé ne change pas, le texte à écrire dans l'image reste mot pour mot, et au moindre doute la demande d'origine part telle quelle.
Un clic sur une image l'envoie à une connexion, avec un commentaire si l'on veut. Elle arrive dans ses images, comme si elle l'avait générée, et dans son chat, le commentaire cité tel quel — jamais transformé en lien ou en image cachée.
En dehors du débogage, les journaux ne gardent plus que des nombres, des longueurs et des identifiants : ni les recherches d'une personne, ni ses centres d'intérêt, ni les noms de ses contacts ou de ses fichiers. Quand une base de données ou un service cite la donnée qu'il refuse, la citation est retirée avant l'écriture. Un test lit chaque ligne de journal du code et refuse celle qui écrirait les mots d'une personne.
Un calcul, une date ou une conversion de devises ne s'estiment plus de tête : LIA les calcule exactement, au taux de référence du jour, qu'elle nomme. Elle peut aussi chercher dans son journal un sujet découvert en chemin, te dire ce qu'elle a fait et consulté sur une période avec des totaux exacts, et te remontrer un fichier qu'elle a produit tant qu'il existe encore.
Depuis la galerie, tu peux conserver une image, un document ou une capture : le nettoyage automatique ne le supprime plus, dans une limite par compte affichée avant tout refus. Ne plus le conserver lui redonne une échéance, jamais une suppression immédiate, et le chat dit à chaque lecture si le fichier est conservé ou n'existe plus.
Un message arrivé d'ailleurs — un autre onglet, Telegram, une routine, un rappel — s'affiche sans recharger la page : le serveur prévient dès que le message est enregistré, et le chat ajoute ce qui manque sans toucher à ce qui est déjà affiché. Rien ne bouge pendant qu'une réponse s'écrit, et un lecteur remonté dans le fil n'est pas déplacé.
Une image, un document, une capture ou une réponse part par e-mail, en pièce jointe, avec l'objet et les mots choisis par la personne — LIA n'écrit rien à sa place. Il part de sa boîte connectée vers qui elle veut, ou, sans boîte, vers sa propre adresse vérifiée. Chaque boîte a sa taille maximale, tirée de la documentation de son fournisseur et annoncée avant l'envoi.
Une routine suit soit une planification, soit une condition — jamais les deux : on choisit d'abord quand elle s'exécute, et seuls les champs de ce choix s'affichent. Une routine qui attend quelque chose n'a plus d'horaire : LIA vérifie la condition elle-même, jour et nuit, jusqu'à un dernier jour facultatif. Elle ne s'exécute que sur un fait nouveau, jamais deux fois pour le même, dans une limite quotidienne.
Les e-mails, le bot Telegram, les messages d'erreur et les catalogues de l'application s'écrivent désormais dans la langue de la personne qui les lit : plus de phrase française servie par défaut à un compte allemand ou chinois, plus d'e-mail de vérification reçu en anglais. Chaque table de traductions porte les six langues — une vérification automatique s'en assure à chaque changement. Le français écrit en dur que seul le modèle lisait passe en anglais technique, pour ne privilégier aucune langue ; ce qui reste — quelques prompts et libellés en français, des textes adressés au modèle traduits dans les six langues — attend qu'une mesure dise ce que leur traduction change.
LIA devient une station de radio à la demande, dans ta langue : ta journée, puis l'actualité des médias suivis et des sites que tu ajoutes, écrites, vérifiées et dites pour toi pendant que tu écoutes. Une grille fixe décide de ce qui passe, les modèles ne font qu'écrire, et chaque phrase montre sa source. Rien n'est produit quand personne n'écoute, rien n'est gardé après, et ce que coûte la session s'affiche pendant qu'elle dépense.
JEV aide à choisir, orienter ou évaluer parmi des choix bornés, avec un interrupteur à chaud par usage et le parcours existant en cas de doute. Deux usages facultatifs, désactivés par défaut, repèrent l’absence de références personnelles ou le refus de toutes les actions en attente ; aucun n’autorise l’exécution. Les aperçus gardent les résultats canoniques et les observateurs ne bloquent aucune écriture; les administrateurs voient contexte et issue, échecs payants et replis comptent tous deux, et les gains se vérifient sur le parcours complet avant activation.
Les fonctions qui aplatissent un texte pour une voix, une notification ou une carte lisaient certains textes en temps exponentiel : 51 caractères tapés dans le chat coûtaient 4,5 s, un e-mail piégé de 32 Ko gelait LIA 3 s. Chaque motif est réécrit linéaire et deux tests le tiennent, côté serveur comme côté navigateur. La lecture d'une page web contrôle désormais chaque redirection avant de la suivre et se connecte à l'adresse vérifiée, jamais à une résolution ultérieure du nom.
On peut chercher des skills sur skills.sh ou à une adresse GitHub, lire chacune avant de l'installer et la garder à jour ; l'installation reprend exactement le commit lu, chaque fichier vérifié. Une skill écrite ailleurs tourne à part, avec ses seuls fichiers : jamais les connecteurs de la personne, ni image ni contenu web dans ses réponses. Une skill peut exécuter ses propres commandes dans une copie jetable de son dossier, le réseau seulement vers les hôtes permis, et celle que le chat écrit n'entre qu'au clic de la personne.
LIA ne retient plus une notification utile parce qu'un plafond par jour serait atteint : c'est le modèle de décision qui juge si un signal mérite d'interrompre la personne. Chaque passage dans sa plage horaire arrive jusqu'à cette décision, et seuls la plage, les pauses entre deux messages, une réunion en cours et les plafonds de dépense bornent le rythme. Les réveils par e-mail et les moments anticipés suivent les mêmes règles.
LIA se réveille sur une phrase reconnue entièrement dans le navigateur par un petit modèle entraîné pour sa langue, sans la condition technique qui privait l'iPhone et les applications natives de l'ancien mot anglais « OK Guy » ; « LIA, stop » coupe sa voix. Le premier modèle, « Dis LIA » en français, est livré en bêta parce que son banc n'atteint pas encore les seuils publiés, et les autres langues gardent le toucher. En mode Live, un silence met l'assistante en veille : la connexion au fournisseur se ferme, plus rien n'est facturé, et un toucher ou la phrase la réveille sans perdre la conversation.
Les illustrations du blog sont écrites une fois, en quatre largeurs et une image de partage, et servies telles quelles : le serveur ne redimensionne plus rien et le cache de bord les garde. La vidéo de la page d'accueil est hébergée là où l'opérateur le déclare et décrite par un manifeste lu à la demande ; sans lui, la section n'existe pas. En boucle, elle démarre quand elle est visible, avec le son là où le navigateur l'accepte et muette ailleurs jusqu'à un clic, et tant que le son joue, le titre de la page et ceux des sections battent sur la musique grâce à une carte des temps calculée à l'avance.
Les contrôles des modifications ne lisaient qu'une base d'avis de sécurité : la revue de septembre 2026 a trouvé vingt avis publiés par les dépôts des dépendances elles-mêmes, qu'aucun outil ne voyait. Une veille hebdomadaire lit désormais ces avis, les fins de vie, les registres et le moteur du navigateur, et chaque constat est corrigé ou accepté par écrit, avec une date de révision. Les versions Python avancent par une seule commande, après un délai de carence, sans jamais reculer. La sortie d'une génération non maintenue peut être qualifiée par un adaptateur officiel, à règles et seuils inchangés ; des métadonnées de compatibilité seules ne suffisent pas.
Une ligne de journal ouvre la trace de sa requête, une trace ouvre ses journaux et ses métriques, un point de latence ouvre l'exemple qui l'a produit : des liens mesurés hors service en production fonctionnent désormais. La chaîne qui transporte ces signaux est surveillée à son tour, avec une alerte quand des journaux se perdent, et tous les tableaux de bord suivent une même convention : une semaine d'historique et un menu commun.
Les réponses qui portent des données — e-mails, rendez-vous, contacts, lieux, trajets, météo — s'affichent en cartes qui montrent tout ce que la source a fourni, sans jamais inventer une valeur absente, et gardent le détail complet derrière un dépliant. Le modèle ne relit jamais la carte elle-même, seulement les faits autorisés, si bien que la conversation ne s'alourdit pas. Répondre à un e-mail ou ajuster un rappel depuis une carte prépare une demande liée au message d'origine et revérifiée au clic, et un trajet peut s'ouvrir en carte interactive dont le coût est annoncé puis compté.
Un visage Simli optionnel accompagne la voix existante, sur la clé personnelle et avec une seule sortie audible. L’API contrôle la connexion et son arrêt ; la fenêtre expose une fermeture confirmée ou en attente, car le silence peut consommer le forfait. La décision demeure proposée jusqu’à la qualification du fournisseur et des appareils réels ; Radio garde son lecteur.
Relier deux données exige une valeur observée sur la bonne source et le bon compte, avec le rôle attendu ; un mot identique ne suffit pas. Le catalogue conserve les étapes de lecture nécessaires pour démarrer une chaîne et indique les dépendances sans source. Une tentative de modification rend les preuves anciennes périmées avant et après l'appel.
Les demandes explicites sont ancrées aux mots de la personne, puis confrontées aux observations : valeur, date, nombre, opération et exhaustivité. Le jour et le fuseau restent ceux du début du tour, même après une reprise. Un brouillon reste en attente et une délégation opaque reste inconnue ; les lacunes vérifiées atteignent la reprise de lecture bornée et la réponse.
Les lectures indépendantes déclarées peuvent avancer ensemble, avec une limite, puis leurs résultats sont sauvegardés avant une confirmation possible. Une lecture fraîche et complète peut servir de nouveau dans le même tour et contexte. Les modifications invalident cette réutilisation. Un arrêt brutal avant sauvegarde peut encore répéter des lectures ; les observations ne sont pas partagées entre tours.
Les outils MCP de chaque personne sont découverts depuis leurs déclarations actuelles ; seuls les outils réellement construits sont annoncés. Le serveur conserve son identité exacte, séparée des noms simplifiés de routage et d'appel. Une tâche liée à un serveur vérifie sa cible avant confirmation. Les descriptions anciennes reçoivent les capacités courantes sans prétendre connaître toute l'ontologie d'un serveur.
LIA gère ses réglages et objets par des opérations déclarées. Les commandes durables chiffrées lient contenu approuvé, acteur, origine et expiration ; les droits, capacités et préconditions sont relus à l'exécution. Les services sources gardent leurs compare-and-set, les claims sont protégés par jeton. Fichiers, OAuth, données privées et périphériques continuent dans le navigateur authentifié. Une attente n'est pas un succès accompli ; un résultat perdu reste incertain, sans promesse d'exécution externe exactement une fois.
Le dessin frontal texture un relief borné, dont le contour et les franges viennent de l'alpha source. L'anatomie cachée reste approchée ; les yeux, sourcils et bouche sont projetés en DOM/SVG, l'écharpe est volontairement compositée devant. Corps, visage et accessoires partagent le rig existant. Visibilité, mouvement réduit, readiness et contexte graphique gouvernent les ressources et le retour au dessin fixe. Les tests de géométrie et de cycle de vie ne certifient ni toute occlusion ni les performances sur appareil réel.
Un projet Remotion offline conserve chapitres, vues HTML/CSS, poses et accents musicaux pour faire évoluer film et focus ensemble. Les écrans reconstruits citent les sources natives et utilisent des données fictives ; leur géométrie reste fixe hors focus explicite, BIP accompagne la présentation. Le manifeste peut déclarer un film complet distinct de la playlist : son dialogue plein écran suspend le lecteur de fond. Le film est français, ses contrôles sont traduits ; rendu, fichiers livrés, provenance musicale et acceptation du diffuseur restent qualifiés séparément.
Une option serveur vide par défaut permet de présenter BIP lors de la prochaine visite authentifiée, par origine et navigateur. Un identifiant explicite change uniquement le style et son marqueur ; visibilité, taille, positions et choix manuels ultérieurs sont conservés. Aucune colonne avatar n'est ajoutée au compte. Web Locks coordonne les onglets quand disponible ; sans lui, la relecture récente ne garantit pas une transaction simultanée. Désactiver la campagne arrête les nouvelles applications sans rétablir d'anciens choix, et n'atteint pas les appareils hors ligne.
Neuf registres sur la personne — souvenirs, intérêts, habitudes, débriefs, fils ouverts, workboard, routines, rappels, réponses conservées — sont lus en entier, chaque élément citable, sous une seule part de la fenêtre du modèle, et toute coupe est dite. Le portrait redevient une analyse de la personne sur sept facettes, jamais un inventaire, et le résumé s'écrit comme ses propres phrases ; la relecture sémantique, mesurée rejetant les lectures fondées, est retirée : ce qui refuse l'invention est structurel, chaque lecture cite ce qui la fonde. Les budgets sont des cibles énoncées, jamais une coupe. Un changement du journal rend le portrait périmé, servi daté, au lieu de l'effacer ; une entrée supprimée emporte les lectures qu'elle fondait. Mesuré sur dev avant livraison.
LIA enregistre, modifie et met à la corbeille les brouillons Gmail, Outlook et iCloud sans rien demander : un brouillon reste dans la boîte de la personne et n'atteint personne, et la corbeille se récupère. Seul l'envoi demande une confirmation, sur une carte qui montre le brouillon tel que la boîte le tient ; un brouillon modifié dans la boîte entre-temps n'est pas envoyé, et un changement demandé sur la carte est écrit avant le départ. Au passage, la carte de réponse montre enfin, et envoie à, tous ceux que la réponse atteint.
Fish Audio parle (cinq modèles, dont s2.1-pro et drama-3), transcrit les réunions et la dictée, et ses voix se clonent ou se conçoivent depuis l'administration, sous une attestation de consentement versée au journal d'audit. Chaque phrase entendue passe par une seule porte qui la facture une fois, dans l'unité du moteur qui l'a vraiment dite ; chaque compte fournisseur a une seule réserve de requêtes, partagée par toutes les fonctions vocales ; et la dictée distante va au moteur choisi par l'administrateur, que les réglages nomment. LIA glisse des indications de jeu (un rire, un chuchotement, un soupir) dans ce qu'elle écrit pour être dit, dans la syntaxe de chaque moteur qui les joue, et les voix de la radio dialoguent en une seule prise.
Mesuré en production, l'analyseur qui suivait chaque plan en échec qualifiait de passagers des échecs qui ne l'étaient pas, et la boucle de reprise qu'il attendait aurait rejoué l'irréparable. Il disparaît : un échec est dit dans la réponse, une panne passagère est retentée par le client qui l'a rencontrée, et un compteur typé montre chaque étape en échec, y compris avant l'appel d'un outil.
En mode pipeline, la réponse s'écrivait à partir d'une phrase sur les données d'un outil — « 2 destinations » — tandis que les durées, les connexions ou la page suivante restaient de côté : sans elles, 0 réponse sur 9 donnait les temps de trajet, 27 sur 27 avec. Elles arrivent désormais comme en mode autonome, bornées et marquées comme contenu tiers. Et le refus d'un outil ne peut plus devenir un succès en chemin : les commandes Hue disaient avoir allumé une lampe qui n'existait pas.
L'ancienne auto-efficacité ne bougeait que sur l'auto-évaluation de LIA, un seul échange suffisait à faire une force ou une faiblesse, et seule la réponse finale la lisait. Sept domaines gardent désormais deux axes séparés : ce qu'un tour a vérifiablement accompli, et l'utilité que la personne a exprimée par 👍/👎. À partir de cinq observations, LIA peut vérifier un point, poser une question ou nommer une limite — sans changer ni modèle, ni outil, ni budget.
Une connexion acceptée reçoit sa propre copie de skill, serveur MCP ou plugin, désactivée et marquée de son origine. Le paquet relu est immuable, les reprises préservent les modifications du destinataire et les identifiants restent privés. Une skill de pair activée suit explicitement la politique d’une skill créée par le destinataire.
Des décisions natives facultatives annotent une seule fois les preuves autorisées des e-mails et rendez-vous. Le doute reste sans badge, coûts et quotas s’appliquent, et ni une catégorie ni une confiance n’autorisent une action. Corpus figés et nouveaux cas adversariaux relient la politique livrée à des preuves mesurées.
Une carte Position rassemble les Google Places sélectionnés avant leurs cartes individuelles, même en HTML ou Markdown. L’interactivité attend un clic avec coût affiché ; la liste des sources reste utilisable si Maps est indisponible.
L’API repère les chemins inexistants explorés en série et les échecs de connexion, en épargnant les erreurs normales de session ou de ressource. Redis partage un bannissement temporaire entre les workers ; une panne du cache laisse passer les requêtes et reste visible dans les métriques.
Chaque réponse 429 conserve dans les journaux l’adresse du client issue de la chaîne de confiance, la méthode et le chemin sans paramètres. Les accès ordinaires restent discrets, et l’adresse ne devient jamais une étiquette de métrique.
La fiche réutilise les informations déjà obtenues sans rechercher le lieu une seconde fois. Le trajet part de la position navigateur autorisée, de la dernière position fraîche et datée, ou du domicile : marche jusqu’à 2 km inclus, voiture au-delà, avec un seul recalcul si le trajet à pied réel dépasse la limite. Les plafonds restent appliqués et chaque appel payé est enregistré, même si le trajet échoue ou est annulé.
La carte attend une activation explicite sans réserver un grand espace vide. Les mêmes détails s’ouvrent dans une popup sur ordinateur et un dialogue sur téléphone, chacun avec un seul défilement. La liste et les repères partagent les numéros de l’ordre initial ; un lieu sans coordonnées garde son numéro et son lien sans décaler les autres. À contenu inchangé, une carte activée reste active pendant les mises à jour automatiques de l’affichage.
Le téléphone envoie des événements stricts, dédupliqués par source. Les consentements sont indépendants ; exports, effacements, registres et notifications respectent la même autorité.
Une initiative personnelle distincte des alertes, avec politique dédiée et publication atomique dans le chat. Architecture approuvée ; le producteur reste à implémenter avant activation.
Des observations soutiennent épisodes et récurrences, avec portrait autonome, purge et exclusions réversibles persistantes. Les directives encadrent l'initiative ; la base dérivée reste à implémenter.
Les lectures et appels modèles partagent une enveloppe finie et un budget réservé. Les dépenses restent comptées sur refus ou annulation ; les gardes financiers restent à implémenter avant activation.
La sonde de connectivité sortante sépare la résolution DNS de la connexion et confirme une perte sur plusieurs essais espacés. Un paquet DNS perdu n'ouvre plus d'incident critique : une reprise ou une lenteur est signalée comme dégradée, et une vraie coupure nomme l'étape qui a échoué.
Le tour suivant relit désormais tout l'historique depuis le cache au lieu de le réécrire, et ce qu'il relira reste gardé une heure quand une personne attend et échange souvent. Ces écritures d'une heure sont facturées à leur juste prix, et la réflexion d'un tour précédent est rendue au modèle Claude qui l'a écrite, là où il peut la relire.
Chaque compte reçoit désormais au plus quelques e-mails de réinitialisation, quelle que soit l'adresse qui les demande, et un lien ne sert que le compte et le mot de passe pour lesquels il a été émis. Un compte qui se connecte avec Google reçoit un avis à la place d'un lien, un administrateur ne reçoit rien, et une rafale de demandes ou d'inscriptions prévient l'exploitant.
Le navigateur dessine le monde tandis que Redis en arbitre l'accès et les mouvements ; les actions gardent leurs interfaces et approbations natives. Le nom du compte et l'apparence sont partagés avec accord, les activités et la maison restent privées, et les pairs ne voient qu'un statut de connexion grossier. Les messages restent entre leurs destinataires et les traductions consenties sont bornées et comptées.
L'inscription, la connexion par mot de passe et la demande de réinitialisation exigent désormais le jeton d'une vérification Cloudflare Turnstile, que le serveur fait valider : un script qui appelle l'API sans navigateur est refusé. La plupart des visiteurs ne voient rien, et si Cloudflare ne répond pas, seule la connexion passe — une inscription ou un e-mail de réinitialisation attendent.
Ce qu'un serveur MCP personnel propose est gardé sur le compte et resservi d'un message à l'autre, sur n'importe quel processus, pendant qu'un seul le revérifie en arrière-plan. Les serveurs se préparent en parallèle ; un serveur trop lent est laissé de côté pour ce message, nommé dans une notification, et prêt pour le suivant. Quand la copie gardée a dépassé sa fraîcheur, LIA vérifie avant l'appel que l'outil est toujours offert sous la même forme, et refuse sinon de l'envoyer.
Quand la personne désigne un élément qu'elle vient de voir par ce qu'il est — son expéditeur, un mot du sujet —, l'analyse de la demande dit seulement comment il est désigné ; c'est le code qui trouve, parmi les éléments réellement affichés, ceux que ces mots désignent. Un seul : LIA agit et le nomme dans le journal des actions. Plusieurs : LIA demande lequel, par une question qu'aucun modèle n'écrit, et ne devine jamais ; aucun : une nouvelle recherche.
La personne choisit quand LIA lui demande son accord avant un outil MCP : pour tout son compte, pour chaque serveur, pour chaque outil — « ne jamais demander » restant lié à ce que l’outil déclare. Avant tout changement qui ferait moins demander, la page liste ce que LIA ne demanderait plus ; rien n’est verrouillé. Un agent dédié est interrogé une seule fois avant chaque tâche dès qu’un de ses outils le demanderait, et la tâche va alors jusqu’au bout ; depuis la conversation, LIA peut seulement demander davantage.
La section « Outils » ouvre le courrier, l’agenda, les tâches, les contacts, les fichiers, sur Google Drive ou OneDrive, et les lampes de la personne pour qu’elle les consulte et agisse à la main : aucun modèle, aucun jeton, la vitesse du fournisseur. L’écran n’offre que ce que le fournisseur accepte, et ce qu’un client gagne pour l’atelier, les outils de l’assistant le gagnent dans le même temps ; rien de ce que la personne fait à la main n’entre dans un registre, puisque ce n’est pas un acte de LIA.
Demander un jeu ou un petit outil donne une page qui tourne dans la conversation, avec son fichier ; demander le code donne le code, et le texte d’une personne reste du texte. La page s’exécute isolée, sans accès au compte ni à aucun site de son choix, sous une politique qui ne nomme aucun hôte, hormis les fonds de carte que l’opérateur autorise. Relue depuis l’historique, elle attend un clic, car une boucle sans fin figerait l’onglet, et le modèle n’en lit jamais que le titre.
L’administration proposait de régler seize agents qu’aucun tour n’appelait plus : un plan exécute les outils directement, et la production n’a compté aucun jeton sur eux. Leurs postes, leurs nœuds et leurs prompts sont retirés ; le poste Emails reste, car il rédige les messages. Une installation neuve démarre désormais sur des modèles qui ont un tarif.
Résumer un message, proposer une réponse, lire une carte de visite : un clic demande une seule chose à LIA et reçoit une proposition que la personne relit, jamais une écriture chez son fournisseur. L’acte est tracé et facturé à qui a cliqué, et rien n’ajoute de contrôle à un écran qui n’a pas la place : la dernière icône de chaque barre ouvre la liste.
Une session vocale ElevenLabs réglée sur une personnalité cynique parlait comme un assistant enjoué : les balises d'expression du portail imposaient l'enthousiasme et les cadres de LIA demandaient de la chaleur. Désormais chaque voix de la personne, en Live, en Live direct, au téléphone et dans le commentaire vocal du chat, parle dans la personnalité choisie, le fond d'abord, les faits intacts ; LIA écrit elle-même sur l'agent la palette de balises, le message d'accueil et ses outils. Un appel à un tiers reste cordial.
Les aperçus de résultats qu'aucun écran n'affichait plus et la porte JEV de l'initiative, qui ne distinguait rien, sont retirés, et l'évaluateur d'initiative continue de voir chaque tour outillé. Chaque seuil JEV devient un réglage borné, modifiable depuis l'écran d'administration, et chaque jugement payé est compté dans la durée, pour qu'un seuil se décide sur ce qui arrive vraiment et non sur un corpus.
L'heure ne conditionne plus une demande récurrente : un besoin se reconnaît aux jours où il revient, et l'heure ne fait que préremplir. Six sortes de propositions naissent de ce que LIA enregistre déjà — automatiser un besoin, déplacer une routine relancée à la main, élargir les heures de notification, connecter une source… — et un clic les accepte et les exécute. Le chat en montre au plus une sous une réponse, choisie par le code.
Un e-mail, un événement, un contact, une tâche, un fichier ou une lampe montrés dans le chat s'ouvrent dans les Outils. La carte porte une destination signée, liée au compte et à la source qui a répondu ; au clic, le serveur revérifie cette source et refuse en le disant si le compte a changé, plutôt que d'ouvrir une autre fiche qui porterait le même identifiant.
Toutes les icônes passent par une seule porte qui dessine le style choisi par le compte, Lucide, Fluent Color ou Streamline Flex, sans changer le sens d'aucun symbole, et le contraste élevé du système garde ses couleurs. Le thème peut aussi passer seul du clair au noir absolu aux heures choisies, à l'horloge du compte, sans qu'une minuterie écrive jamais le profil.
Un badge ouvre Principale et les annexes nommées, avec leurs historiques et leurs compteurs. Les messages automatiques arrivent dans Principale, tandis que les réglages et les apprentissages sont communs au compte. Réinitialiser ou supprimer retire la génération visée et laisse un reçu qui suit son nettoyage.
Lu seul, un message ne peut pas dire s'il a reçu une réponse : celle-ci est un autre message de la même conversation. LIA lit désormais cette conversation quand elle liste du courrier, et dit partout le même fait : déjà répondu, réponse restée en brouillon, réponse reçue. Elle ne propose donc plus de répondre à un e-mail auquel la personne a déjà répondu, dans le chat comme dans les notifications, l'accueil, les relations et les Outils.
« Neuf heures et demie » ne désigne un instant précis qu'avec le fuseau où tu le dis, et chaque heure que LIA a perdue l'a été quand l'un a voyagé sans l'autre : un rendez-vous déplacé à 9 h 30 se retrouvait à 10 h 30. L'heure et son fuseau forment désormais un seul objet, que LIA remet tel quel à Google, Microsoft et iCloud sans rien convertir en chemin, avec une seule règle pour les deux nuits où l'heure change. Et chaque trajet d'une heure, de l'écran à l'agenda puis de l'agenda à l'écran, est rejoué sur des agendas simulés d'après leur documentation, dans des fuseaux éloignés de l'heure universelle.
Le modèle connaissait l'heure présente, jamais celle des messages précédents : reprise des jours plus tard, une conversation se lisait comme si tout venait d'être dit, et « le dentiste demain », écrit un mardi, restait à venir le vendredi. Chacun de tes messages porte désormais le moment où tu l'as écrit, dans ton fuseau, et tout modèle qui relit la conversation le lit : la réponse, la boucle ReAct, l'analyse de ta demande, le résumé de compaction, l'appel téléphonique, et ce que LIA retient de toi (souvenirs, centres d'intérêt, engagements, journal), dont une échéance se lit désormais dans ton fuseau. Mesuré sur trois familles de modèles avant d'écrire le code, les questions qui en dépendent sont passées d'environ 3 bonnes réponses sur 21 à 14, 16 et 20 sur 21.
Sans clé de recherche personnelle, LIA ne cherchait que sur Wikipédia. LIA fait désormais tourner à ses côtés SearXNG, un métamoteur sans clé, activé par défaut (l'exploitant peut le refuser) : la recherche du chat, l'enrichissement des réponses, la veille de tes centres d'intérêt et les Outils y trouvent alors leurs liens web, sans filtrage comme avec Brave, ta propre clé Brave restant prioritaire. Mesuré avant d'écrire le code : 58 recherches utiles sur 60 dans les six langues, en 0,7 seconde en moyenne. Et une source de la veille qui n'interrogerait rien n'est plus comptée comme consultée.
Deux personnes qui répondaient au même mail recevaient la même réponse de LIA. La première fois que LIA écrit un mail pour toi, elle apprend désormais ta façon d'écrire dans tes derniers mails envoyés — formule d'appel, formule de fin, signature, ton, jamais ce dont tu parlais — et la suit dans chaque réponse et chaque nouveau message, y compris la réponse que tu confirmes, que LIA rédige maintenant elle-même quand tu n'en as pas dicté les mots. Tu la lis, la désactives ou la fais oublier dans les réglages. Mesuré sur des personnes fictives avant d'écrire le code : les réponses sont passées d'environ 42 à 63 marques du style de leur auteur sur 66, sans un seul fait recopié d'un ancien mail.
Un message envoyé pendant que LIA répondait — ou pendant qu'une routine tournait sur ton compte — était refusé et perdu. Le serveur le garde désormais avec sa discussion, sous la conversation, où tu peux le modifier ou le retirer ; les mots écrits ensuite s'y ajoutent. Il part tout seul, comme ton message, dès que LIA a fini normalement ; si la réponse a été arrêtée ou a échoué, il attend ta décision. Il n'est jamais pris pour la réponse à une question que LIA te pose, et « Envoyer maintenant » arrête la réponse en cours puis l'envoie. Chaque exécution dit désormais comment elle s'est terminée, et c'est cette fin, écrite quand le compte se libère, qui décide.
Ce que tu écris pendant que LIA travaille est souvent une précision de ta demande (« seulement ceux ouverts le dimanche »), et l'envoyer après la réponse refaisait le travail. En mode ReAct, ton message en attente peut désormais rejoindre la réponse en cours : LIA le lit à sa prochaine étape, comme tes propres mots, et en tient compte pour la suite, sans rien réécrire de ce qui précède. Tant qu'elle ne l'a pas lu, tu peux le modifier ou le retirer ; si elle finit avant, il part juste après, comme d'habitude. Ta note reste dans la discussion, à sa place, et la demande que retiennent la réponse, la mémoire et les tours suivants l'inclut.
Une routine peut désormais s'exécuter quand un autre système l'appelle : une box domotique, une forge de code, un service de formulaires. LIA donne à la routine sa propre adresse et un secret, montré une seule fois ; l'autre système signe chaque appel avec, et LIA sert l'appel dans la minute, en lisant ce qu'il a envoyé comme une donnée, jamais comme une instruction. Un appel sans signature valide est refusé, une rafale est bornée, un envoi répété compte une fois, et un secret perdu se remplace par un nouveau qui retire aussitôt l'ancien. Un administrateur peut fermer la capacité ; le démonstrateur la garde fermée.
Une routine peut désormais attendre qu'une page web change : un prix, un « en stock » qui revient, une annonce ajoutée. LIA lit elle-même la page publique, sans modèle, et ne lance la routine que pour les lignes qui y apparaissent, lues comme des données, jamais comme des instructions. Une ligne qui disparaît puis revient est annoncée à nouveau.
Un document que LIA génère utilise désormais les mécanismes de son format : un tableur calcule avec de vraies formules, un graphique se modifie dans Excel ou PowerPoint, une présentation que tu vas projeter s'anime sobrement, un rapport s'ouvre sur une page de garde avec ses chiffres clés, ses figures et ses sources cliquables. Le modèle dit ce que les choses sont et le moteur les dessine, dans une palette au contraste vérifié qui suit le ton du document. Les illustrations sont des images générées : elles ne viennent que si tu les autorises dans Réglages › Documents, dans un budget, et chacune est comptée dans tes coûts.