LCM-X replaces one-shot compression in Hermes Agent with a SQLite-backed, DAG-based context engine. The live prompt stays small, every raw message is preserved, and the agent can recover exact detail long after compaction.
git clone https://github.com/electricsheephq/lcm-xSet up OAuth2 for the dashboard, we're on Next 15.
Installed the client and wired the callback route through the app router.
CORS is failing on the token exchange.
Fixed via redirect URI config; tokens now persist.
CORS is failing on the token exchange.
Fixed via redirect URI config; tokens now persist.
A conventional agent holds the whole conversation inside one token budget. Every user message and every tool result eats space — and the budget must keep headroom for the model to write a summary once it runs out.
Around 80% of the budget the system stops and batches as much history as it can into a single summarization call. The conversation blocks while it runs.
Ten turns collapse into a paragraph. Space is reclaimed, but nothing points back at what was dropped. The agent will misremember specifics, contradict decisions it already made, and ask again for things it was already told.
LCM-X starts the same way — messages accumulating in a budget — but nothing is ever thrown away. Raw messages are persisted in a local SQLite store before anything is compacted.
The most recent raw messages are never compacted. Everything older becomes eligible. The tail is four turns here; in real use it is much larger.
When eligible messages outside the fresh tail cross the threshold, compaction fires asynchronously — the conversation is never interrupted. Because the source rows still exist, compaction is always safe.
The chunk becomes a depth-0 node. It replaces those messages in the active prompt, but it keeps references to every source row — so it can be expanded back to the exact original text on demand.
New turns arrive, the tail advances, another cohort ages out, another pass fires. Depth-0 nodes accumulate — each one a dense slice of the conversation with a full source trail behind it.
Once enough nodes pile up at the same depth, LCM condenses them. Four depth-0 summaries are synthesized into one depth-1 node: more abstract, more durable, covering the whole arc.
Each level runs a different prompt. D0 keeps exact decisions and technical detail. D1 distills the arc — outcomes, what changed, current state. D2 writes a durable narrative that stays useful for weeks.
Sixty-four turns in, the active prompt is still small — and not one message has been discarded. The DAG holds minutes at D0, hours at D1, days at D2, weeks above that.
Before spending a single token on expansion, the agent inspects a node: subtree token count, source token count, and a child manifest. Enough to plan a retrieval strategy.
Search every node in the DAG — raw rows and summaries alike, across all depths, literal or semantic. Results carry depth labels, so the agent knows whether a topic still lives in raw text or has been distilled upward.
When a summary isn't enough, the agent issues a scoped delegation grant — a conversation scope plus a token budget — and spawns a sub-agent to walk the DAG on its behalf.
The sub-agent explores a 20k-token subtree and spends under 800. It returns one focused answer. The main context is unchanged — but now holds exact detail from turn three of a sixty-four turn conversation.
Drop it into Hermes Agent and your prompts stay bounded while the history stays whole.
git clone https://github.com/electricsheephq/lcm-xHermes' built-in compressor prunes older tool results and rebuilds the prompt from a summary plus a recent tail. The session rows may still be searchable at the host level, but the model's active context loses both the verbatim turns and any structured path back to them. LCM-X makes recall part of the context engine itself.
Every raw message persisted with FTS metadata before a single token is compacted. The store is plugin-local and built for drill-down, not just archival.
Depth-aware nodes over compacted history. Each node keeps source lineage, so any summary can be walked back to the exact rows it came from.
Raw messages, child summaries and externalized payloads come back in pages — never as an unbounded dump into the active prompt.
Filter raw rows and summaries by descendant lineage, with explicit session-boundary rules.
Oversized tool, media and raw payloads are externalized behind stable refs, protecting SQLite from inline base64 blobs.
Optional named redaction of API keys, bearer tokens, passwords and private keys before LCM stores or summarizes anything.
Opt-in day, week and month rollups with natural-time recall through lcm_recent.
Embedding-backed semantic and hybrid grep modes, with free-tier cloud or fully local providers.
Three of them carry the story above. The other twelve cover search, expansion, evidence and store health.
Literal, semantic or hybrid search across raw rows and every summary depth.
Node manifest: subtree tokens, source tokens, children — before you spend.
Delegation grant plus a budgeted sub-agent that walks the DAG for you.
# the agent hits a summary and needs the exact wordingmanifest = await lcm_describe(node="sum_d2_01")# depth 2 · subtree 20,480 tok · 3 children hits = await lcm_grep("budget cap", mode="hybrid")# D0 sum_03 “…hard cap of $3,000, flights excluded…”# RAW turn_07 “…keep the total under 3k, seriously…” answer = await lcm_expand_query( query="original budget constraint", budget=4000)# spent 781 / 4,000 tok · main context delta +65 tokEvery retrieval starts with a manifest, so the agent knows the cost of an expansion before it pays for it. Recovery is paged and budgeted — never an unbounded dump back into the live prompt.
git clone https://github.com/electricsheephq/lcm-x \ ~/.hermes/plugins/hermes-lcm
hermes-lcm is discovered on next agent start.
./scripts/install.sh
Symlinks the plugin and verifies your Python runtime.