Honcho memory : test et avis, 90,4 % confirmé par notre recalcul (avantages et limites)

Honcho memory : test et avis, 90,4 % confirmé par notre recalcul (avantages et limites)

Honcho memory, la couche de mémoire pour agents IA de Plastic Labs sous licence AGPL-3.0, annonce 90,4 % sur LongMemEval S. Notre test du 28 octobre 2026 a recompté ses fichiers de résultats bruts et trouvé le même score : 452 réponses justes sur 500. Sur LoCoMo, avec les mêmes 1 540 questions des deux côtés, l'avance de Honcho sur Claude Haiku 4.5 seul est de 6,3 points, et non les 14,3 publiés.

Une bonne mémoire. Une avance plus modeste. De vrais compromis.

Honcho memory vaut-il le coup ? Le verdict en un tableau

Choisis Honcho si ton agent doit modéliser une personne pendant des mois ; passe ton chemin pour du RAG documentaire, un rappel instantané ou un fork propriétaire.

Honcho est la seule option AGPL-3.0 parmi les couches de mémoire dédiées (Mem0, Letta et cognee sont sous Apache-2.0, LangMem sous MIT), et son cloud facture le raisonnement à chaque requête en plus de l'ingestion.

Les anciens tests citent encore $100 de crédits offerts. La documentation annonce désormais $5, plus $5 par mois avec une carte.

Comment fonctionne Honcho memory ?

Ton application écrit des messages entre des peers, puis un worker en arrière-plan les transforme en conclusions que tu interroges en langage naturel ou récupères comme contexte.

Un peer est n'importe quel participant, utilisateur ou agent. Le quickstart v3 de la documentation Honcho montre tout le flux (code source sur GitHub) :

import os
from honcho import Honcho
honcho = Honcho(workspace_id="my-app-testing", api_key=os.environ["HONCHO_API_KEY"])
alice = honcho.peer("alice")
tutor = honcho.peer("tutor")
session = honcho.session("session-1")
session.add_messages([
    alice.message("Hey there — can you help me with my math homework?"),
    tutor.message("Absolutely. Send me your first problem!"),
])
answer = alice.chat("What learning styles does the user respond to best?")

peer.chat() répond aux questions posées en langage naturel. La recherche hybride BM25 + vectorielle retrouve les messages et les conclusions, c'est-à-dire les faits dérivés par Honcho. session.context(summary=True, tokens=10_000) renvoie un contexte limité en tokens prêt à injecter dans un prompt.

Le raisonnement est asynchrone. Un nouveau fait apparaît une fois le deriver passé, pas à la lecture suivante ; l'endpoint representation du README est la voie à faible latence.

Le score LoCoMo de 89,9 % de Honcho tient-il ? Nous avons recompté les fichiers bruts

Les scores de 89,9 % et 90,4 % se reproduisent tous deux depuis les fichiers bruts de Plastic Labs ; sur LoCoMo, en revanche, l'avance à questions égales sur Haiku seul est de 6,3 points.

Le 28 octobre 2026, nous avons recompté trois fichiers de résultats du dépôt honcho-benchmarks (dossier de run a1d689b, nommé d'après le commit de Honcho testé). La colonne « publié » est auto-déclarée sur honcho.dev/evals.

Le test montre où part l'écart. La baseline publiée inclut 446 questions adversariales, sur lesquelles Haiku obtient 46,2 %, alors que le run de Honcho n'en contenait aucune. L'article de Plastic Labs lui-même, Benchmarking Honcho, écrit « Haiku alone scores 83.9% », proche de nos 83,6 %. La page d'évals compare simplement deux jeux de questions différents.

Sur les historiques courts, la raison de choisir Honcho est de consommer moins de tokens, pas d'être plus précis. Les historiques de LoCoMo, de 16K à 26K tokens, tiennent dans n'importe quelle fenêtre de 200K, et ConvoMem a constaté que le contexte complet atteint 70 à 82 % en dessous d'environ 150 conversations.

LongMemEval S est différent : avec environ 115K tokens par historique, l'avance de +27,8 tient. Une précision de périmètre. Ces runs datent d'une configuration de décembre 2025 avec un dialectic Haiku 4.5, alors que la v3.4.1 (2026-10-27) utilise gpt-5.4-mini par défaut.

# files: github.com/plastic-labs/honcho-benchmarks, folder a1d689b
import json, statistics
def score(f, drop_adv=True):
    per_conv = []
    for c in json.load(open(f))["detailed_results"]:
        qs = [q for q in c["question_results"] if not (drop_adv and q["category_name"] == "adversarial")]
        per_conv.append(sum(q["passed"] for q in qs) / len(qs))
    return round(100 * statistics.mean(per_conv), 1)
print(score("locomo_results_20251215_175728.json"))                  # 89.9
print(score("locomo_baseline_results_20251215_184837.json"))         # 83.6, same 1,540 Qs
print(score("locomo_baseline_results_20251215_184837.json", False))  # 75.4, incl. adversarial

Pourquoi les développeurs choisissent-ils Honcho ?

Honcho gagne sur la modélisation de l'utilisateur, parce qu'il tient à jour un portrait de qui est la personne, et cette mémoire la suit d'un outil d'agent à l'autre.

Vectorize (éditeur de Hindsight, un concurrent) a publié en mars 2026 une comparaison des fournisseurs de mémoire pour Hermes qui décrit Honcho comme un modèle comportemental de l'utilisateur, « not just a fact store ». Chaque raison a son revers.

C'est sur les économies de tokens que le marketing prend de l'avance. La page d'accueil promet 60 à 90 %, mais la page d'évals affiche 89 % sur LongMemEval S, 52 % sur LoCoMo et 16 % sur BEAM 100K. Un développeur cité sur la page d'accueil rapporte 10 à 15 %.

Qui utilise Honcho, et pour qui est-il fait ?

542 206 téléchargements du SDK Python sur le mois jusqu'au 28 octobre 2026 montrent que Honcho a de vrais utilisateurs, surtout des développeurs d'agents autour de Hermes et des agents de code.

caption: Signaux d'adoption, relevés le 2026-10-28.
items:
  - value: 542206
    label: téléchargements PyPI de honcho-ai, dernier mois
    source: pypistats.org
  - value: 101791
    label: téléchargements npm de @honcho-ai/sdk, du 27 sept. au 26 oct.
    source: api.npmjs.org
  - value: 7803
    label: étoiles GitHub, 954 forks
    source: GitHub API

La page d'accueil intitule sa bande de logos « Used by developers at » (utilisé par des développeurs chez). Cela désigne des développeurs individuels au sein de ces organisations, pas des contrats à l'échelle de l'entreprise ni des études de cas.

Hermes Agent, de Nous Research, livre Honcho comme plugin de mémoire (hermes plugins install honcho), et la documentation Hermes sur Honcho recense cinq outils, de honcho_profile à honcho_conclude.

Popularité ne vaut pas consensus. Un sondage de 138 réponses sur X autour de Hermes (oct. 2026) place les notes Markdown en tête (27), Hindsight deuxième (25) et Honcho troisième (22).

• Bon choix : compagnons, tuteurs et agents de coaching
• Bon choix : agents de code personnels partagés entre Claude Code, Codex et Cursor
• Mauvais choix : RAG documentaire, rappel au tour suivant, forks propriétaires

Avantages et limites de Honcho : que paie-t-on pour la précision ?

La précision de Honcho est réelle ; le prix à payer, c'est la latence, la surconsommation de tokens, une pile d'auto-hébergement lourde et l'AGPL, donc prévois de les assumer tous les quatre.

L'auto-hébergement demande Postgres avec pgvector, un worker deriver et un LLM compatible tool calling (par défaut : gpt-5.4-mini, text-embedding-3-small). La CLI démarre l'API, le deriver, Postgres et Redis ; Docker Compose fonctionne aussi. Si les données de tes utilisateurs doivent rester en Europe, un hébergeur européen (Hetzner, OVH, Scaleway) convient : avec l'AGPL-3.0 en auto-hébergement, la mémoire persistée reste chez toi.

# .env: set these before starting
DERIVER_FLUSH_ENABLED=true   # small batches otherwise wait (#494)
AUTH_USE_AUTH=true           # off by default
AUTH_JWT_SECRET=your-secret  # generate with scripts/generate_jwt_secret.py

uv tool install honcho-cli
honcho start --setup

Avantages : là où Honcho mérite sa place

• Une modélisation de l'utilisateur que les développeurs décrivent comme « savoir qui tu es »
• Le meilleur résultat sur longs historiques de notre recomptage : +27,8 sur LongMemEval S
• Open source, auto-hébergeable, avec des plugins pour Claude Code, Codex, Cursor, Hermes et d'autres

Limites : ce que ça te coûte

• Latence. Des développeurs rapportent une trace dialectic minimal de 9,1 s (#1101) et 2,16 s ajoutées à chaque tour d'API Hermes (#1289). Le « ~200 ms » de la page d'accueil est une affirmation du fournisseur sur context().
• Coût des requêtes. Pour 10 000 utilisateurs qui ajoutent 20K tokens par mois, l'ingestion coûte $400, mais 30 requêtes de niveau Low chacun coûtent $3,000 (Minimal : $300). C'est le niveau de requête, pas l'ingestion, qui décide de ta facture Honcho.
• Entretien de l'auto-hébergement. Des utilisateurs GitHub signalent une mémoire absente tant que le deriver n'a pas vidé sa file (#494) et un modèle de repli codé en dur (#1180). Quitter le cloud implique de rejouer les messages, car les embeddings ne sont pas exportés (#721).
• AGPL-3.0. Un article comparatif affirme que l'auto-hébergement t'oblige à publier le code source de ton application. C'est exagéré : l'article 13 de l'AGPL s'applique quand tu modifies Honcho et que des utilisateurs y accèdent via un réseau. Mem0, Letta et cognee sont sous Apache-2.0 et LangMem sous MIT, donc Honcho est le seul sous copyleft parmi les couches de mémoire dédiées. Ceci n'est pas un avis juridique.

Lance le quickstart avec le crédit de $5 sur un vrai journal de conversation avant de t'engager.

Questions fréquentes

Honcho memory est-il gratuit ?

En partie. Le cloud offre $5 de crédit, plus $5 par mois avec une carte, et les startups ayant levé moins de $5M peuvent obtenir $1,000 de crédits. L'auto-hébergement n'entraîne aucun frais de licence sous AGPL-3.0, mais tu paies tes propres factures de LLM et d'embeddings.

Puis-je utiliser Honcho dans un SaaS propriétaire ?

Oui, si ton application appelle un serveur Honcho non modifié via son API. Si tu modifies Honcho et que tu le sers sur un réseau, l'article 13 de l'AGPL exige de proposer le code source de ce Honcho modifié. Ton application reste fermée. Ceci n'est pas un avis juridique ; demande conseil à un juriste si tu forkes.

Honcho vs Mem0 ou Hindsight : lequel choisir ?

Prends Mem0 (Apache-2.0) pour démarrer le plus vite, Hindsight (MIT) pour économiser des tokens, et Honcho pour la modélisation de l'utilisateur. Un développeur rapporte que Hindsight a « used far fewer tokens » sur Hermes (X, oct. 2026). Le blog de Mem0 affirme que Honcho n'a pas de benchmarks publics, alors qu'il a publié 21 fichiers de résultats bruts depuis le 2025-12-19. Voir le classement complet.

title: Références
items:
  - title: Honcho Evals
    publisher: Plastic Labs
    year: 2025
    url: https://honcho.dev/evals
  - title: plastic-labs/honcho README
    publisher: GitHub
    year: 2026
    url: https://github.com/plastic-labs/honcho
  - title: plastic-labs/honcho-benchmarks
    publisher: GitHub
    year: 2025
    url: https://github.com/plastic-labs/honcho-benchmarks
  - title: Benchmarking Honcho
    publisher: Plastic Labs
    year: 2025
    url: https://plasticlabs.ai/blog/research/Benchmarking-Honcho
  - title: Honcho Memory
    publisher: Nous Research (Hermes Agent docs)
    year: 2026
    url: https://hermes-agent.nousresearch.com/docs/user-guide/features/honcho
  - title: GNU Affero General Public License v3
    publisher: Free Software Foundation
    year: 2007
    url: https://www.gnu.org/licenses/agpl-3.0.html
  - title: "LongMemEval: Benchmarking Chat Assistants on Long-Term Interactive Memory"
    publisher: arXiv
    year: 2024
    url: https://arxiv.org/abs/2410.10813
  - title: Evaluating Very Long-Term Conversational Memory of LLM Agents (LoCoMo)
    publisher: arXiv
    year: 2024
    url: https://arxiv.org/abs/2402.17753
  - title: ConvoMem
    publisher: arXiv
    year: 2025
    url: https://arxiv.org/abs/2511.10523