All plugins

hermes-dreaming

Nightly deterministic memory consolidation ("dreaming"): corroborates candidate facts with what humans actually said on distinct days, proposes the few worth keeping with a verbatim edit anchor, asks whether stale memory entries still hold, and wakes the agent only when there is work — including a memory file close to its char limit. Fact sources: the holographic store, a SQLite or JSONL export, or none. Secrets and instructions are screened by the dream's own rules plus a verbatim copy of the holographic plugin's screen (scripts/holo_screen.py, MIT, same maintainer), applied to stored facts and human messages before anything reaches memory, the report or the model. Portable Agent Plugins v1 package (plugin.json + skills/); no tools, hooks, middleware or env vars. Disclosure — by default the scripts make no network or LLM calls and open state.db and every fact store read-only (SQLite mode=ro; with holographic >= 0.15.0 including its fact_versions/fact_confirmations tables, to say who stands behind a fact); they also read Hermes config.yaml's memory/timezone keys and the holographic plugin's db_path/scope/cron_writes/min_trust_threshold (the floor recall applies, so a rejected fact is only reported when the store still trusts it) and, to say so in install.py --check, embeddings/mirror_memory_writes, the pending/memory approval queue, cron/jobs.json (to find their own jobs) and — only when chat_stores is set, with holographic scope user/chat/thread — the per-chat databases next to the store (counts of every one; facts of the chats listed in promote_from). An optional cloud judge (judge in dreaming.json, off by default; off, its code is not even loaded) may, once the owner enables it, send for each mention the rules counted the fact's text and that person's own words (no reply quote, link, id, sender or time; names inside the text may be included; screened for secrets and instructions first), only from the chats, sources and chat stores the owner lists, over HTTPS to the providers the owner lists, in the owner's order: OpenRouter's Decisions API (model typesafe/jev-1.14, Jev by TypeSafe; the data reaches OpenRouter and TypeSafe) and/or OpenAI's Decisions API (model gpt-6-luna); when the first gives no usable answer the same pair may reach the next. A verdict can only remove a counted mention — from promotion, confirmation, fact decay, "said again" after a rejection, the selection of new facts and conflicts, and evidence. Keys OPENROUTER_API_KEY / OPENAI_API_KEY are read from the environment or, since Hermes withholds these provider keys from cron scripts, straight from their own line in $HERMES_HOME/.env; the judge's calls are billed to those keys. It keeps a 90-day verdict cache and a 90-day local journal of the pairs sent in $HERMES_HOME/cache (the journal is deleted on nights the judge is off); the nightly spending cap ($0.05 by default) is soft; data already sent cannot be recalled and falls under the providers' retention terms. The user-run installer copies three gate scripts into $HERMES_HOME/scripts, seeds $HERMES_HOME/dreaming.json and, through Hermes' cron Python API, creates (or with --rebind re-points) two agent cron jobs bound to this plugin's own skill with only the memory toolset, plus one no_agent job (every 15 min, no model) that reads the fact stores to keep a hash index of diary lines and, for facts holographic >= 0.8.0 has forgotten, rewrites the dream's own cache files, judge files and diary without them, deletes the output files of the dream's own cron jobs that mention them (by id or verbatim text) and deletes the set-aside copies of its own broken state files; with a chat --deliver target the reports are attached as a session you can reply to. The agent runs send recent human messages (up to 200 / 40k chars, each with its chat type and sender id) and fact snippets to your configured model; state goes to $HERMES_HOME/cache and a diary to $HERMES_HOME/memories/DREAMS.md (configurable); memory files are changed by the agent only through the regular memory tool, and with the holographic provider it also adds candidate facts via fact_store (with holographic >= 0.15.0 marked said or inferred; with holographic >= 0.8.0 also change / end / correct / forget, the last three only on a human's own answer; forget is irreversible), lowers trust on human-rejected facts via fact_feedback, with holographic >= 0.15.0 raises trust (fact_feedback confirmed, +0.05, at most 10 facts a night) on facts people repeated on two or more different days and, when keywords.enabled is set (off by default), adds search keywords to facts via fact_store update. Since 3.4.0, with holographic >=0.19.0 and profile scope, it also reads fact_merges and current version ids to propose disjoint duplicate pairs. It saves immutable proposal numbers, both full texts, version ids, origins, keywords and the provider database path in cache/dream-proposals.json; open proposals expire after 180 days and closed ones are removed after 30 days. Full pair texts are included in the agent report and therefore reach the configured agent model. Old facts are merged by fact_store only after the adult memory owner approves the exact proposal; the response checks the database and uses expect to refuse changed versions. Scheduled extraction may merge only a newly added paraphrase from its own session into an existing fact, never old facts from other sessions. The scripts themselves still open the fact store read-only. The sweep also cleans the state of merged copies and archives their hashes so a later forget can remove older untagged diary copies; merging itself does not erase the diary. No new credentials, network providers or tools are introduced. Version 3.4.2 clarifies that forget cleans the store and the skill's own files; Git history, external database dumps, system backups and Hermes session history require separate cleanup. Reports distinguish a successful store deletion from a retained external copy and do not promise that retrying removes a documented history boundary. Version 3.5.0 adds explicit cron maintenance: known stock prompts are synchronized while custom prompts are preserved; --update-existing applies only explicitly supplied settings and --job-id scopes the entire operation. cron.expected_roles controls desired creation without pausing existing jobs. --upgrade validates the request before copying gate scripts and updating cron through public APIs, then checks the result. Checks expose paused jobs, execution modes, missing roles and duplicates; no automatic activation or job deletion. --inherit-model explicitly clears both model and provider pins. The public cron update API has no CAS; avoid concurrent configuration edits during installation. Version 3.6.0 adds opt-in read-only task-outcome summaries and recorded memory-attempt explanations from holographic >=0.20.0 (experience_schema=1). It reads bounded attempt/version references and agent-reported outcomes; usefulness does not change truth, trust, ranking or MEMORY.md. It makes no new model or network calls and keeps no second correction-text cache. Explicit --memory-store must be in chat_stores.promote_from; stores are never joined. task_outcomes: true adds only summary counts to the ordinary nightly result and creates no extra wakeup. Missing capability is reported as unsupported, not as a successful empty journal. Human corrections reported by the agent are not authenticated human confirmation. Version 3.6.1 reuses parsed numbers within a bounded in-memory nightly cache, reducing repeated work without changing contradiction rules. Version 3.6.2 copies the cron gate scripts atomically (an interrupted install keeps the previous gate) and names any cron job the installer refuses to change with the fix. Version 3.7.0 keeps the whole-store duplicate search within its nightly budget on large stores (it also narrows candidates by the numbers and names the pair rule requires; the rule still decides every pair) and names the store in task-outcome summaries. Version 3.7.1 derives each message's data once per nightly pass, with memory bounded by corroboration.memory_mb (default 256 MB; above it data is rebuilt on demand, never changing decisions). Version 3.7.2 makes the quarantine screen about 40× faster on long messages with byte-identical decisions (re-vendored holographic screen 0.22.1). Version 3.7.3 fixes an install-time scanner false positive in that screen's start list (3.7.2 was refused by hermes plugins install) and runs hermes plugins validate in CI. Version 3.7.4 changes no behaviour: the vendored holographic screen is copied whole and checked before it is written. Version 3.8.0 no longer promotes an agent's conclusion nobody confirmed (holographic origin inferred) to MEMORY.md by any corroboration route; people repeating it offer it for confirmation instead, and stores without origins are promoted as before; --explain says why, and --memory-explain keeps the provider's count of candidates that changed before the record. Version 3.8.4 keeps, for each memory entry, hashed word stems and numbers plus a 60-character preview (none for an entry with a secret) in the loss-guard snapshot in $HERMES_HOME/cache, so an entry the agent compressed, reworded or merged is no longer reported as lost; the alert names lost entries by that preview. Version 3.8.5 has the nightly agent change memory entries with the memory tool's patch (Hermes 0.22 removed replace; replace remains only as the fallback for Hermes 0.21), counts a patch staged in the pending/memory approval queue as waiting, and compares a lost entry only with entries the night wrote (also across a split, with numbers compared as numbers); for an entry of fewer than two word stems the snapshot also keeps hashed stems of its short words or, for one with no words and no secret, hashed character trigrams; state files with a UTF-8 BOM are read. Version 3.8.6: install.py --check counts a judge key only from its own line in $HERMES_HOME/.env, the one a cron script can read, and names DREAM_* variables set only in the terminal it runs in, compared with their lines in that .env (a DREAM_* value may be printed, a key never is); it and a new read-only dream.py --nightly-status read the dreaming jobs' next_run_at in cron/jobs.json to say when Hermes will not fire them (a gateway that is down, a job paused or with no next run). The nightly prompt never patches through another entry's whole text and keeps an absorbed entry when a merge fails; the loss-guard snapshot also keeps hashed full dates and each entry's hashed head key. No new credentials, network calls, tools or writes.

itpartypattaya27Memoryv3.8.6Updated 9 days ago

About

Nightly deterministic memory consolidation ("dreaming"): corroborates candidate facts with what humans actually said on distinct days, proposes the few worth keeping with a verbatim edit anchor, asks whether stale memory entries still hold, and wakes the agent only when there is work — including a memory file close to its char limit. Fact sources: the holographic store, a SQLite or JSONL export, or none. Secrets and instructions are screened by the dream's own rules plus a verbatim copy of the holographic plugin's screen (scripts/holo_screen.py, MIT, same maintainer), applied to stored facts and human messages before anything reaches memory, the report or the model. Portable Agent Plugins v1 package (plugin.json + skills/); no tools, hooks, middleware or env vars. Disclosure — by default the scripts make no network or LLM calls and open state.db and every fact store read-only (SQLite mode=ro; with holographic >= 0.15.0 including its fact_versions/fact_confirmations tables, to say who stands behind a fact); they also read Hermes config.yaml's memory/timezone keys and the holographic plugin's db_path/scope/cron_writes/min_trust_threshold (the floor recall applies, so a rejected fact is only reported when the store still trusts it) and, to say so in install.py --check, embeddings/mirror_memory_writes, the pending/memory approval queue, cron/jobs.json (to find their own jobs) and — only when chat_stores is set, with holographic scope user/chat/thread — the per-chat databases next to the store (counts of every one; facts of the chats listed in promote_from). An optional cloud judge (judge in dreaming.json, off by default; off, its code is not even loaded) may, once the owner enables it, send for each mention the rules counted the fact's text and that person's own words (no reply quote, link, id, sender or time; names inside the text may be included; screened for secrets and instructions first), only from the chats, sources and chat stores the owner lists, over HTTPS to the providers the owner lists, in the owner's order: OpenRouter's Decisions API (model typesafe/jev-1.14, Jev by TypeSafe; the data reaches OpenRouter and TypeSafe) and/or OpenAI's Decisions API (model gpt-6-luna); when the first gives no usable answer the same pair may reach the next. A verdict can only remove a counted mention — from promotion, confirmation, fact decay, "said again" after a rejection, the selection of new facts and conflicts, and evidence. Keys OPENROUTER_API_KEY / OPENAI_API_KEY are read from the environment or, since Hermes withholds these provider keys from cron scripts, straight from their own line in $HERMES_HOME/.env; the judge's calls are billed to those keys. It keeps a 90-day verdict cache and a 90-day local journal of the pairs sent in $HERMES_HOME/cache (the journal is deleted on nights the judge is off); the nightly spending cap ($0.05 by default) is soft; data already sent cannot be recalled and falls under the providers' retention terms. The user-run installer copies three gate scripts into $HERMES_HOME/scripts, seeds $HERMES_HOME/dreaming.json and, through Hermes' cron Python API, creates (or with --rebind re-points) two agent cron jobs bound to this plugin's own skill with only the memory toolset, plus one no_agent job (every 15 min, no model) that reads the fact stores to keep a hash index of diary lines and, for facts holographic >= 0.8.0 has forgotten, rewrites the dream's own cache files, judge files and diary without them, deletes the output files of the dream's own cron jobs that mention them (by id or verbatim text) and deletes the set-aside copies of its own broken state files; with a chat --deliver target the reports are attached as a session you can reply to. The agent runs send recent human messages (up to 200 / 40k chars, each with its chat type and sender id) and fact snippets to your configured model; state goes to $HERMES_HOME/cache and a diary to $HERMES_HOME/memories/DREAMS.md (configurable); memory files are changed by the agent only through the regular memory tool, and with the holographic provider it also adds candidate facts via fact_store (with holographic >= 0.15.0 marked said or inferred; with holographic >= 0.8.0 also change / end / correct / forget, the last three only on a human's own answer; forget is irreversible), lowers trust on human-rejected facts via fact_feedback, with holographic >= 0.15.0 raises trust (fact_feedback confirmed, +0.05, at most 10 facts a night) on facts people repeated on two or more different days and, when keywords.enabled is set (off by default), adds search keywords to facts via fact_store update. Since 3.4.0, with holographic >=0.19.0 and profile scope, it also reads fact_merges and current version ids to propose disjoint duplicate pairs. It saves immutable proposal numbers, both full texts, version ids, origins, keywords and the provider database path in cache/dream-proposals.json; open proposals expire after 180 days and closed ones are removed after 30 days. Full pair texts are included in the agent report and therefore reach the configured agent model. Old facts are merged by fact_store only after the adult memory owner approves the exact proposal; the response checks the database and uses expect to refuse changed versions. Scheduled extraction may merge only a newly added paraphrase from its own session into an existing fact, never old facts from other sessions. The scripts themselves still open the fact store read-only. The sweep also cleans the state of merged copies and archives their hashes so a later forget can remove older untagged diary copies; merging itself does not erase the diary. No new credentials, network providers or tools are introduced. Version 3.4.2 clarifies that forget cleans the store and the skill's own files; Git history, external database dumps, system backups and Hermes session history require separate cleanup. Reports distinguish a successful store deletion from a retained external copy and do not promise that retrying removes a documented history boundary. Version 3.5.0 adds explicit cron maintenance: known stock prompts are synchronized while custom prompts are preserved; --update-existing applies only explicitly supplied settings and --job-id scopes the entire operation. cron.expected_roles controls desired creation without pausing existing jobs. --upgrade validates the request before copying gate scripts and updating cron through public APIs, then checks the result. Checks expose paused jobs, execution modes, missing roles and duplicates; no automatic activation or job deletion. --inherit-model explicitly clears both model and provider pins. The public cron update API has no CAS; avoid concurrent configuration edits during installation. Version 3.6.0 adds opt-in read-only task-outcome summaries and recorded memory-attempt explanations from holographic >=0.20.0 (experience_schema=1). It reads bounded attempt/version references and agent-reported outcomes; usefulness does not change truth, trust, ranking or MEMORY.md. It makes no new model or network calls and keeps no second correction-text cache. Explicit --memory-store must be in chat_stores.promote_from; stores are never joined. task_outcomes: true adds only summary counts to the ordinary nightly result and creates no extra wakeup. Missing capability is reported as unsupported, not as a successful empty journal. Human corrections reported by the agent are not authenticated human confirmation. Version 3.6.1 reuses parsed numbers within a bounded in-memory nightly cache, reducing repeated work without changing contradiction rules. Version 3.6.2 copies the cron gate scripts atomically (an interrupted install keeps the previous gate) and names any cron job the installer refuses to change with the fix. Version 3.7.0 keeps the whole-store duplicate search within its nightly budget on large stores (it also narrows candidates by the numbers and names the pair rule requires; the rule still decides every pair) and names the store in task-outcome summaries. Version 3.7.1 derives each message's data once per nightly pass, with memory bounded by corroboration.memory_mb (default 256 MB; above it data is rebuilt on demand, never changing decisions). Version 3.7.2 makes the quarantine screen about 40× faster on long messages with byte-identical decisions (re-vendored holographic screen 0.22.1). Version 3.7.3 fixes an install-time scanner false positive in that screen's start list (3.7.2 was refused by hermes plugins install) and runs hermes plugins validate in CI. Version 3.7.4 changes no behaviour: the vendored holographic screen is copied whole and checked before it is written. Version 3.8.0 no longer promotes an agent's conclusion nobody confirmed (holographic origin inferred) to MEMORY.md by any corroboration route; people repeating it offer it for confirmation instead, and stores without origins are promoted as before; --explain says why, and --memory-explain keeps the provider's count of candidates that changed before the record. Version 3.8.4 keeps, for each memory entry, hashed word stems and numbers plus a 60-character preview (none for an entry with a secret) in the loss-guard snapshot in $HERMES_HOME/cache, so an entry the agent compressed, reworded or merged is no longer reported as lost; the alert names lost entries by that preview. Version 3.8.5 has the nightly agent change memory entries with the memory tool's patch (Hermes 0.22 removed replace; replace remains only as the fallback for Hermes 0.21), counts a patch staged in the pending/memory approval queue as waiting, and compares a lost entry only with entries the night wrote (also across a split, with numbers compared as numbers); for an entry of fewer than two word stems the snapshot also keeps hashed stems of its short words or, for one with no words and no secret, hashed character trigrams; state files with a UTF-8 BOM are read. Version 3.8.6: install.py --check counts a judge key only from its own line in $HERMES_HOME/.env, the one a cron script can read, and names DREAM_* variables set only in the terminal it runs in, compared with their lines in that .env (a DREAM_* value may be printed, a key never is); it and a new read-only dream.py --nightly-status read the dreaming jobs' next_run_at in cron/jobs.json to say when Hermes will not fire them (a gateway that is down, a job paused or with no next run). The nightly prompt never patches through another entry's whole text and keeps an absorbed entry when a merge fails; the loss-guard snapshot also keeps hashed full dates and each entry's hashed head key. No new credentials, network calls, tools or writes.

hermes-dreaming

hermes-dreaming — nightly memory consolidation for Hermes Agent

Русская версия

Nightly, deterministic memory consolidation ("dreaming") for
Hermes Agent, in the spirit of OpenClaw dreaming.

An agent's memory goes wrong in two quiet ways: useful facts never make it into durable memory, and
durable memory fills up with stale or duplicated entries until the char limit silently stops all
writes. Every night a Python script looks at what the agent knows and what people actually said, and
wakes the agent only when there is something to decide. The rules call no LLM and the script never writes
memory; the agent applies its proposals through the regular memory tool and reports in a few lines. An
optional cloud judge, off by default, can second-guess the rules' mention count — see
below.

Task outcomes and recorded explanations (3.6.0)

With holographic 0.20.0 or later, read how stored facts helped or failed a task, separately from their truth/trust:

python3 skills/dreaming/scripts/dream.py --memory-outcomes
python3 skills/dreaming/scripts/dream.py --memory-explain ATTEMPT_ID --memory-format text

Enable collection in the provider (experience: on; optional experience_trace: on). Add "task_outcomes": true
to dreaming.json to include count-only summaries in the normal nightly report. Default is off. No additional model
wakeup or network call is added, no correction text is copied into a lesson cache, and nothing automatically changes
trust, ranking or MEMORY.md. Revisions count as one active outcome per attempt; these remain agent reports.

The default is the configured profile store. A scoped store requires an explicit --memory-store already allowed by
chat_stores.promote_from; reports never join stores, and since 3.7.0 the JSON summary names its store ("store"). Old providers report unsupported and continue normal dreaming.
See docs/experience.md for retention, erase boundaries, JSON output and limitations.

How it works

One night: inputs, the deterministic pass with the screen, the wake gate and the agent's turn; the weekly extraction
and the forget sweep beside it

  • Corroboration from real conversations. A fact counts only if humans mention it on distinct
    days. Cron prompts, compaction banners, URLs, untrusted chats and the agent's own threads never
    corroborate anything. Works in the languages the holographic store reads: Chinese, Japanese,
    Korean and Thai are compared by character n-grams, Latin languages by stems without diacritics.
  • Scoring with the OpenClaw weights (relevance, frequency, diversity, recency, consolidation,
    richness) plus a corroboration gate.
  • Matching against memory. Exact, declarative alias rules and stemmed containment in three
    directions; a candidate that repeats an entry with different numbers is a possible update
    (conflicts), not a duplicate. Every candidate carries the nearest entry, which file it lives in
    and its full text, the source of the verbatim span memory patch changes (Hermes ≥ 0.22), plus an
    old_text anchor for the memory replace of Hermes 0.21.
  • Screening. Secrets and prompt-injection are quarantined — by the dream's own rules and by the holographic
    provider's screen (credentials in its 18 languages, token shapes, environment assignments, instructions in any
    language), which the provider applies only to what it stores and recalls next — dated events expire (dates
    and event words in 15 languages, from «14 de noviembre» to 11月14日), near-identical facts in the store reach the agent once.
  • A wake gate. On a quiet night the cron job prints {"wakeAgent": false} and the model never
    starts. A memory file close to its char limit counts as work (memory_pressure) — the limit gates
    writes silently, so otherwise nobody notices until facts stop being recorded.
  • A loss guard. If a large share of memory disappears overnight, or a long entry loses half of itself, the
    next report says so and names the entries that are gone. An entry the agent compressed, reworded, merged into
    another one or split in two is not a loss: its words and numbers are still in the entries it wrote.
  • Feedback to retrieval. A fact you rejected keeps its trust in the fact store, so the
    provider's prefetch goes on offering it. Such facts are listed with a ready
    fact_feedback(unhelpful) call, so a rejection teaches retrieval too.
  • Confirmations (holographic ≥ 0.15.0). A fact people said again — on two different days, in messages that
    hold most of its words and neither negate it nor give it a new number — is listed with a ready fact_feedback(confirmed) call: its trust
    rises a little, and the agent's own conclusion counts as confirmed. Naming the topic is not saying it again, so
    this is rare by design (none of 58 facts on a live family store; the loose rule would have offered 26). It never
    wakes the model. Items also carry the fact's origin — said, confirmed or inferred (an agent's conclusion
    nobody confirmed, asked about rather than written).
  • Keywords for search (opt-in, holographic ≥ 0.6.1). The fact store finds a fact by words it
    does not contain only through its keywords — synonyms, other roots, translations. Facts without
    them are listed a few a night (keywords_needed) with a ready fact_store update call, and the
    extraction run gives keywords right when it adds a fact. Housekeeping: it never wakes the model.
    Keywords and the provider's optional search by meaning (holographic ≥ 0.14) do different jobs:
    meaning reaches a paraphrase that shares no words, but only while its endpoint answers; keywords
    live in the store and work offline. The pass reads words either way — vectors are the provider's
    business and never reach its JSON.
  • Duplicates across the store (holographic ≥ 0.19.0). Two facts that say one thing in other words — the
    same thread described twice, a profile stored again by the nightly extraction — are found over the whole store
    and asked about, one pair a night: «D-17: "…" and "…" — look like one fact. Merge?», both texts whole. Only a
    "yes" to that number merges them, through fact_store merge with the versions you were shown; the copy's
    history stays under the fact that remains. Nothing is merged at night, and pairs that differ by one word
    («утром» / «вечером»), a number, a person or a "not" are not asked about. The extraction run merges a retelling it
    has just stored into the old fact itself, when the provider's hint offers it and nothing new is in it.
  • A diary (memories/DREAMS.md) with provenance for every candidate.

Every item gets an outcome

A candidate is written, rejected or comes back; a memory entry is removed or confirmed

Nothing is asked forever. A promotion is either written or put on the reject list (matched by text;
dream-reject.py --undo lifts a rejection, and a fact people said again after 180 days comes back as a
question, reject_reask_days); with no outcome it comes back in 3 days. New facts, conflicts and decay
questions are shown at most once per 14 days. A memory entry that survived a "still relevant?" question — kept, or rewritten
in place with a fresh date — counts as confirmed and rests for 90 days. Cooldowns start only when
the agent actually answered: a night that failed halfway re-shows the same items.

With holographic ≥ 0.8.0 (stats.fact_history: true) a human's answer about a fact goes to the
store, which keeps the fact's history: "no longer true" → fact_store end, "it changed" → change,
"that was wrong" → correct, "forget it" → forget (final: the store's fact history goes too) plus removing the
memory entry that carries it. After a forget the store keeps only a tombstone — the id, never the
text — and this skill removes its own copies of the fact by that id: the last payload, the reject
list, the cooldowns, the diary lines (tagged [#<id>] since 2.4.0; older ones through an index of
line hashes kept while the fact still existed) and the logs of the dream cron jobs. Every pass does
that first; the no_agent job dream-forget-sweep.py does it every 15 minutes without the model.

This cleanup covers the store and the skill's own copies listed above. It does not rewrite Git commits,
external database dumps, system backups or Hermes session history. Those copies need their own cleanup process.
A report must distinguish successful deletion from the store from a retained external copy; a documented
history boundary is not removed by retrying the same sweep. The skill does not rewrite repository history.

A "merge?" question (holographic ≥ 0.19.0) has a number that is never reused. "Yes D-17" → fact_store merge
with the versions shown; a text that changed since makes the merge refuse (changed_since) and the question is
asked anew. "They are different" → dream-reject.py --not-duplicates D-17, never asked again (--undo D-17); with
no terminal in the session the pair simply rests 180 days. A question the agent's report did not name comes back the
next night. A merge is no forget: the diary keeps its lines, and only the skill's live state lets the copy go.

Install

Requirements: Hermes Agent ≥ 0.21, Python ≥ 3.9 (standard library only).

1. The plugin — a portable Agent Plugins v1 package (plugin.json + skills/dreaming/):

hermes plugins install hermes-dreaming      # the reviewed, pinned catalog entry
hermes plugins enable hermes-dreaming

Install from the catalog, not from a URL (see below). The cron jobs below are bound to this
plugin's own skill, so they run exactly the copy you installed (and the catalog reviewed). Plugin
skills are namespaced and kept out of the system prompt's skill index; the agent finds them with
skills_list and loads them with skill_view.

hermes skills install itpartypattaya/hermes-dreaming/skills/dreaming

The skill then lands in ~/.hermes/skills/dreaming/ and is listed in the skill index. The installer
scripts below use it only when the plugin is not installed; substitute that path in the commands.

2. The gates and the config

python3 ~/.hermes/plugins/hermes-dreaming/skills/dreaming/scripts/install.py

Hermes runs cron scripts only from ~/.hermes/scripts/ (a symlink is refused), so the installer
copies the three gates there, seeds ~/.hermes/dreaming.json from the example, does a dry run on
throw-away copies of the state, and checks the fact source and the core. It is idempotent;
install.py --check verifies without changing anything — run it after every update, since the copies
in scripts/ can drift from the skill. It also names a job Hermes will not fire: one due more than an hour ago
(the gateway is not running cron) or one with no next run. dream.py --nightly-status answers the short
question "is a night coming?" (read-only; the agent runs it when you answer a dream question).

== hermes-dreaming installer ==
  ✓ dream-precheck.py in place and identical to the skill copy
  ✓ dream-extract-precheck.py in place and identical to the skill copy
  ✓ dream-forget-sweep.py in place and identical to the skill copy
  ✓ config /home/you/.hermes/dreaming.json is valid JSON
  ✓ dry run: fact source: holographic · facts: 0 · human messages in window: 0
  ✓ core gives cron jobs memory natively (Hermes >= 0.21) — the extraction job can use fact_store
  ✓ memory provider 'holographic', fact store present (/home/you/.hermes/memory_store.db)
  ✓ holographic 0.17: cron jobs may write facts; forgotten facts are swept
  ✓ the fact store keeps origins and confirmations — items carry `origin`, the confirm section is on

== 9 ok, 0 warning(s), 0 problem(s) ==

3. Edit the config — the part nobody can do for you:

$EDITOR ~/.hermes/dreaming.json    # timezone, trusted_chat_ids, agent_names, fact_source

Until trusted_chat_ids lists your group chats, no group chat corroborates memory (fail-closed
by design). If a trusted chat is a forum, list the threads that are not human talk — the agent's own
alerts, assistant bridges, machine-generated cards — under excluded_threads.

4. The cron jobs

~/.hermes/hermes-agent/venv/bin/python \
    ~/.hermes/plugins/hermes-dreaming/skills/dreaming/scripts/install_cron.py --deliver local --dry-run
# happy with the plan? run it again without --dry-run

The CLI has no flag for enabled_toolsets, and cron/jobs.json is live scheduler state, so job
creation goes through the Hermes Python API. The jobs get the plugin skill's qualified name
straight from Hermes' plugin registry (hermes-dreaming:dreaming on Hermes 0.22.6; earlier cores named
it agent-plugin-hermes-dreaming-<hash>:dreaming), so the plugin must be enabled first. When Hermes
renames it, a job bound to the old name runs without the skill: install.py --check reports a stale
skill binding, and install_cron.py --rebind points the job at the current name; all three gates likewise prefer the plugin's copy of dream.py. Re-running
install_cron.py updates existing jobs whose prompts exactly match a known shipped template for
that job's role. Local edits (even whitespace), missing prompts and unknown templates are preserved
with a warning: compare them with DREAM_PROMPT / EXTRACT_PROMPT in the installed script and
migrate them manually. No Git checkout or separate migration state is needed. A job that loads
another skill than this install provides is reported; --rebind also points it at the right skill
in place, preserving any other attached skills. Prompt synchronization does not require --rebind.
By default, schedules, delivery, model/provider, paused state and run counters are preserved.
Explicitly supplied settings that differ from existing jobs are reported. Add --update-existing
to apply only those supplied settings, for example --update-existing --model cheaper-model.
--inherit-model --update-existing clears both model and provider pins; it cannot be combined
with explicit model/provider values. Schedule changes support cron expressions to cron expressions;
Hermes may recalculate the next run and clear pending/quota scheduling state. No job is resumed.

--job-id <exact-id> limits the entire operation to that job, including prompt/rebind/settings
changes; missing jobs of other roles are not created, and a job of another role the installer cannot
classify or that runs in the wrong mode is reported without blocking the named one (a job of the same role
still blocks: both run the same gate script). Repeat it to select several jobs. Duplicates
are reported with their IDs and active count. Untargeted updates of duplicate roles are refused;
use explicit IDs to choose which jobs to maintain. Nothing is deleted automatically.

Use --upgrade --dry-run after updating the plugin, then repeat without --dry-run to repair copied
gates, synchronize jobs and run an independent final cron/gate check. All targets, config and arguments
are checked before gate writes; public Hermes schedule validation runs before apply. A direct invocation
without --upgrade refuses stale copied gates. This is staged work, not an atomic transaction: a
failure stops later writes, reports partial progress and can be retried. Use install.py --check
for the additional fact-source, memory and judge checks. --hermes-home <path> selects the same home
for files, the registry and cron API; choosing an interpreter alone does not choose a data home.

Use --dry-run to preview the actual creates and updates, including job IDs, changed fields and
the stock prompt diff. This reads a snapshot of cron/jobs.json without importing the cron API or writing
anything; it does not reserve that state for a later apply. Do not edit cron configuration at the
same time as running the installer: Hermes' public update API has no conditional update. The
installer re-reads before updating and skips edits it observes, but cannot close every race.
install.py --check reports outdated stock prompts as problems and custom/unknown prompts as
warnings. It also reports each role's execution mode, paused/terminal state and duplicates. Several
active jobs of one role or an incorrect execution mode are problems. Missing optional jobs and paused
jobs are warnings; a correct skill binding alone does not mean the job runs. --force explicitly
creates additional jobs, with a count warning; it is incompatible with targeted/rebind/settings updates.
Use
--deliver telegram:<chat_id>:<thread_id> to receive the report in a chat and
--extract-schedule "" to leave the extraction out. A third, no_agent job (--sweep-schedule,
every 15 minutes) cleans the dream's copies of facts the store has forgotten — no model, empty
output unless it removed something; --sweep-schedule "" skips it. Empty schedules skip this invocation
only: existing jobs remain enabled, and the installer names them. To pause future starts use
hermes cron pause <exact-id>; this does not cancel an execution already in progress.

To persist a smaller installation, set "cron": {"expected_roles": ["night", "sweep"]} in
dreaming.json. The allowed roles are night, extract, sweep; the default is all three, and []
deliberately expects/creates none. Installer and checker share this policy. Excluding a role does
not pause an existing job: one that is still active is reported. Invalid config is an error, never
an instruction to fall back to creating all jobs. No prompt/intent sidecar is needed.
The extraction job is cheap to run weekly — a
nightly run mostly answers [SILENT] on a small household.

A job keeps the skill name it was created with. The hash in it comes from the plugin's name in
plugin.json, so updates and reinstalls keep it. Disabling or removing the plugin does not: the job
then runs without its skill, and Hermes starts the nightly report with
⚠️ Skill(s) not found and skipped. install.py --check names such a job; re-enable the plugin, or
run install_cron.py --rebind against the install you kept. The check reads Hermes' plugin
registry, so run it with Hermes' interpreter (~/.hermes/hermes-agent/venv/bin/python) — a plain
python3 only gets a warning that it cannot tell.

Install from the catalog, not from a URL

hermes plugins install hermes-dreaming      # the reviewed, pinned catalog entry

hermes plugins install itpartypattaya/hermes-dreaming installs HEAD as a custom, unreviewed
source, and the next plugins update does a git pull past the pinned SHA. Same code today,
different trust tomorrow.

Docker

In a container install the paths differ: the plugin lands under /opt/hermes
(or wherever HERMES_HOME points) and Hermes' own interpreter is
/opt/hermes/.venv/bin/python. Run the installers with that interpreter and as
the uid the gateway runs under — a docker exec as root would leave
cache/*.json owned by root, and the gateway's own pass then reads them as
missing. The scripts restore the previous owner when they can, but starting as
the right user is cleaner.

Upgrading from 2.0

2.0 bound the jobs to a regular dreaming skill. After installing the plugin, re-run step 2 (the
gates changed) and then step 4 with --rebind: the existing jobs switch to the plugin's skill without
losing their schedule, delivery or history.

Upgrading from 1.x

Version 1 was installed by cloning the repository straight into ~/.hermes/skills/dreaming. Version
2 keeps the skill in skills/dreaming/, so a git pull there would hide SKILL.md one level down.
Move the old clone away, install with step 1, re-run step 2 (the gates are replaced), and run step 4
with --rebind so the existing jobs point at the plugin's skill. Your config and state in ~/.hermes/cache/ stay as they are. The allow_memory
flag of 1.x jobs is unused since Hermes 0.21 and can stay or go.

Writes that wait for a human

If your Hermes runs with memory.write_approval: true, a write from a cron session answers
success: true, staged: true and the file on disk does not change: the entry sits in
pending/memory/ until you approve it. The pass reads that queue, so a candidate already waiting
is not offered again, an entry whose removal is queued is not asked about, and a queue that is both
large and old raises a pending_writes alert. Two things follow:

  • the nightly report says "sent for approval", not "saved" — believe it;
  • enabling the holographic provider for the fact store opens a second write channel that the
    approval gate does not cover: fact_store writes to memory_store.db directly, including
    from cron, and its prefetch then feeds those facts into ordinary turns. With the gate on, consider
    fact_source: none (the nightly memory review keeps working) — install.py --check says this out
    loud too.

Fact sources

The dream consolidates candidate facts; where they come from is fact_source in dreaming.json.

fact_sourcewhere the facts areextraction jobnotes
holographic (default)the Hermes holographic provider's SQLite store (memory_store.db, or plugins.hermes-memory-store.db_path)✅ via fact_storeenable with memory.provider: holographic; use 0.8.0 or later — 0.2.0–0.7.x refuse every fact_store write from a cron job, so extraction and keywords store nothing (install.py --check warns). ⚠️ It left the Hermes core on 2026-10-11 (Hermes v0.21.7): hermes update installs the plugin itpartypattaya/hermes-plugin-holographic from the catalog in its place. The catalog entry may still pin an older release (0.6.1) — check with install.py --check; if that install failed and memory went off, see the plugin's README, "Memory went off after hermes update". With holographic scope: user / chat / thread the facts live in per-user / per-chat files the dream does not read by default and a cron job stores nothing — the report says so; see One database per chat. Nothing else about this skill changes
sqliteany SQLite table: fact_store_path, fact_table, fact_columns—for your own export; opened read-only
jsonlone JSON object per line: fact_store_path, fact_columns—the simplest export format
noneno fact store—the memory files alone: "still relevant?", fill level, loss guard

fact_columns maps your names onto id and content (required) and created_at, updated_at
(ISO or epoch), category, tags (string or list), trust (0..1). Example:
{"fact_source": "jsonl", "fact_store_path": "exports/facts.jsonl", "fact_columns": {"content": "memory"}}.

Hosted providers (mem0, Honcho, Supermemory, RetainDB) extract and deduplicate facts on their own
servers; reading them would need API keys in a cron job for little gain, so there is no adapter. If
you still want the dream's corroboration over them, export to jsonl.

One database per chat

holographic with scope: chat, thread or user keeps one database per chat (topic, user) — a bot that serves
many unrelated groups keeps them apart. Memory files are one for all chats, so the dream does not read those
databases unless told to, and then only in two steps:

"chat_stores": {"read": true, "promote_from": ["telegram:-1001234567890", "telegram:-1001234567890:42"]}
  • read — every database appears in the report as counts (facts, new ones): no text is read or shown, no ids.
  • promote_from — the chats (topics with scope: thread, users with scope: user) whose facts join the pass. Each
    is corroborated only by its own chat, and that chat's messages corroborate nothing else. Once a promoted
    fact is written to memory, every chat sees it — list only chats where that is what you want. With scope: user
    the plugin files a fact by the turn's author, but Hermes keeps no author per message: a user's facts are
    corroborated by the messages of that user's own sessions (in a group, the session owner stands for the author).

Such items carry store and ids like telegram--1001234567890#17; the agent writes them only through memory
(a cron session cannot reach a chat's database), and "forget it" is said in that chat. Extraction stays with the
shared store. The trust rules do not change: chats in trusted_chat_ids (and private chats, unless
trust_private_chats: false) still corroborate shared facts and memory entries — on a bot serving many unrelated
people, trust only the owner's chats.

Optional live task-outcome reports and recorded retrieval explanations (no second text cache or model calls):
docs/experience.md. These reports do not change trust or ranking.

Optional cloud judge (off by default)

The rules decide that a message mentions a fact when the two share enough words. That is cheap and predictable,
and often wrong: "Гоша тренирует юниоров" counted for "Гоша не пьёт кофе", a pasted report counted for every fact
it brushed against. On a frozen test set of 360 pairs, only 37 % of the pairs the rules counted were real
confirmations. Each false one pushes a fact towards memory or tells the store that people keep saying it.

The judge is a second opinion on exactly those pairs. For every (fact, message) pair the rules counted, it asks a
decision model one question — does the message confirm the fact, contradict it, or neither? — and when the answer
is a confident "no", it takes the pair out of the count. It can never add a pair: what is a candidate is still the
rules' call, and a night without the judge is decided exactly as before. It is off by default; turned off, its
code is not even loaded and nothing leaves the machine.

A night with the cloud judge: the rules count pairs, the ones that may leave go to Jev (OpenAI as the fallback), a
confident "no" takes a pair out; shadow only reports, veto decides the night again; a night covered under half
applies no veto

How a night with the judge goes

  1. The rules decide the night as always and note every pair they counted.

  2. Each pair that may leave (see below) goes to the first provider: the fact's text and the person's own words,
    nothing else, with this question and these three answers — the wording the threshold was measured with:

    Does the message confirm the fact, contradict it, or neither?
    confirms     the message confirms the fact: the same person or thing, and the fact still holds
    contradicts  the message contradicts the fact: it says the fact is not true or no longer true
    unrelated    the message is about another person or thing, or neither confirms nor denies the fact
    
  3. The model picks one answer and returns a probability for each. An answer other than confirms with a
    confidence of at least tau (0.50 by default) is a veto. An answer that does not fit the schema is not used;
    the pair goes once to the second provider, if there is one.

  4. In shadow the night publishes what the rules decided, and the report (stats.judge) says how many pairs the
    judge vetoed and how many decisions that would change. In veto the night is decided again without the vetoed
    pairs, and that night is published — promotions, confirmations, fact decays, "said again" after a rejection,
    new facts and conflicts, the evidence quoted. Memory-entry questions (md_decays) never take a veto.

  5. A night on which the judge answered for under half of the pairs it could send, or every provider was off,
    applies no veto at all (effective: degraded). Three such nights without two good ones between raise one
    judge_degraded alert a week, so a lost key or a dead network does not go unnoticed.

The models

A decision model is a classifier behind an API: it reads a text, chooses one of the answers it is given and returns
a probability for each. It writes no text, answers in a few hundred milliseconds and costs a fraction of a cent per
call. Two are supported; the first one listed in providers is asked first, the second only when the first gives
no usable answer.

Jev (jev)OpenAI Decisions (openai)
Made and served byTypeSafe; served by OpenRouter (/api/alpha/decisions, an alpha API)OpenAI (/v1/decisions, public beta since 2026-10-06)
Modeltypesafe/jev-1.14gpt-6-luna
KeyOPENROUTER_API_KEYOPENAI_API_KEY
Cost of one call, measuredabout $0.00002 (OpenRouter reports the charge)about $0.00002 (~210 input tokens at $0.10 per million; output is free)
Latency, measured (median / 95th percentile)~280 ms / 0.4–1 s~290 ms / ~0.4 s
False confirmations removed (holdout)84 % (142 of 169)75 % (127 of 169)
True confirmations removed (holdout)none of 101none of 101
Real confirmations among the counted0.37 → 0.790.37 → 0.71
By language, false ones removed (ru / en / zh)76 % / 94 % / 85 %68 % / 87 % / 74 %
Data terms, as their documentation stated in October 2026not used for training; zero retention only for enterprisekept up to 30 days for abuse monitoring; zero retention on approval; not used for training by default

Jev comes first because it removed more false confirmations with the same zero errors; OpenAI is the fallback for
the nights Jev's alpha API is down or changes. Check the providers' current terms yourself before you send family
chats to them: what was sent cannot be recalled.

How it was measured: before any of this code existed, both providers answered 921 pairs prepared exactly as the
plugin prepares them — 561 to choose the threshold on, then a holdout of 360 written separately (by another model,
in Russian, English and Chinese) and frozen before the first run. tau 0.50 is the lowest value tried; the rule
was the lowest threshold with at most 5 % wrong vetoes and 10 % lost confirmations, and both providers met it
there. Before the release, the plugin itself replayed those recorded answers and vetoed the same pairs, one by
one. The whole measurement cost $0.023.

What it does not prove: the holdout was written by a model and not checked by a person, and live speech is messier
than written examples. shadow and a labelled sample (below) are how you find out on your own chats. Local models
were tried first, on the 3.2.0 experiment: Laya (multilingual, on a CPU) was the weakest of all, mDeBERTa-xnli was
better on its own but added almost nothing as a veto — hence a cloud option, off by default.

Turning it on

"judge": {"mode": "shadow", "providers": ["jev", "openai"], "send_from": "trusted", "send_sources": ["telegram"]}

Put the keys in ~/.hermes/.env — Hermes keeps provider keys out of the environment of cron scripts (and
terminal.env_passthrough refuses them), so the nightly judge reads its own line (OPENROUTER_API_KEY=…,
OPENAI_API_KEY=…) and no other; a key exported only in your shell works for a pass you run by hand, never at night.
A key is never printed, logged or written anywhere. install.py --check then shows the mode, where pairs may go and
whether the night has each key (a key only in the terminal it runs in is named as such), never its value. A section that breaks the schema turns the judge off and says why.

What leaves the machine

  • Only from what you list. send_from is "trusted" (the trusted group chats and, with
    trust_private_chats, private chats) or a list of chat ids; send_sources names the session sources
    (telegram, …); send_fact_stores names promoted chat stores whose facts may be sent, with that chat's own
    messages only; send_no_chat_sessions lets sessions without a chat go. The default lists nothing.
  • Only the fact and the person's own words. The fact's text as stored; the message without the reply quote,
    with a voice transcript unwrapped, without links (with or without https://) and [service brackets]. No ids,
    senders or times. Names inside the texts do leave.
  • Nothing risky, nothing long. A pair whose text holds a secret or an instruction stays home, and so does a long
    one (a fact over 400 characters, words over 600) — such pairs stay counted without a verdict. Long pasted messages
    are a large share of what the rules count on a busy chat, and the judge does not see them.
  • To whom. OpenRouter for jev, OpenAI for openai; with both listed, one pair may reach both.

Limits, failures and files

  • At most max_attempts (250) calls, max_cost_usd ($0.05, by the price the provider reports; soft — the last call
    may pass it) and 120 seconds a night, never past the gate's deadline. HTTPS to fixed endpoints, no proxy, no
    redirect, answers of at most 64 KB. A provider without a key, or that refuses it, is off until the next night. An
    answer, cache or health file of the wrong shape is unusable, not fatal; anything else that fails inside the judge
    leaves the night to the rules.
  • Its files, in ~/.hermes/cache/ (0600): dream-judge.json — verdicts for 90 days, keyed by hashes, with fact ids
    and no text, reused only for the same pair with the same text and a provider still listed;
    dream-judge-journal.jsonl — every pair sent, as it was sent, and a record of each night, for 90 days, for your
    review; dream-judge-health.json — one line a night; dream-judge-export-manifest.json — the last review sample,
    until it is scored (90 days at most). A night with the judge off deletes the journal and the health file; the
    forget sweep removes a forgotten fact from all of them, even with the judge off.
  • Off the network: --dry-run reads the judge's cache and sends nothing; --explain does not load the judge;
    --judge-replay FILE judges from recorded answers (JSON lines {"provider", "fact", "words", "response"}) and
    writes nothing of the judge. A real night — the gate, hermes cron run, dream.py without --dry-run — sends.

From shadow to veto

Run shadow for a couple of weeks, then take a blind sample: dream.py --judge-export sample.jsonl writes one
judged pair per fact, each line only {"id", "fact", "message"}. Label every line in a JSON-lines file
{"id", "label"} — S (confirms), C (contradicts), U (neither) or ? (for someone else to decide) — and run
dream.py --judge-score labels.jsonl. It answers ready when the upper 95 % bound of wrong vetoes is at most 10 %,
of lost confirmations at most 20 %, coverage at least 90 % and no wrong veto changed a decision; not_ready when
the lower bound of wrong vetoes is over 10 %; otherwise continue — label more. When the fallback gave over a fifth
of the verdicts, each provider has to pass on its own. Switch mode to veto only on ready.

Using it by hand

S=~/.hermes/plugins/hermes-dreaming/skills/dreaming/scripts
python3 $S/dream.py --dry-run                 # what tonight's pass would show; writes nothing
python3 $S/dream.py --explain 42              # why fact 42 scored like that
python3 $S/dream.py --forget-sweep            # clean the copies of facts the store has forgotten
python3 $S/dream-reject.py 42 --reason "thread was closed"
python3 $S/dream-reject.py --list             # what is muted, and how old
python3 $S/dream-reject.py --undo 42          # lift a rejection (by its key or the fact's id)
python3 $S/dream-reject.py --from-report --reason "duplicates the system prompt"   # after a manual cleanup

Cleaning durable memory by hand? Reject what you dropped: the facts stay in the store, flip to
in_memory: false, and the next pass would propose them right back.

A plain python3 may have no PyYAML. The scripts then read config.yaml with a narrow reader of their own. It
covers block key: value lines, comments and one-line {…}, and it does not guess. If it cannot read the
memory: block or the holographic plugin's block for sure, that block counts as unread:

  • the pass reads no facts unless fact_store_path names the store;
  • extraction stays off;
  • the report and install.py --check say why.

Forms it leaves unread include a {…} over several lines, a value on the line after its key, tags, anchors and
block scalars (|). To read such a config, run the scripts with Hermes' interpreter
(~/.hermes/hermes-agent/venv/bin/python, which has PyYAML). The scheduled jobs always use it.

Verify it end to end

hermes cron list                          # the three jobs present and enabled
hermes cron run <dream job id>            # one real run
tail -20 ~/.hermes/memories/DREAMS.md     # a section for today

A quiet night prints {"wakeAgent": false} and the agent never starts — the wake gate doing its job.

hermes cron run and the gates are a real night, like dream.py without --dry-run: they write the state,
mark what they showed and, with the cloud judge on, send pairs to its providers. To look without consequences,
use dream.py --dry-run.

Configuration

~/.hermes/dreaming.json (or $DREAM_CONFIG); see skills/dreaming/examples/dreaming.example.json.
Missing file → defaults. A file that is there but is not valid JSON stops the nightly pass and the extraction job
with dream_error, instead of a night on the defaults (no trusted chats, so a batch of wrong "still relevant?"
questions and an extraction cursor moved past every group message); --dry-run and install.py --check still read
past it and say so. Precedence: CLI flag > DREAM_* env > config > default.

fieldmeaning
timezoneIANA zone for the diary date and day-bucketing of mentions. Not set → Hermes' own timezone, then UTC
trusted_chat_idsgroup chats whose messages corroborate memory (fail-closed: empty = none)
excluded_threadsthreads of a trusted chat that must not corroborate — {"<chat_id>": ["<thread_id>", …]}
untrusted_sourcessession sources that are machine prompts — cron, subagent and tool are always excluded; add cli when scripts drive the agent
exclude_patternsregexes; a message whose text matches never corroborates (bridge briefs, forwarded digests — machine text with no source of its own)
trust_private_chats, trust_sessions_without_chatwhether a DM, and a session with no chat metadata, count as human speech (both default true)
agent_names, extra_stopwordsnoise words for the tokenizer
alias_rulesdeclarative "same fact, other words" rules — {"fact": [["a","b"],["c"]], "memory": [["x"]]}
fact_source, fact_store_path, fact_table, fact_columnswhere candidate facts come from (above). Env: DREAM_FACT_SOURCE, DREAM_FACT_STORE
durable_memory_pathsfiles that already are memory (dedupe targets)
memory_char_limitschar limits of MEMORY.md / USER.md. Leave it out and the limits are read from Hermes' own memory.memory_char_limit / user_char_limit; the example's numbers are the core defaults and will misreport an install that raised them
pending.dir, pending.alert_min, pending.alert_daysthe approval queue (pending/memory): when ≥alert_min writes have waited longer than alert_days, one alert is raised
pinned_markersentries with these markers are never asked about
probesphrases that must stay in MEMORY.md / USER.md (["allergic to peanuts"]); when one disappears — by its text, or every word of it in one sentence of an entry in any form — one probe_missing alert. The loss guard catches a mass loss; this catches the one entry merged away while memory was tidied at its limit. Empty by default
reject_reask_daysa rejected fact (dream-reject.py) is asked about once more when the rejection is older than this (180 days) and the fact was said again since — a new store row and a human mention after it; the item carries previously_rejected. 0 = never
windows, gates, weightsscoring knobs — references/scoring.md; gates.md_confirmed_cooldown_days (90) is the rest period of a confirmed entry
precheck.memory_full_pctfill level (%) at which a memory file alone wakes the agent (default 85; 0 disables)
precheck.timeout_sechow long the gate waits for dream.py before reporting dream_error (default 600)
corroboration.memory_mbwhat one nightly pass may keep of what it read from the window's messages, in MiB (default 256, at least 1; an estimate on the high side). Past it the parts cheapest to read again are let go and read again when a fact needs them — a slower night, the same decisions. Lower it on a small machine; raise it if a large window makes the night slow — references/scoring.md, "Each message is read once a pass"
extract.*extraction chunking: max_messages 200, max_chars 40000, min_messages 15, backfill_days 60, max_retries 3
diary.heading, diary.keep_sections, diary.pathdiary header, rotation and where it lives (memories/DREAMS.md)
memory_loss_alert_fractionloss-guard threshold (0.25) — applied to the share of lost entries and of lost characters
gates.promotion_cooldown_daysrest for a promotion already shown (3 days); without it a candidate the agent could not write came back every night
duplicates.enabled, .min_containment, .per_night, .question_cooldown_days, .max_pair_checks, .max_charsthe "merge?" questions (holographic ≥ 0.19.0, on by default): the share of the shorter fact's words the other must hold (0.7), questions a night (1), rest of an asked pair (180 days), the night's budget of pair checks (200 000; past it the search is skipped with one alert), facts longer than this (2000) take no part — references/scoring.md, "Duplicates across the store"
keywords.enabled, keywords.caplist facts without keywords for the agent (keywords_needed, at most cap a night, default 10) and ask the extraction run for keywords. Off by default; turn it on with holographic ≥ 0.6.1 — an older provider ignores the parameter, and 0.6.0 re-dated a fact when it got keywords
chat_stores.read, chat_stores.promote_fromholographic scope: user / chat / thread only: list every per-chat database (counts), promote the facts of the listed chats — see One database per chat
judge.mode, judge.providers, judge.tau, judge.send_*, judge.max_attempts, judge.max_cost_usdthe optional cloud judge: off (default) / shadow / veto; jev and / or openai, the first asked first; the veto threshold, 0.50–1 (default 0.50); what may be sent — send_from ("trusted" or chat ids), send_sources, send_fact_stores, send_no_chat_sessions; the night's limits (250 calls, $0.05). A section that breaks the schema turns the judge off and says why — see Optional cloud judge

Safety and privacy

Files the skill reads and writes

  • Network: none by default. With the cloud judge on, the pass sends
    what its section lists to OpenRouter and / or OpenAI over HTTPS, and nothing anywhere else. LLM calls: none
    from the scripts besides that judge's decision call; the only model turn is the agent in the cron session,
    with your model and your tools.
  • Reads: state.db (sessions and messages, opened read-only), the fact store (read-only, per-user
    and per-chat stores too), the memory files, dreaming.json and config.yaml, the approval queue
    (pending/memory), scripts/holo_screen.py, dream_lang.py and dream_yaml.py next to it; the forget
    sweep also cron/jobs.json and the dream jobs' logs; with the judge on, its keys' own lines in .env
    (nothing else of it).
  • Script writes: ~/.hermes/cache/dream*.json (the night's payload dream.json, cooldowns, questions,
    reject list, snapshot, extraction cursor, diary index of line hashes, sweep state; with the judge on, its
    dream-judge* files; mode 0600) and a lock
    file, ~/.hermes/memories/DREAMS.md (diary; after 90 nights the older sections move to
    DREAMS.md.archive.md), and — only install.py — the three gate copies in ~/.hermes/scripts/ (0755)
    plus a seeded dreaming.json.
    A state file is written whole or not at all (a temporary file renamed over it). One that is there but is not
    valid JSON is never read as "no state": it is moved aside to <file>.corrupt-<UTC time> with a warning in the
    job's log, and the pass runs without it — look there if rejections or cooldowns seem to have reset.
    Only a run that holds the state lock moves a file aside; dream-reject.py --list reports a broken list and leaves
    it as it is.
    The forget sweep rewrites those files without a forgotten fact and deletes the dream jobs' own logs
    in ~/.hermes/cron/output/ that mention it, by its id or its verbatim text. The set-aside *.corrupt-* copies
    cannot be parsed, and a write cut short may have cut the fact's text anywhere, so the first sweep after a
    forget deletes all of them; later sweeps delete a copy that mentions a forgotten fact. A copy it cannot delete
    is an error: the gate fails and the next run deletes it. Nothing else.
  • The agent writes memory entries through the memory tool (at most 6 changes a night, of them at
    most 3 new); in the extraction job, candidate facts through fact_store add; keywords through
    fact_store update; trust through fact_feedback (unhelpful for a rejected fact, confirmed). The
    skill deletes nothing from the store; a fact changes or leaves it through fact_store end / change /
    correct / forget, on a human's own words only.
  • Message and fact contents are treated as data, never as instructions. Facts, the evidence quoted
    next to them, the messages the extraction job hands over and the "still relevant?" previews are
    all screened for credentials and injection directives; a hit is quarantined (a secret's text is
    published nowhere, an injection keeps a 60-char preview in the full JSON only).
    The screening is a regex filter, not a guarantee: it knows the common key shapes
    (sk-, gsk_, ntn_, gho_, AWS, Google, Slack, Telegram, JWT, PEM), credential markers in
    Russian and English, and the injection phrasings the core's own cron scanner looks for, plus the
    holographic provider's screen (scripts/holo_screen.py, a verbatim copy, MIT) — a
    wording nobody has seen yet can still get through. Keep the approval gate on if that matters.
    No tools, hooks, middleware or environment variables are registered.
  • DREAM_SCRIPT decides what code the gates run. Set in the environment of the cron jobs, it points all three
    gates at another dream.py instead of the plugin's reviewed copy. It exists for unusual layouts
    (skills.external_dirs); leave it unset otherwise.

Repository layout

plugin.json                          Agent Plugins v1 manifest
skills/dreaming/
  SKILL.md                           agent instructions
  scripts/dream.py                   the pass (never writes memory)
  scripts/dream_lang.py              stopwords, months, weekdays and dates of every language read
  scripts/dream_yaml.py              config.yaml reader for a run without PyYAML
  scripts/dream_judge.py             the optional cloud judge (loaded only when it is on)
  scripts/holo_screen.py             the holographic provider's screen, a verbatim copy
  scripts/dream-precheck.py          nightly wake gate        → ~/.hermes/scripts/
  scripts/dream-extract-precheck.py  extraction gate          → ~/.hermes/scripts/
  scripts/dream-forget-sweep.py      no_agent forget sweep    → ~/.hermes/scripts/
  scripts/dream-reject.py            reject list CLI
  scripts/install.py                 installs and verifies the gates
  scripts/install_cron.py            creates jobs and synchronizes recognized stock prompts
  scripts/cron-prompt-history.json   per-role SHA256 allowlist of shipped prompt templates
  references/scoring.md              signals, gates, sections, state files
  references/cron-memory.md          what cron sessions may touch
  examples/                          config and cron job examples
  tools/vendor_screen.py             makes holo_screen.py from the provider's source
tests/                               stdlib unittest, synthetic data, no network (the judge's: a fake provider
                                     on 127.0.0.1)
docs/                                README images (SVG sources in docs/src/)

Development

python3 -m unittest discover -s tests -v

The tests also run from a copy that keeps tests/ next to the skill directory. CI also runs
ruff check --select E,F,BLE --ignore E501 skills tests, and checks scripts/holo_screen.py against the provider's
source at the commit the copy names. tests/evals/evals.json holds scenario prompts for checking the agent's
behaviour against SKILL.md with skill-creator; CI does not run them. Issues and pull requests are welcome.

Design notes

  • Corroboration must come from humans; machine text never counts.
  • Every candidate needs an outcome. What the agent cannot close at night (there is no terminal
    in the cron session) is closed by cooldowns on the script side, not by agent discipline.
  • Text, not ids. SQLite reuses ids; state is keyed by a text fingerprint, so a re-extracted fact
    is recognised.
  • Zero writes is a success. A night is capped at 6 memory changes, and an entry is changed only
    with text the script hands over verbatim.
  • Borrowed ideas: OpenClaw (phases, weights, gates, loss fraction, explain), mem0 (nearest entry →
    update instead of append), Graphiti (supersession as a flag), Generative Agents (evidence
    citations), MemoryBank (decay by strength).

Author

Anton Vaskov — Telegram @passone, GitHub itpartypattaya.

License

MIT

README from the reviewed commit 21878d3; it updates when the author re-pins.

More by itpartypattaya

4 plugins by itpartypattaya in the catalog.

itpartypattayaholographicLocal fact-store memory provider: SQLite with FTS5 keyword search (word forms in English, Russian, Spanish, French, Portuguese, Indonesian, German, Hindi, Arabic, Bengali, Italian, Turkish, Polish and Dutch; Russian and English words of the same root at a lower weight, from bundled DerivBase.Ru (Apache-2.0) and Open English Wordnet (CC BY 4.0) pairs; German compounds and German and Spanish irregular verb forms from bundled Wikidata Lexemes tables (CC0); Chinese, Japanese, Korean and Thai by character n-grams, Chinese also split into words with jieba's dictionary (MIT), Traditional and Simplified Chinese compared as one through a bundled OpenCC table (Apache-2.0), Japanese spelling variants through SudachiDict's (Apache-2.0); synonyms through keywords the agent gives when it stores a fact), trust scores, entities with aliases and HRR (holographic reduced representation) recall, with no API key, network or model calls unless an optional online feature is switched on: search by meaning (embeddings: on) or rescoring by a cross-encoder (rerank: on), both off by default. The provider that shipped in-tree as plugins/memory/holographic, with the same provider name, config (plugins.hermes-memory-store) and memory_store.db, so hermes update moves existing users onto it; a file without merges keeps history schema 1; the first merge raises it to schema 2, after which writers of 0.15-0.18 refuse it until 0.19.0 or a pre-merge backup is restored. Taken over from Nous Research's handoff copy (NousResearch/hermes-plugin-holographic) and maintained by itpartypattaya; since 0.1.1 it fixes probe/reason/related/contradict, non-atomic writes and the never-written retrieval_count, gates recall by relevance without repeats, flags duplicates and conflicts when a fact is added, and honours the provider contract (read-only subagent contexts, hermes_home, mirror metadata, backup_paths); since 0.8.0 it keeps the history of every fact (change / end / correct / revert, search and list as_of a date) and forget erases a fact with all its versions from the file; since 0.16.0 a name guessed from a fact's text must be shaped like one and stays provisional until a second fact or a person confirms it, and entities can be renamed or deleted (the facts stay). Since 0.18.0 an optional, experimental second stage reorders the recall candidates with a cross-encoder at a /v1/rerank endpoint that answers in Cohere's shape without a key, such as llama-server (rerank: on, off by default). It does not raise hits: on the maintainer's held-out set (126 questions) it cut non-target facts in the top five by about 40 % and lines per turn by about a third, and lost about one target per hundred questions. Disclosure — local only unless an optional online feature (search by meaning or rescoring) is switched on: reads and writes one SQLite file per profile ($HERMES_HOME/memory_store.db unless db_path says otherwise), or with scope: user / chat / thread one file per user or chat in holographic-users/ or holographic-chats/ next to it; each fact version records where it was written (platform, chat type, chat and thread id, session id, the turn author's id and display name, and whether the person said it or the agent inferred it; never chat titles), shown in full by list, history and export and not in recall unless recall_source: short (date, display name, this or another chat); each confirmation of a fact by a person keeps its time, session id and that person's id (no text); forget deletes that and the confirmations with the fact and keeps only an HMAC of the text, keyed by a random key stored in the same file, as a tombstone; delete_entity removes a name, its aliases and links from the entity index (never a fact) and keeps an HMAC of each name the same way (not of an alias only a fact's text gave, which goes without one), and both rewrite the file so freed pages keep no copy; the first writable open after an upgrade that changes the extraction rules relinks the facts to their entities under the new rules (stores up to 2,000 facts and 500,000 characters; larger ones on fact_store rebuild_entities), changing only the names it guessed and their links, never a fact, a declared name or an alias someone gave; subagents never write, but a cron job's explicit fact_store / fact_feedback calls do unless cron_writes: false (on by default); no subprocesses or telemetry (at the debug log level the recall stages log fact ids and scores, never text), and no network calls or credentials unless embeddings: on or rerank: on (both off by default). With embeddings: on, the text of facts, and of messages and fact_store search queries that are not greetings, goes to the OpenAI-compatible embeddings endpoint the user configures, also after cron turns while cron_writes is on (embedding_url; https, plain http only to localhost, a private or link-local address, or a local host name such as one without a dot or ending in .local), with the key read from the environment variable the user names (embedding_key_env, OPENAI_API_KEY unless set, sent as a Bearer token to whatever embedding_url is configured, never stored in config) and no redirects followed; facts that recall would not inject, and facts and messages that look like they hold a secret (checked by pattern, best effort), are not sent; the vectors are kept in the same file (table fact_embeddings), deleted with their fact by forget / end / remove and all of them by the next writable session after the option is switched off; the provider keeps what it received under its own terms; with rerank: on, before a turn the user's message and up to rerank_top_k (40) candidate fact texts, and for a fact_store search its query and results, go to the rerank endpoint the user configures (rerank_url; https, plain http only to localhost, a private or link-local address, or a local host name), with no credentials and no redirects followed; facts that recall would not inject or that look like they hold a secret, and queries that hold one, are not sent; a failure or a slow answer gives the recall of rerank: off and pauses the endpoint (60 s, doubling to 900 s); nothing the endpoint returns is stored; the bundled language dictionaries are gzip-compressed plain-text word lists; with auto_extract on (off by default) user sentences that state a preference or decision are stored. Since 0.19.0, fact_store merge combines duplicate facts in one transaction while keeping each copy's history, sources and confirmations under its original id. The retained fact keeps its own text, trust and origin; copies leave current search and recall. Optional expect pins the exact shown versions and refuses changed participants without a write. Scheduled jobs can merge only copies created in their own session. Forgetting the retained fact also erases its merged copies. Merge is local and makes no new network or model calls. Version 0.19.1 adds strict tooling for comparing recorded margins; the normal RECALL_MARGIN remains 1.0. Version 0.19.2 closes a timed-out rerank or embeddings request socket so a server dripping response headers does not keep its worker alive. During TLS wrapping, cancellation is retained but the handshake can continue until its own socket timeout; DNS resolution is outside socket cancellation. Version 0.20.0 adds an opt-in local task-outcome journal and the memory-provider tool fact_experience: emitted and candidate fact/version identifiers, an optional short task and correction, outcome/reason and optional corrected-source references. It is separate from trust, origin and ranking. Agent reports are not authenticated human confirmations. Collection and detailed tracing are off by default; retention is bounded to 30 days and 1000 attempts per store, with up to 10 revisions per attempt. Forgetting any referenced fact removes the dependent attempt and outcome from the store. No new model, network or credential use; synchronous local writes add latency. PR #45 also loads NumPy on first use outside the plugin-loader lock; concurrent first callers wait for import completion. Version 0.20.1 limits SQLite busy waits for the optional journal and retries transient contention once. Failed receipts are reported and are not queued; the SQLite timeout is not a full search deadline. Version 0.20.2 writes no receipt for a prefetch that emits nothing, applies journal retention whenever a writer opens the store (also with the journal off) and scrubs removed outcome text from the file like a forgotten fact. Version 0.20.3 adds one system-prompt line, only with the journal on, asking the agent to record an outcome when the person corrects an answer that used recalled facts (an agent report, not human confirmation). Version 0.21.0 adds an opt-in prefetch_max_tokens budget for the recalled block: facts that do not fit are left out whole, never cut; off by default. Version 0.22.0 keeps entity links honest on a text change: a new entities list replaces the declared names, and a declared name the new text no longer says is dropped; revert restores a version's declared names from an additive version_names table (names with keyed hashes, removed with the version and by delete_entity in every spelling a tombstone covers, including by older releases through triggers). Version 0.22.1 makes the secret/instruction screen about 30× faster on long texts with the same decisions (patterns unchanged; a prefilter chooses where they are tried). Version 0.22.2 sends a slow reranker only as many of the first candidates as its measured speed answers in half rerank_timeout (at least two), so a large pool no longer times out and pauses the endpoint; the candidates not sent keep their order behind the scored ones. Version 0.23.0 stops feedback (helpful/unhelpful) from refreshing a fact's age: optional temporal decay counts from when the current version was recorded, and updated_at changes only when the fact itself does; a correction with a new text (correct / update content) starts at its origin's trust without the old text's helpful marks, recalls and confirmations, like change, while a date-only correction keeps them and revert restores the old trust. Version 0.23.1 takes a correction that journal retention removed off the disk on the open connection (the file rewrite runs after the receipt write, with busy timeout 0 at every step) and clears only the rewrite mark it served. Version 0.24.0 adds two experimental features, both off by default and with no new network, model or credential use: memory_map.py, a command-line exporter nothing in the provider calls, which prints one store as a read-only JSON snapshot for a person to read (opened mode=ro in one read transaction; a forgotten fact is its id and date only; corrected versions and texts the safety screen hides carry no text; with --config it reads config.yaml's search settings, with --hermes-home the hermes-dreaming files about the profile store), whose output holds the facts' texts and so is personal data; and prefetch_clause_coverage: on, which gives each of two separate Russian or English questions in one message a second look at the facts the coverage gate left out. Version 0.25.0 limits the memory map export to 1000 facts and 300 names by default (--max-facts / --max-entities, 0 for none) and says what it cut in SNAP.limits; nothing else changes. Version 0.25.1 fixes recall by meaning dropping a fact that names a short Russian name in another grammatical case than the message (Eva as «Ева» / «Еву»): the name now also meets a capitalized word of the fact that may be a case form of it. Version 0.25.2 reads that word by its case ending rather than a short stem: names whose stem changes meet their forms («Лев» / «Льва»), and different names that only shared a short stem («Аня» / «Анна») no longer meet; nothing else changes. Version 0.25.3 no longer imports NumPy when the provider starts (the first search that needs it does, as does opening a store whose vectors need re-encoding) and treats a NumPy that is installed but fails to import as missing, so recall goes on by words; finds a Latin word written into Chinese, Japanese, Korean or Thai text by itself; refuses at write, and leaves out of recall, a prompt addressed to an assistant and the agent's report of its own steps; and auto_extract (off by default) no longer stores a reply such as "I like that" as a preference; no change to defaults, schema or network behaviour. Version 0.26.0 adds an experimental presence gate, prefetch_presence_gate (off by default): with it on, a fact this provider injected is held back past the six-turn repeat window only while the model can verifiably still see it (its exact recall line inside a <memory-context> block the core fenced, or its fact id and text in a fact_store result), reading only the messages the core already passes to sync_turn, with no new storage, network, model or credential use; tool results now carry raw Unicode instead of Unicode escape sequences (a payload that cannot be encoded keeps the escaped form); change names the keywords it drops and correct writes the keywords it is given; with the gate off, recall is unchanged. Version 0.26.1 fixes that gate after an independent review: a sync the core queued before a compaction no longer counts as the current view, a fact the compaction removed is recalled again once a fresh view no longer shows it, a compaction that fails no longer switches the gate off for the session, a late sync keeps its own turn, and a fact_store history result counts as the fact being visible; with the gate off nothing changes. Version 0.26.2: with the task-outcome journal on (off by default), a prefetch that only refreshes facts the session already holds records no new attempt and carries no Memory attempt line, so a repeated block adds nothing new to the context. Version 0.26.3: with the journal and the presence gate on, a delivery whose attempt could not be written after a compaction no longer stops that fact from recording attempts later. Version 0.26.4 fixes the presence gate after a second independent review: two late syncs in a row each keep their own turn, a quiet session that compacted leaves no lasting state, and a refresh no longer keeps token-budget room for an attempt line it does not carry. Version 0.26.5 fixes four edge cases found in a third review of the presence gate and the journal (both off by default): a long pasted message keeps its turn, a session the provider forgot drops its turns' messages, a failed attempt write drops only receipts older than the last compaction, and the token budget no longer keeps room for an attempt line in a block that became a refresh. Version 0.26.6 loads numpy's OpenBLAS on one thread on Windows when the plugin is what imports numpy, which saves about 225 MB of commit charge per Hermes process on an 8-thread machine. Version 0.27.0 adds French auto-extraction of stated preferences and shared decisions, and an optional one-hop memory graph over the entity index that reaches facts next to the ones a query names (bounded reads, off by default). Version 0.28.0 links a wiki pointer line (Wiki page: namespace/.../slug.md) to its namespace and page slug as entities, and recall before a turn searches only what the person wrote: a reply's quoted message, attachment notes, the author's name prefix in shared chats and the cron hint are left out, and a notice of finished background work recalls nothing. Version 0.29.0 records in the optional task-outcome journal (with experience_trace on) one word for why the reranker did or did not order a recall, never error text or facts, and adds measurement tooling; no change to defaults, schema or network behaviour. Version 0.29.1 refuses a fact id that is not a whole number (a JSON true or 1.9 acted on fact #1, and forget erased it) and restores the connection's own SQLite busy timeout after the recall-count flush; no change to defaults, schema or network behaviour. Version 0.29.2 refuses a trust change, trust floor or limit that is no number (a JSON true or "nan" in trust_delta set a fact's trust to the top, and min_trust: true made search and list answer nothing); no change to defaults, schema or network behaviour.Communitymemory42itpartypattayahermes-cronOperating skill for Hermes cron: lifecycle rules (pause vs disable vs remove, in 30m vs 30m), four ways to avoid needless LLM runs (no_agent, wakeAgent pre-check, monitor, [SILENT]), verify-after-change, a layered runbook and a read-only doctor that complements hermes cron doctor and reports one error across several jobs as one scheduler fault and a cron store that cannot be written. Portable Agent Plugins v1 package (plugin.json + skills/); no tools, hooks, middleware or env vars. Disclosure — skill only, no network; the bundled doctor reads ~/.hermes/cron/jobs.json, ticker stamps and executions.db (or a named profile's store with --profile) read-only, checks the cron directory's permissions and free space without writing, and runs the local hermes cron doctor (argument list, no shell), whose job loader may repair malformed jobs.json entries (--no-builtin skips it).Communityautomation6itpartypattayahermes-field-notesField notes for a Hermes install: search known pitfalls before debugging and record new ones with root cause; register every local core edit as a patch note with a declarative checks file, then verify read-only after each hermes update (OK / MISSING / UPSTREAMED / N/A / UNKNOWN with reason) and list core files changed outside the registry. Ships 42 pitfalls and 10 patch recipes checked against 0.22.0. Optional pinned Telegram dashboard edited in place by an hourly no_agent cron job. Portable Agent Plugins v1 package (plugin.json + skills/); no tools, hooks, middleware or env vars; never edits the core or runs patch scripts. Disclosure — its scripts only read the Hermes core (pyproject.toml, read-only git status/diff) and never edit it or run patch scripts; the skill does walk the agent through hand-editing core files from its patch recipes and re-running the owner's re-apply scripts, each only after the user says yes. Network: Telegram Bot API only when the dashboard is enabled (reuses the agent's TELEGRAM_BOT_TOKEN from env or ~/.hermes/.env), and the public GitHub API without credentials (latest release plus compare against the installed commit SHA, cached 12 h; upstream.check=false disables). Writes: the notes store (~/.hermes/field-notes), ~/.hermes/field-notes.json, state and lock files in ~/.hermes/cache, a copy of the cron script in ~/.hermes/scripts when install.py runs (the skill runs it on first use), and one hourly no_agent cron job only when the user runs install_cron.py (it reads ~/.hermes/installs/*/facts.json to find Hermes' own Python and re-runs itself with it). Without a dashboard chat, install_cron.py sends the job's alerts to the Telegram home channel when TELEGRAM_HOME_CHANNEL is set (read from env or ~/.hermes/.env), else local.Communitytools2

Developer Mode

Explore built-in Hermes toolsets and actions.

HermesAgent

Developer?

Create a Hermes extension for Desktop or agent workflows.

Developer Section