La révolution Memory OS derrière OpenHuman

En 2026, la course à l'IA personnelle passe de « le modèle est-il assez intelligent ? » à « l'agent se souvient-il de moi ? ». Memory ChatGPT, contexte projet Claude, AGENTS.md des coding agents — même douleur : les LLM sont stateless ; quelques bullets system prompt ne sont que des post-it. Le projet open source OpenHuman (TinyHumans AI, GPL-3.0) va plus loin en élevant « memory » au rang de CPU et scheduler : un Memory OS (système d'exploitation mémoire) — pas un plugin vectoriel, mais une pipeline Memory Tree local-first, auditable et éditable. Cet article décortique l'architecture et explique pourquoi les développeurs Apple Silicon font tourner ces agents 7×24 sur Mac mini M4 Cloud Mac.

Pourquoi Memory OS plutôt qu'une fenêtre de contexte plus longue

Passer de 8K à 1M tokens ne change pas le fait : à la fin du chat, rien ne reste dans les poids. La « mémoire » produit ressemble souvent à :

• quelques préférences utilisateur dans le system prompt ;
• RAG session depuis une base vectorielle ;
• plugins montant Notion ou Drive temporairement.

Cela soulage sans abstraction OS : ingest unifié, format persistant, scopes de retrieval, lifecycle et stockage lisible. La métaphore Memory OS d'OpenHuman : Memory Tree n'est pas « un wrapper de plus », mais une pipeline déterministe transformant mail, Slack, GitHub, transcriptions en base Markdown queryable par l'agent et ouvrable par l'utilisateur. La doc : « You can't trust a memory you can't read. »

Qu'est-ce qu'OpenHuman

OpenHuman est l'application desktop agent IA personnel local-first de TinyHumans (Rust + Tauri) — « memory and doer » de votre vie numérique, pas seulement chat. Contrairement aux frameworks terminal-first :

• Memory Tree + Obsidian Wiki pour mémoire long terme structurée ;
• Auto-fetch tire périodiquement les nouvelles données SaaS sans prompt manuel ;
• Chaîne d'outils : recherche web, code, navigateur, Cron, multi-agent, voix, Google Meet Agent ;
• 118+ intégrations OAuth (tableau comparatif — voir doc à jour).

Autour de mai 2026, forte attention GitHub et Product Hunt — le différenciateur est Memory OS, pas une UI de chat de plus.

Cœur Memory OS : pipeline Memory Tree déterministe

Selon la doc Memory Tree, chaque donnée suit le même hot path :

source adapters (chat / email / document)
        ↓
canonicalize    → Markdown normalisé + provenance
        ↓
chunker         → IDs déterministes, ≤3k tokens
        ↓
content_store   → fichiers .md atomiques sur disque
        ↓
store           → chunks.db (SQLite)
        ↓
score           → signaux + embedding + extraction entités
        ↓
source / topic / global trees  → résumés par scope
        ↓
retrieval       → search / drill_down / topic / global / fetch

Trois principes de design ingest

• Deterministic : IDs content-addressed — pas de doublon à ingest répété.
• Fast : hot path sans LLM, heuristiques bon marché seulement.
• Bounded write : transaction unique — pas d'ingest à moitié en DB.

Travail lourd — embedding, entités, résumés seal, digest quotidien — dans la file de jobs background (3 workers par défaut, sémaphore limitant les appels LLM parallèles lors des pics Auto-fetch).

Trois arbres : Source, Topic, Global

Le « système de fichiers » Memory OS n'est pas un key-value plat mais trois arbres de résumé :

La similarité vectorielle agit en bas, mais la structure arborescente compresse et navigue — frontière avec le « sac RAG pur ». Cycle leaf : pending_extraction → admitted → buffered → sealed (ou dropped) ; retrieval remonte la provenance sans relancer la pipeline.

Obsidian Wiki : mémoire lisible, modifiable, supprimable

Double écriture : chaque chunk va dans memory_tree/chunks.db et en .md sous wiki/ — vault Obsidian, inspiré du workflow obsidian-wiki de Karpathy. La page Intelligence ouvre Obsidian ; les hits de recherche sautent au Markdown source.

Pour les développeurs :

• versionner wiki/ avec Git (attention données sensibles) ;
• corriger une mémoire agent erronée directement en .md ;
• audit compliance : clair + scores + provenance, pas embeddings boîte noire.

Auto-fetch : Memory OS « tient la comptabilité » activement

La plupart des mémoires agent sont passives — @ fichier, coller lien, export manuel. Auto-fetch OpenHuman (~20 minutes) parcourt les connexions actives et écrit nouveaux mails, messages et PR dans Memory Tree. Le scheduler déclenche à UTC 0:00 digest global et flush des buffers stale.

Nouvelle UX : le matin l'agent a déjà « le contexte d'hier » — comme le page cache OS, pas un cold boot depuis le cloud.

Backend agentmemory : partager la mémoire avec Cursor et Codex

Si vous hébergez agentmemory (npx -y @agentmemory/agentmemory) pour Cursor ou Claude Code, définissez memory.backend = "agentmemory" dans config.toml. OpenHuman devient client REST mince ; storage, embedding et retrieval hybride (BM25 + vector + graph) passent par agentmemory.

Mapping typique (doc) :

• store → POST /agentmemory/remember
• recall → POST /agentmemory/smart-search
• lifecycle : consolidation, retention scoring, auto-forget, graph extraction

chunking/sealing Memory Tree et trait backend sont orthogonaux — basculer agentmemory ne change pas l'ingest wiki Obsidian, mais le recall agent passe par la lib partagée. Migration : export SQLite → POST agentmemory → redémarrer config (pas de hot migrate).

Memory OS vs base vectorielle vs contexte chat

Différence mémoire avec OpenClaw et autres agents

OpenClaw (souvent couvert ici) excelle en routing multi-canal, santé daemon, tunnel SSH vs WSS. Mémoire souvent plugin ou DB externe, pas Memory Tree intégré. OpenHuman productise la mémoire dans Intelligence : métriques, graphe entités, heatmap ingest, entrée Obsidian.

Les deux sur un Cloud Mac : OpenHuman comme OS connaissance personnelle, OpenClaw pour orchestration Telegram/Webhook — séparez OPENHUMAN_WORKSPACE et config OpenClaw, isolez pics CPU/RAM via launchd ou tmux (embedding et gateway ne se chevauchent pas).

OpenHuman sur Mac mini M4 Cloud Mac

Pourquoi Cloud Mac pour une app desktop ? Trois profils concrets :

• Développeur Windows/Linux principal : macOS pour OpenHuman Tauri + Ollama Metal sans acheter de Mac — comme Xcode distant depuis Windows.
• Auto-fetch 7×24 : veille laptop casse sync ; nœud M4 dédié reste en ligne SSH/VNC, Memory Tree grandit en continu.
• Gros wiki : chunks.db + Obsidian + caches modèles — extension 1 To/2 To voir FAQ stockage M4.

Matériel : 16 Go vs 24 Go et Ollama

fast-score n'utilise pas le GPU ; embedding et résumés background si. Avec Local AI (Ollama) sur M4 — comme les expériences MLX/Ollama : 16 Go pour sync léger + petit modèle embed ; 24 Go pour workers parallèles, modèles embed plus grands et IDE ouvert. Disque : 1 To minimum pour IA + Memory OS.

Déploiement en bref

1. Louer Mac mini M4 Vuncloud, SSH, workspace sur volume persistant.
2. Installer release OpenHuman, configurer intégrations OAuth.
3. Premier Run ingest manuel, vérifier croissance wiki/ et métriques Intelligence.
4. (Optionnel) Ollama + Local AI pour embedding on-device.
5. (Optionnel) agentmemory pour recall partagé avec Cursor.

Acheter un Mac ou louer Cloud Mac pour Memory OS ?

Si Memory Tree est votre second cerveau productif avec mail pro et repos connectés, le Mac mini local séduit par privacy et absence de loyer — jusqu'au backup second site ou wiki miroir lecture seule partagé. Test court : louer un nœud dédié à la semaine pour OpenHuman + agentmemory ; long terme voir TCO local vs location. Équipes CI avec runner macOS GitHub Actions splittent souvent les locations en parallèle.

FAQ

Qu'est-ce que Memory OS ? Métaphore OpenHuman pour Memory Tree + wiki Obsidian + Auto-fetch — ingest, stockage, index, scheduler et retrieval comme un OS.

Où sont les données ? Par défaut ~/.openhuman/memory_tree/chunks.db et wiki/ — SQLite et Markdown locaux.

agentmemory avec Cursor ? Oui — memory.backend = "agentmemory" et service REST local.

Différence avec base vectorielle RAG ? Arbres Source/Topic/Global, digest temporel, wiki éditable — pas seulement similarité.

Mac obligatoire ? Desktop cible macOS ; 24/7 souvent Cloud Mac.

Conflit OpenClaw ? Pas forcément — séparer répertoires et ressources.

Beta stable ? Projet actif, itération rapide — sauvegardez chunks.db et wiki/ vous-même.

Conclusion

La voie Memory OS d'OpenHuman fait passer l'IA personnelle de « chat + RAG temporaire » à un OS connaissance local-first et auditable. ingest déterministe, trois arbres de résumé et double écriture Obsidian répondent à « pourquoi l'agent se souvient ? » — pas par un contexte plus grand, mais par une couche mémoire structurée. Sur Apple Silicon : Ollama et agentmemory localement, Cloud Mac si besoin de sync permanent — chemin 2026 concret pour l'ingénierie IA personnelle.