Hermes Agent : veille technique auto-hébergée avec Matrix, FreshRSS et Firecrawl

Je suis tombé sur Hermes Agent début 2026, et il m’a fallu quelques semaines pour comprendre ce que le projet apportait par rapport aux autres frameworks d’agents.

Le pitch officiel - “self-improving AI agent with a built-in learning loop” - ne rend pas bien service à ce que le logiciel fait concrètement. Après plusieurs mois d’utilisation quotidienne, voici ce que j’en retire.

En bref

#

• Hermes Agent développé par Nous Research, installé sur un serveur bare metal dans mon homelab.
• Connecté à Matrix (Synapse sur matrix.cryptolab.re, client Element).
• FreshRSS pour l’agrégation de flux RSS.
• Firecrawl pour l’extraction et le nettoyage d’articles web.
• Ollama, Claude et Codex selon le type de tâche.
• opencode comme client de code local, appelé via une skill Hermes.
• Le tout forme une plateforme de veille technique qui tourne 24/7.

Présentation de Hermes Agent

#

Hermes Agent est un agent autonome open source développé par Nous Research - le lab derrière les modèles Hermes, Nomos et Psyche.

À ne pas confondre avec un chatbot ou un copilote de code. Hermes est un agent généraliste avec :

• Un système de mémoire persistante (SQLite + FTS5 pour la recherche plein texte, résumés LLM)
• La création autonome de skills (il apprend et réutilise des procédures)
• Un messaging gateway qui supporte plus de 20 plateformes de communication
• Un système de cron intégré pour les automatisations planifiées
• Le support du protocole MCP pour étendre ses outils
• Plus de 60 outils intégrés (terminal, fichiers, web, browser, code, etc.)

Ce qui distingue Hermes des autres frameworks, c’est sa boucle d’apprentissage : il crée des skills à partir de l’expérience, les améliore pendant l’utilisation, et construit un modèle de l’utilisateur au fil des sessions. L’intérêt apparaît surtout après plusieurs semaines d’usage régulier.

Pour une veille technique quotidienne, c’est une base intéressante : assez autonome pour filtrer le bruit, mais encore assez contrôlable pour garder la main sur les décisions importantes.

Architecture du projet

#

Le code est structuré en plusieurs couches :

hermes-agent/
├── run_agent.py              # Boucle principale de l'agent
├── cli.py                    # Interface CLI
├── gateway/                  # Plateformes de communication
│   └── platforms/            # adaptateurs de messagerie
├── tools/                    # outils intégrés
│   ├── registry.py           # Registre central des outils
│   ├── web_tools.py          # Recherche web et extraction
│   ├── terminal_tool.py      # Exécution de commandes
│   └── mcp_tool.py           # Client MCP
├── agent/
│   ├── prompt_builder.py     # Construction des prompts
│   ├── memory_manager.py     # Gestion de la mémoire
│   └── skill_commands.py     # Commandes de skills
├── skills/                   # Skills embarquées
├── optional-skills/          # Skills optionnelles officielles
├── cron/                     # Planificateur de tâches
└── hermes_state.py           # Base SQLite + FTS5

Comment Hermes connecte tous les composants

#

Voici comment les différentes briques s’articulent dans mon déploiement :

Agents

#

Le coeur d’Hermes est la classe AIAgent dans run_agent.py. C’est un orchestrateur synchrone qui gère la sélection du provider, la construction des prompts, l’exécution des outils, les retries, le fallback et la compression de contexte.

Il supporte trois modes API :

• Chat completions (OpenAI-compatible)
• Codex responses (pour les modèles Codex)
• Anthropic Messages (format Claude)

L’agent peut déléguer des tâches à des sous-agents isolés via delegate_tool, ce qui permet de paralléliser des workstreams.

Skills

#

Les skills sont des documents d’instruction au format SKILL.md. Chaque skill a un nom, une description et une procédure étape par étape.

Particularité intéressante : Hermes lit les descriptions courtes de toutes les skills installées sans les charger en mémoire. Il ne charge le contenu complet que quand une tâche correspond effectivement à une skill.

Les skills peuvent être :

• Bundled : livrées avec Hermes, toujours disponibles
• Installées depuis le Skills Hub : communauté, compatibles agentskills.io
• Créées par l’agent lui-même : il les génère et les améliore automatiquement

Chaque skill installée devient automatiquement une commande slash :

/deploy-k8s déploie le manifest staging
/veille résume les derniers articles cybersécurité

Providers

#

Hermes supporte une trentaine de providers d’inférence. Le système de runtime_provider.py résout un tuple (provider, model) en (api_mode, api_key, base_url) dynamiquement.

Dans mon setup, j’utilise un routage simple :

• Ollama (local) pour les tâches courantes : résumés, extraction, classification
• OpenRouter (cloud) pour les analyses complexes qui demandent un modèle plus capable

Le basculement se fait à la volée avec /model en cours de conversation.

Outils externes

#

Hermes supporte MCP, mais ce n’est pas le mécanisme utilisé partout dans mon setup.

Dans ma configuration locale :

• FreshRSS est une skill Hermes qui appelle l’API Google Reader compatible FreshRSS.
• Firecrawl est configuré comme backend web/search/extract côté Hermes.
• opencode utilise son propre MCP Firecrawl local, séparé de la configuration Hermes.

Cette séparation évite de mélanger lecture des flux RSS, extraction de pages web et assistance de code dans un terminal.

Installation

#

Linux

#

Je n’ai pas installé Hermes à la main ni créé de services systemd dédiés. J’ai suivi l’intégration officielle Ollama :

ollama launch hermes

Ollama prend en charge le flux d’onboarding :

• installation de Hermes si nécessaire via le script Nous Research ;
• choix du modèle local ou cloud ;
• configuration du provider Ollama ;
• connexion à l’endpoint OpenAI-compatible http://127.0.0.1:11434/v1 ;
• lancement de Hermes.

Si je dois relancer la configuration complète, je repasse par :

hermes setup

Configuration complète de mon setup

#

La partie importante n’est pas seulement d’installer Hermes. C’est de décider où passe chaque type de tâche.

Dans mon cas :

• Hermes orchestre la veille, les crons, la mémoire et Matrix.
• FreshRSS reste la source d’articles et de flux.
• Firecrawl transforme les pages web en Markdown exploitable.
• opencode sert aux tâches simples et rapides dans un terminal.
• Codex sert aux tâches de code plus lourdes : revue, refactoring, modifications multi-fichiers.
• Claude est utilisé pour les analyses longues ou les travaux de code qui demandent beaucoup de contexte.

Je préfère cette séparation à un agent unique qui aurait tous les droits partout. C’est moins ambitieux sur le papier, mais plus facile à exploiter au quotidien.

Variables d’environnement Hermes

#

Je garde les secrets dans ~/.hermes/.env, chargé par Hermes au lancement.

HERMES_HOME=/root/.hermes

# Matrix
MATRIX_HOMESERVER=https://matrix.cryptolab.re
MATRIX_ACCESS_TOKEN=syt_xxx
MATRIX_ALLOWED_USERS=@moi:matrix.cryptolab.re
MATRIX_ALLOWED_ROOMS=!veille:matrix.cryptolab.re
MATRIX_HOME_ROOM=!veille:matrix.cryptolab.re
MATRIX_REQUIRE_MENTION=true
MATRIX_AUTO_THREAD=true
MATRIX_SESSION_SCOPE=room

# FreshRSS
FRESHRSS_URL=https://rss.cryptolab.re
FRESHRSS_USER=veille
FRESHRSS_API_PASSWORD=xxx

# Firecrawl
FIRECRAWL_API_URL=http://localhost:3002

# Providers LLM
ANTHROPIC_API_KEY=sk-ant-xxx
OPENAI_API_KEY=sk-xxx
OPENROUTER_API_KEY=sk-or-xxx
OLLAMA_BASE_URL=http://127.0.0.1:11434/v1

Deux détails comptent :

• FreshRSS utilise un mot de passe API dédié, pas le mot de passe principal du compte.
• Firecrawl pointe vers l’instance self-hosted locale via FIRECRAWL_API_URL.
• Codex n’est pas configuré ici via une clé API : la skill appelle la CLI codex, déjà authentifiée et configurée sur la machine.

Vérification FreshRSS

#

Avant de brancher Hermes dessus, je vérifie que l’API FreshRSS répond correctement. FreshRSS expose une API compatible Google Reader sous /api/greader.php.

curl -s -X POST \
  -d "Email=${FRESHRSS_USER}" \
  -d "Passwd=${FRESHRSS_API_PASSWORD}" \
  "${FRESHRSS_URL}/api/greader.php/accounts/ClientLogin"

La réponse doit contenir un champ Auth=.... Je l’utilise ensuite pour une requête de lecture seule :

FRESHRSS_AUTH="veille/token-retourne-par-freshrss"

curl -s \
  -H "Authorization:GoogleLogin auth=${FRESHRSS_AUTH}" \
  "${FRESHRSS_URL}/api/greader.php/reader/api/0/unread-count?output=json" | jq .

Si cette commande échoue, inutile de déboguer Hermes. Le problème est côté FreshRSS, reverse proxy ou mot de passe API.

Skill FreshRSS dans Hermes

#

Hermes ne lit pas FreshRSS avec du code improvisé dans un prompt. La configuration locale utilise la skill freshrss, qui appelle un script Python basé sur l’API Google Reader compatible FreshRSS.

La skill FreshRSS sert à :

• récupérer les articles non lus ;
• filtrer par catégorie ;
• récupérer les métadonnées utiles : titre, URL, flux, date, état lu/non lu ;
• récupérer le contenu stocké côté FreshRSS ;
• marquer un article comme lu ou non lu après validation.

Firecrawl dans Hermes

#

Firecrawl intervient après FreshRSS. Il ne surveille pas les flux : il reçoit une URL d’article et renvoie un contenu propre, généralement en Markdown.

web:
  backend: firecrawl
  search_backend: firecrawl
  extract_backend: firecrawl

Dans opencode, Firecrawl est configuré séparément comme MCP local. Ce n’est pas la même intégration que le backend web Hermes.

Skills Hermes pour Codex, opencode et Claude

#

Codex et opencode ne sont pas branchés chez moi comme des MCP Hermes. Je les expose à Hermes sous forme de skills : des procédures nommées qui expliquent quand et comment appeler les CLI.

Je ne détaille pas ici l’installation des skills, parce que le format et les emplacements peuvent évoluer. La documentation Hermes sur les skills reste la référence pour la partie déclarative.

La différence est importante :

• FreshRSS est une skill Hermes, parce qu’il expose les flux, articles et états de lecture.
• Firecrawl est un backend web Hermes, et un MCP séparé côté opencode.
• opencode est une skill, parce que je veux lancer rapidement un agent de code local pour des tâches simples.
• Codex est une skill, parce que je veux l’appeler pour les grosses tâches de code : revue, refactoring, changements multi-fichiers.
• Claude reste un provider pour les analyses longues et les tâches de code qui demandent beaucoup de contexte, pas un outil MCP nécessaire à ce workflow.

Exemple de skill Codex :

---
name: codex-review
description: Utilise Codex CLI pour relire un dépôt, un diff ou un fichier technique.
---

1. Vérifier que la demande concerne du code, un dépôt Git, un diff ou un fichier technique.
2. Ne jamais lancer Codex sur un chemin non précisé.
3. Utiliser `codex exec` en mode non interactif.
4. Préférer une sandbox limitée au workspace.
5. Demander une sortie courte : problèmes bloquants, corrections recommandées, commandes de validation.
6. Ne pas appliquer automatiquement les modifications si la demande est une simple revue.

Commande typique appelée par la skill :

codex exec --sandbox workspace-write \
  "Relis le diff courant.
  Liste les problèmes techniques, les incohérences et les validations utiles.
  Ne modifie aucun fichier."

Exemple de skill opencode :

---
name: opencode-simple
description: Utilise opencode en mode non interactif pour des tâches locales simples et rapides.
---

1. Vérifier que le dépôt cible est explicite.
2. Vérifier que le modèle demandé est disponible dans opencode.
3. Utiliser `opencode run` pour les tâches courtes : reformulation, petite correction, inspection ciblée.
4. Escalader vers Codex ou Claude si la demande touche plusieurs fichiers, nécessite une revue profonde ou demande beaucoup de contexte.
5. Ne pas exposer de secrets dans le prompt.
6. Retourner le résumé de ce qui a été fait et les limites éventuelles.

Commande typique :

opencode run \
  "Relis ce paragraphe et propose une version plus courte.
  Ne modifie pas les fichiers."

Cette approche me convient mieux qu’une intégration MCP :

• le périmètre est clair ;
• les commandes sont auditables ;
• Hermes garde le rôle d’orchestrateur ;
• opencode, Codex et Claude restent des outils spécialisés, appelés selon la taille et le risque de la tâche.

Pour Claude, je garde deux usages distincts :

• Claude via ANTHROPIC_API_KEY comme provider Hermes pour les analyses longues ;
• Claude pour les grosses tâches de code quand il faut plus de contexte qu’une passe opencode rapide.

export ANTHROPIC_API_KEY=sk-ant-xxx
hermes chat --provider anthropic --model claude-sonnet-4-6

Skill Hermes pour la veille

#

La configuration brute ne suffit pas. J’ai ajouté une skill Hermes dédiée à la veille :

---
name: veille-technique
description: Analyse les nouveaux articles via la skill FreshRSS, extrait le contenu via Firecrawl et signale les sujets à lire en priorité.
---

1. Récupérer les articles non lus via la skill FreshRSS dans la catégorie veille.
2. Ignorer les contenus marketing, sponsorisés ou redondants.
3. Pour chaque article retenu, utiliser Firecrawl pour récupérer le contenu complet.
4. Extraire les versions, CVE, commits, advisories et commandes utiles.
5. Évaluer l'intérêt opérationnel du sujet.
6. Proposer un résumé court dans Matrix avec une recommandation : ignorer, lire, surveiller.

Le résultat n’est pas parfait, mais il est prévisible. Les mauvaises recommandations viennent surtout d’un prompt trop vague ou d’un flux RSS mal catégorisé, rarement de Firecrawl lui-même.

Connexion à Matrix

#

Matrix est le canal principal de communication avec l’agent. J’utilise Synapse comme homeserver sur matrix.cryptolab.re, et Element comme client.

Compte bot

#

J’ai créé un compte bot sur mon homeserver Synapse :

register_new_matrix_user -c /etc/synapse/homeserver.yaml \
  http://localhost:8008

J’ai choisi le nom @hermes:matrix.cryptolab.re.

Gateway Matrix

#

La configuration du gateway Matrix se fait dans ~/.hermes/.env :

MATRIX_HOMESERVER=https://matrix.cryptolab.re
MATRIX_ACCESS_TOKEN=syt_...
MATRIX_ALLOWED_USERS=@moi:matrix.cryptolab.re
MATRIX_ALLOWED_ROOMS=!veille:matrix.cryptolab.re
MATRIX_REQUIRE_MENTION=true
MATRIX_AUTO_THREAD=true
MATRIX_SESSION_SCOPE=room

J’ai restreint l’accès à mon utilisateur et à une seule salle de veille. Le bot ignore les messages qui ne le mentionnent pas dans les salons, sauf dans les DMs.

Home Room

#

La Home Room est la salle où Hermes envoie les messages proactifs : résultats de cron, notifications, alertes.

Configuration :

# Dans ~/.hermes/.env
MATRIX_HOME_ROOM=!veille:matrix.cryptolab.re

Ou directement via commande slash dans la salle :

!sethome

Dépannage Matrix

#

Quelques problèmes rencontrés :

Clock skew : Le bot se connectait mais ignorait tous les messages entrants. Cause : l’horloge système du serveur était décalée. La solution :

sudo timedatectl set-ntp true
timedatectl status

Access token expiré : Les tokens Matrix peuvent expirer. J’ai automatisé la génération via l’API :

curl -X POST https://matrix.cryptolab.re/_matrix/client/v3/login \
  -H "Content-Type: application/json" \
  -d '{"type": "m.login.password", "user": "@hermes:matrix.cryptolab.re", "password": "***"}'

Mautrix non installé : Hermes a besoin de mautrix pour Matrix.

pip install 'hermes-agent[matrix]'

Intégration de FreshRSS

#

FreshRSS est mon agrégateur de flux RSS. Il tourne depuis des années dans le homelab et collecte environ 80 flux : cybersécurité, DevOps, cloud, self-hosting, Linux.

Récupération des flux RSS

#

Hermes interroge FreshRSS via la skill FreshRSS pour récupérer les nouveaux articles. J’ai créé une tâche cron Hermes :

hermes cron add --name "veille-quotidienne" \
  --schedule "0 8 * * *" \
  --prompt "Vérifie FreshRSS pour les nouveaux articles de la catégorie 'veille' et résume-les en 3 lignes max chacun. Envoie le résumé dans ma Home Room Matrix."

Surveillance de nouvelles publications

#

Le cron est paramétré pour s’exécuter plusieurs fois par jour :

# Vérification matinale approfondie
0 8 * * *

# Vérification rapide en début d'après-midi
0 14 * * *

# Vérification en soirée
0 19 * * *

Sélection automatique des articles intéressants

#

Le prompt du cron inclut des critères de filtrage :

Parmi les articles de la catégorie 'veille', sélectionne ceux qui :
1. Concernent une CVE avec un score CVSS > 7.0
2. Annoncent une nouvelle version majeure d'un outil que j'utilise
3. Décrivent une technique d'attaque ou de défense nouvelle
4. Présentent un projet open source prometteur

Ignore les articles purement marketing ou redondants.

Avantages par rapport à une veille manuelle

#

Avant Hermes, je parcourais FreshRSS manuellement : 80 flux, 150 à 300 articles par jour. Je passais 30 à 45 minutes à trier, lire, évaluer.

Maintenant, Hermes filtre et résume automatiquement. En 5 minutes, j’ai une synthèse des articles importants dans Matrix, avec des recommandations de lecture.

Le gain de temps est réel, mais l’avantage principal est ailleurs : Hermes parcourt systématiquement les flux configurés. Humainement, on finit toujours par zapper certains flux par lassitude. L’agent réduit surtout ces oublis.

Intégration de Firecrawl

#

Firecrawl est l’outil d’extraction web que j’utilise pour récupérer le contenu complet des articles identifiés via la skill FreshRSS.

Extraction du contenu complet des articles

#

FreshRSS fournit souvent des extraits tronqués. Pour les articles intéressants, Hermes récupère l’URL via la skill FreshRSS, puis utilise Firecrawl pour récupérer le contenu intégral.

La configuration Firecrawl reste séparée de la skill FreshRSS :

# ~/.hermes/config.yaml
mcp_servers:
  firecrawl:
    command: "npx"
    args: ["-y", "firecrawl-mcp"]
    env:
      FIRECRAWL_API_KEY: "${FIRECRAWL_API_KEY}"
    tools:
      include:
        - firecrawl_scrape
        - firecrawl_search
        - firecrawl_map

Nettoyage du HTML

#

Firecrawl nettoie automatiquement le HTML : il retire le bruit (navigation, publicités, cookies), ne garde que le contenu principal et le convertit en Markdown.

Le résultat est un texte propre que le LLM peut analyser sans bruit superflu.

Récupération du Markdown

#

Le format Markdown aide pour deux raisons :

1. Compressible : moins de tokens que le HTML brut
2. Analysable : la structure (titres, listes, code) aide le LLM à comprendre l’article

Enrichissement des données de veille

#

Avec le contenu complet, Hermes peut :

• Extraire les informations clés (CVE, versions, configurations)
• Classifier le sujet (sécurité, DevOps, cloud)
• Évaluer l’intérêt opérationnel du sujet
• Signaler les lectures à prioriser

Le workflow typique : FreshRSS détecte un article, Hermes le récupère via la skill FreshRSS, Firecrawl extrait l’URL retenue, le LLM l’analyse, puis Hermes renvoie le résultat dans Matrix.

Mon workflow de veille quotidien

#

Voici concrètement comment ça se passe chaque jour.

1. FreshRSS détecte un nouvel article

Le flux RSS d’un blog sécurité publie un nouvel article sur une CVE. FreshRSS le récupère et le catégorise automatiquement.

2. Hermes Agent récupère l’article

Le cron Hermes de veille s’exécute. Il utilise la skill FreshRSS pour récupérer les nouveaux articles non lus.

3. Firecrawl extrait le contenu

Pour chaque article récent, Hermes utilise Firecrawl comme backend d’extraction. Firecrawl retourne le contenu en Markdown propre.

4. LLM analyse le sujet

Le modèle, Ollama ou cloud selon la complexité, analyse l’article avec ce prompt implicite :

1. Quel est le sujet principal ?
2. Quel est l'impact opérationnel ?
3. Y a-t-il des commandes de vérification utiles ?
4. Quelle est la sévérité réelle (pas le CVSS brut) ?
5. Le sujet mérite-t-il une lecture prioritaire ?

5. Un résumé est envoyé dans Matrix

Hermes poste un message structuré dans la salle Matrix :

Veille du 19/06/2026 - 08:00

Nginx RIFT (CVE-2026-42945)
Source : blog.nginx.org
Flux : Sécurité
Sévérité : 7.5 CVSS - Buffer overflow dans le module rewrite
Impact réel : Nécessite une configuration spécifique, pas critique par défaut
Action : lecture prioritaire

Debian 14 "Forky" annoncé
Source : lists.debian.org
Flux : Linux
Résumé : Planning de sortie, nouvelles features, dépréciations.
Action : informationnel, pas d'urgence

6. Les articles les plus intéressants sont signalés

Les articles à lire en priorité sont marqués dans Matrix avec une justification courte. Hermes ne rédige pas les articles à ma place : il sert ici à trier, résumer et éviter de passer à côté d’une source importante.

Avantages

#

Gain de temps : Je passe de 45 minutes de veille manuelle à 5-10 minutes de revue de résumés.

Couverture plus régulière : L’agent traite les flux configurés de manière systématique. Ça ne garantit pas une veille parfaite, mais ça réduit les oublis liés à la revue manuelle.

Centralisation : Matrix est le point d’entrée unique. Je consulte la veille depuis n’importe quel client Element (mobile, desktop, web).

Séparation des modèles : Les tâches simples (résumé, classification) tournent sur Ollama local. Les analyses complexes passent par le cloud. Le coût reste maîtrisé.

Séparation des intégrations : FreshRSS et Firecrawl restent deux briques séparées. L’une fournit les articles et leurs métadonnées, l’autre extrait le contenu complet des URLs retenues.

Skills auto-générées : Hermes a créé des skills pour certaines tâches récurrentes de veille sans que je les écrive.

Limites

#

Consommation de tokens : Les résumés quotidiens + analyses consomment ~200K tokens par jour. Même en local, ça a un coût en temps de calcul.

Qualité des prompts : Hermes est très sensible à la formulation des prompts cron. Un prompt vague produit des résumés inutiles. J’ai dû itérer plusieurs fois pour trouver les bons filtres.

Bruit : Certains articles sont mal classifiés par FreshRSS et passent les filtres. Hermes ne rattrape pas une mauvaise catégorisation initiale.

Mémoire perfectible : Le système de mémoire est utile, mais il ne remplace pas un bon cadrage de la tâche. Hermes peut perdre le fil d’une analyse longue si le contexte dépasse la fenêtre du modèle.

Dépendance réseau : Si le serveur homelab est down ou Synapse inaccessible, tout le workflow s’arrête. Matrix est un SPOF dans cette architecture.

Maintenance : Hermes évolue vite. Les mises à jour cassent parfois des configurations. Le projet est encore jeune et certains cas limites ne sont pas documentés.

Faut-il utiliser Hermes Agent en 2026 ?

#

La réponse est nuancée.

Oui, si :

• Tu veux une plateforme agent auto-hébergée complète
• Tu es prêt à investir du temps dans la configuration initiale
• Tu as un besoin réel d’automatisation de tâches (veille, triage, monitoring)
• Matrix est déjà dans ta stack

Non, si :

• Tu cherches une solution “prête à l’emploi” sans configuration
• Tu veux uniquement un chatbot Matrix basique
• Tu n’es pas à l’aise avec l’administration d’un outil agent qui lance des commandes et manipule des credentials

Hermes Agent est un outil solide, mais il demande de la patience. La documentation officielle est bonne, mais certains aspects, notamment le système de cron, nécessitent de tâtonner.

Pour mon usage de veille technique, le ratio temps passé / valeur obtenue est bon. Je ne le recommanderais pas à quelqu’un qui veut simplement ajouter un chatbot Matrix en 5 minutes.

Ce qui fait la différence, c’est que Hermes n’est pas seulement un connecteur LLM + messagerie. C’est une plateforme qui apprend avec l’usage. Les skills créées après plusieurs semaines d’utilisation apportent plus de valeur que la configuration initiale.

Sources

#

• Hermes Agent - Documentation officielle
• Ollama - Hermes Agent integration
• Hermes Agent - GitHub
• Hermes Agent - Matrix setup
• Hermes Agent - Architecture
• Hermes Agent - Skills
• Hermes Agent - MCP Integration
• Hermes Agent - AI Providers
• Firecrawl - Documentation MCP
• FreshRSS - Accès mobile et API
• FreshRSS - API compatible Google Reader
• Codex - Documentation officielle
• opencode - Configuration
• opencode - CLI
• Claude API - Overview
• Nous Research