DSH Memory: dsh-memento vs MemoryRouter

The harness ships with no memory plugin of its own, and its extension points invite plugins to fill that gap. dsh-memento takes the strictest posture available: every write waits for your approval, every change leaves an audit record, and the store is one SQLite file on your machine with zero network access. MemoryRouter takes the opposite posture. Clean exchanges are captured automatically, and the vault they land in is hosted, so the memory answers on every surface you connect.

Both stop a fresh session from opening blank. What separates them is where the record lives and what it takes to write to it.

The memento plugin

One command into a profile, then restart the harness:

dsh plugin --profile web add dsh-memento

The design is a typed memory service, and the approval gate is enforced inside that service rather than in the tool layer, so a model cannot route around it. The default write policy is ask, with auto and off available; a denied write still leaves an audit row, and every accepted write can be reconstructed from the approval pair plus the plugin's own audit table.

Storage is local: $DSH_HOME/dsh-memento/memory.db, file mode 0600, zero network, zero credentials. Entries live in two tracks, one for facts about you and one for environment facts and conventions, split across user-global and workspace layers and isolated per agent preset. The snapshot injected into the prompt freezes at the first assembly of a session and does not change while the session runs. Budgets are hard, 2,000 characters per layer for the user track and 4,000 per layer for the agent track, and a full store returns a structured error instead of truncating silently.

The surface area is real: a /memory command covering list, query, add, remove, consolidate, proposals, budgets, audit, export, and import; a read-only web panel; and a read-only stdio MCP server (dsh-memento-mcp) so outside clients can search the same store. The limits are documented too: search is case-insensitive substring rather than full-text, the ask policy needs an answerer or writes fail closed, and the session-log half of the audit is declared but not yet emitted by the harness.

Details come from the memento repository and its npm page, read October 15, 2026.

The MemoryRouter plugin

Two steps into a profile:

dsh plugin --profile web add dsh-memoryrouter

Then give it your key. The plugin reads apiKey from the profile's config or falls back to the MEMORYROUTER_API_KEY environment variable; with neither set it warns once and does nothing else; the harness never goes down over it.

The plugin hooks two points beneath the channel plugins. Each completed turn sends the user message and the model's final reply to your vault. When a new turn opens with real human text, relevant memories come back as one delimited block, marked plugin-sourced so storage never re-ingests its own recaps. Tool output, thinking blocks, system prompts, and commands never reach the store. Store runs asynchronously with one retry and never delays a turn; recall is capped at 2.5 seconds and degrades silently, costing context rather than the turn.

The placement is the point. Something you settle in the Web UI follows you into a Telegram session. The vault also reaches past the harness: point your other tools at it and they draw on the same record, from Claude Code and Codex to the editors over MCP and the chat connectors (Claude and ChatGPT). The vault is hosted, so the review boundary from the earlier walkthrough still applies to what you send. Setup details and the full option table are in the dsh docs and on the DeepSeek Harness page.

The case for memento

Locality comes first. Nothing leaves the box: no network, no credentials, one file on your disk. If a policy forbids data leaving the machine, this design satisfies it without debate.

The gate comes second. Writes become decisions, and the audit trail can answer what the agent knew and when it learned it. Anyone running agents under review gets an artifact they can hand to someone else.

And it costs nothing. Apache-2.0, no account, nothing external in the path.

The split that decides it

Two differences carry most of the weight.

The write path. memento stores what survived an approval, so the store is a set of entries someone signed for. MemoryRouter keeps the exchange and moves the judgment to retrieval, with reflections sitting above the raw record so the reasoning stays next to the decision. One design asks you to curate at write time. The other asks you to choose a capture boundary you trust.

Where the record can answer from. memento's store serves the machine it sits on and the sessions running there. The vault is reachable from any channel and any machine running the harness on the same key, plus every other tool you have connected. If your work lives on one box and one surface, locality is the feature you want. If you work from a phone as often as a desk, run headless jobs elsewhere, and expect your editor to know what the harness already settled, only one of these travels.

Costs and what they buy

memento is free and open source. If budget is the constraint, the comparison is over.

MemoryRouter runs $20 a month from the fifteenth day, 200M memory tokens included; extra usage is $0.50 per 1M. Your model providers stay yours, and nothing about inference is repriced.

Where to land

One machine, one harness, writes that need your sign-off: run memento.

Several channels, several machines, or several tools sharing one memory: Start your vault and let the next dsh session open with today's decisions already in it.