sibyl-memory-hermes 0.1.0

Hermes Agent memory provider — local-first, SQLite-backed, structured-tier memory for Hermes v0.10.0+.

sibyl-memory-hermes

Hermes Agent memory provider — local-first, SQLite-backed, structured-tier memory for Hermes v0.10.0+.

Drop-in memory for Hermes Agent (and any other Python agent framework). Memory content lives on the user's own machine — never on our cloud. Built on sibyl-memory-client, the underlying SDK.

pip install sibyl-memory-hermes

Quickstart

from sibyl_memory_hermes import SibylMemoryProvider
from hermes_agent import Agent

# Default: reads ~/.sibyl-memory/credentials.json (written by `sibyl init`)
# and opens ~/.sibyl-memory/memory.db
agent = Agent(memory=SibylMemoryProvider())

# Per-turn memory (Hermes contract):
agent.run("What did I work on yesterday?")
# → SibylMemoryProvider.save_context(inputs, outputs) lands in the journal

# Fact store:
agent.memory.remember(
    "project", "atlas",
    {"status": "active", "stage": "staging"}
)
agent.memory.recall("project", "atlas")

# Full-text search across all entities:
results = agent.memory.search("error budget")

Why "local-first"?

Mem0, Zep, Honcho, and every other agent-memory product centralize user context on their servers. Sibyl Memory keeps the data on the user's disk. The plugin schema has no memory-content tables in our cloud — even with admin database access we cannot read what users have written. That's the difference between "we promise we don't" and "we structurally can't."

	Sibyl Memory	Typical hosted memory
Memory content lives...	on user's disk	on vendor's servers
Query latency	local SQLite (sub-ms)	round-trip + vector search
Privacy claim	structurally enforced	policy-only
Free-tier cost to vendor	near-zero	scales with users

Architecture: five tiers, not one bucket

The provider routes operations onto the appropriate memory tier instead of dumping everything into a single vector store:

Intent	Tier	Storage call
save the conversation turn	COLD journal	save_context(inputs, outputs)
remember a fact	WARM entity	remember(category, name, body)
current state	HOT state	set_state(key, body)
lookup a runbook	REFERENCE	set_reference(key, body)
archive stale entity	ARCHIVE	archive(category, name)
search by content	FTS5	search(query)

Different intents, different lookups, no embedding model required. FTS5 covers full-text search out of the box.

Hermes contract

If Hermes v0.10.0+ is installed, SibylMemoryProvider inherits Hermes' MemoryProvider ABC at import time so framework-level isinstance checks pass. The contract methods:

• save_context(inputs, outputs) → journal append
• load_context(limit) → recent turns
• clear_context() → no-op (journal is append-only by design)

If Hermes isn't installed, the provider still works standalone — any framework that calls these methods directly works.

Activation

Most users get here via the sibyl init CLI (from the sibyl-labs-cli package), which writes ~/.sibyl-memory/credentials.json after browser authentication. The provider auto-detects this file on construction.

For pre-activation use (e.g., in tests):

from sibyl_memory_hermes import SibylMemoryProvider

provider = SibylMemoryProvider(
    db_path="/tmp/test-memory.db",
    tenant_id="test-user",
)

Free tier

• 10 MB local soft cap (gentle prompt — not a hard wall)
• Single device
• All five tiers (HOT/WARM/COLD/REFERENCE/ARCHIVE)
• FTS5 full-text search
• Multi-tenant isolation

Paid tiers (Sync, Lifetime, Stake, Enterprise) add cross-device encrypted blob sync, team features, and self-host options. See sibyllabs.org/plugin.

License

MIT. Source: github.com/sibyllabs/sibyl-memory-hermes.

Citation

Sibyl Memory currently holds #2 globally on the LongMemEval Oracle benchmark. The benchmark methodology and report are at blog.sibylcap.com/longmemeval-v2.