{"slug": "push-vs-pull-agent-memory", "title": "Push vs. Pull Agent Memory?", "summary": "Recall, a new open-source memory substrate for AI agents, introduces a push-based memory model where agents automatically check, update, and supersede facts without manual queries. The tool runs locally on SQLite, requires no cloud or server, and supports CLI, MCP, and TUI interfaces. It aims to give developers full control over agent memory with built-in provenance, confidence scoring, and rollback capabilities.", "body_md": "**The memory layer your agent just uses. It remembers, corrects itself, and recalls across sessions on its own. Local, free, and yours.**\n\n[Install](#install) ·\n[Quickstart](#the-60-second-tour) ·\n[Demo](#demo) ·\n[Agents & MCP](#hook-up-your-agent) ·\n[How it works](#how-it-works) ·\n[Why Recall](#why-recall) ·\n[Compare](#how-recall-compares) ·\n[Teams](#one-graph-many-writers) ·\n[Checker, Solver & Lattice](#beyond-memory-checker-solver-and-lattice) ·\n[Docs](/H-XX-D/recall-memory-substrate/blob/main/docs/README.md) ·\n[Roadmap](/H-XX-D/recall-memory-substrate/blob/main/ROADMAP.md)\n\n**Most agent memory is pull: a store you query.** You ask, it returns the\nclosest matches, and it is on you to notice when a fact has gone stale. Recall\nis\n\n*push*: the agent and the substrate run a loop together. It checks what it already knows before it acts, does the work, and writes back what it learned,\n\n*superseding*the old fact when something changes and surfacing the contradiction without being asked. No reminding it to save, no separate cloud service mining your transcript after the fact. Under the hood an LLM proposes a structured write, an admission firewall validates it, and the compiler returns only the relevant subgraph, ranked by evidence, fit to a word budget, all in local SQLite: no server, no account, no cloud. The memory is yours, and every fact still carries provenance, confidence, and a one-command undo.\n\nOne installable Node.js tool: CLI, read-only TUI, MCP server, quiet maintenance daemon, strict write schema, semantic search, encrypted secrets side graph, and a reproducible benchmark harness.\n\n```\nnpm install -g github:H-XX-D/recall-memory-substrate\n```\n\nOr use the installer script, which clones, builds, and links `recall`\n\n+\n`recall-mcp`\n\n:\n\n```\ncurl -fsSL https://raw.githubusercontent.com/H-XX-D/recall-memory-substrate/main/scripts/install.sh | bash\n```\n\nRequires Node.js 24+. Recall uses Node's built-in SQLite, so there is no\ndatabase server, no native build step, no account, and no network\ndependency. CI runs the core suite on Linux, macOS, and Windows, plus a\nreadiness lane for MCP smoke, Python hooks/toolkit checks, public benchmarks,\nand installer validation. Upgrades, uninstall, and troubleshooting:\n[Installation Guide](/H-XX-D/recall-memory-substrate/blob/main/docs/11_INSTALLATION.md).\n\nThe installer above already wires up any agent CLI it finds. To do it yourself (or after installing a new agent), one idempotent command sets up the skill, the MCP server, the consult-Recall hook, and makes Recall the durable memory layer:\n\n```\nrecall claude sync     # Claude Code: skill + MCP + SessionStart hook; turns OFF native auto-memory\nrecall codex sync      # OpenAI Codex:  skill + MCP in config.toml + a Recall directive in AGENTS.md\nrecall claude status   # confirm what's wired   (recall codex status for Codex)\n```\n\nRestart your agent and it's armed: it reads memory before relying on\nrecollection and writes durable findings back on its own; you never tell it to\n\"save.\" Both syncs back up your config before editing, are safe to re-run, and\nare reversible (`recall claude enable-auto-memory`\n\n). Using a different MCP\nclient? See [hook up your agent](#hook-up-your-agent).\n\n```\nrecall version    # confirm the installed package version\nrecall init       # create the local graph in ./.recall\nrecall status     # store health, counts, config\n```\n\nMemory enters as structured, schema-validated proposals. Normally your\nagent submits these over MCP ([see below](#hook-up-your-agent)), but the\nsame path works from the shell:\n\n```\nrecall admit --json decision.json   # validated, provenance-stamped, rollbackable\n```\n\nIt comes back as a compiled context packet, not a dump of the store:\n\n```\nrecall compile \"prepare the auth service deploy\" --words 220\nobjective:\nprepare the auth service deploy\n\ncompiler_state:\n- retrieval=fts5-bm25; query=\"prepare the auth service deploy\"; selected_cells=3; budget_words=220\n- health=beliefs:0, contradictions:0, stale_or_low_trust:0, critical_warnings:0\n\nrelevant_memory:\n- Cap the Postgres pool at 20 connections: Staging fell over at 35 concurrent\n  connections during the load test on June 3. Capped pool_size at 20 in service\n  config; raising it requires a load test sign-off. [decision:07fbbfd9-…]\n\nrisks:\n- Auth tokens expire but never rotate: Access tokens have 24h expiry but no\n  rotation path; a leaked token stays valid until expiry. [risk:1cb991a1-…]\n\ntasks:\n- Add a smoke check for the new rate limiter: The rate limiter shipped behind a\n  flag; nobody has verified the 429 path end to end. [task:8bddbb07-…]\n\nexpansion_handles:\n- 07fbbfd9-…  1cb991a1-…  8bddbb07-…\n```\n\nA packet holds ranked evidence, open risks and tasks, contradiction warnings when they exist, and expansion handles for drilling into any cell, all under a hard word budget. You can browse the graph at any time:\n\n```\nrecall tui                          # read-only terminal dashboard\nrecall search \"rate limiter\"        # FTS5 + BM25 lexical search\nrecall semantic \"token rotation\"    # semantic search (hash or real embeddings)\n```\n\nEvery cell also carries an **effective confidence** next to the author's\nimmutable stated confidence. It is recomputed on every read from incoming\nsupports, challenges, and the writer's contradiction record. Write one\ncontradiction and the number moves:\n\n```\n# before: the pool-cap decision stands alone\ndecision:6eba1114…  state=active/conf:0.7/eff:0.7/…\n\n# after: one cell contradicts it (nothing deleted, no model ran)\ndecision:6eba1114…  state=active/conf:0.7/eff:0.29(challenged)/…\n```\n\nChallenged cells sink in ranking, supported cells hold, and writers with a record of overconfidence get discounted. All of it is deterministic and runs offline.\n\nRuntime state stays local and is git-ignored by default:\n\n```\n.recall/recall.sqlite3      # primary graph\n.recall/secrets.sqlite3     # encrypted secrets side graph\n```\n\nBack up or move a graph with the portable archive path:\n\n```\nrecall export > recall-export.json\nrecall import --json recall-export.json --db .recall/restored.sqlite3\n```\n\nUndo a bad write through the rollback journal:\n\n```\nrecall rollback list\nrecall rollback show <journal-id>\nrecall rollback apply <journal-id>\n```\n\nSee [Backup And Recovery](/H-XX-D/recall-memory-substrate/blob/main/docs/20_BACKUP_AND_RECOVERY.md) for the full\nrestore path, including file-level SQLite copies and upgrade safety.\n\n**Change your mind without losing the past.** Recall's moat is supersession: a\ncorrection is never an overwrite. You admit a new cell that `--contradicts`\n\nthe\nold one, and every future read *demotes* the superseded value instead of deleting\nit; the conflict resolves automatically, at read time.\n\n▶ Click the frame (or open [ assets/recall-supersede-demo.mp4](/H-XX-D/recall-memory-substrate/blob/main/assets/recall-supersede-demo.mp4))\nfor a ~17s screencast, a real, unedited\n\n`recall`\n\nrun::`v1`\n\n*\"Cache TTL is 60s\"*lands at full strength (`eff:0.70`\n\n).:`v2 --contradicts v1`\n\n*\"…is 300s.\"*Read it back and`compile`\n\ndoesn't return both as equals:`v1`\n\nis demoted to`eff:0.29(challenged)`\n\n,`v2`\n\nstays high. The old value is still in the graph: preserved, queryable, just down-weighted.: a 3-link chain.`v3 --contradicts v2`\n\n`v1`\n\nand`v2`\n\ncollapse to`eff:0`\n\n; exactly one live answer remains, the*why-we-changed*trail intact.- The run asserts a tripwire: the real graph was untouched (\n`334 → 334`\n\n, a throwaway db).\n\nDemotion-not-deletion is the line between memory that merely *persists* and\nmemory that stays *honest*, the whole point of Recall over a flat note file.\n\nEvery Recall capability has a short, honest screencast: real CLI, real output,\nan isolated graph, with the full script and the unedited transcript beside\neach clip. Browse them all in the [companion gallery](https://h-xx-d.github.io/recall-demos/).\n\n| Screencast | What it shows |\n|---|---|\nInstall in one command |\n`recall claude sync` / `recall codex sync` wires the skill, MCP, and consult-Recall hook, and turns off native note-memory |\n|\nthree `claude` sessions, natural prompts, nobody says \"save\"; persist → supersede → cold-session recall |\nSupersession mechanics (the clip above) |\nthe `contradicts` edge, read-time demotion, multi-link chains |\nRollback a write |\njournaled, reversible undo; archives the node, strips its relations |\nInception |\ngrounded idea synthesis: a new hypothesis pre-linked (`depends_on` ) to its sources |\nEffective confidence |\nstated vs graph-computed trust, recomputed on every read |\nCompile |\nids-first context packets; expand a cell or single field only when needed |\nRetrieval |\nFTS5 + BM25 with porter stemming and identifier-aware tokenization |\nSubgraph |\nslice the graph by structured facets (tags), not just search |\nMemory health |\n`recall beliefs` / `recall maintenance --derive` audits between turns |\nCalibration |\nper-actor Brier scores; memory that learns who to trust |\nWatch programs |\na non-LLM monitor that trips when the graph turns against a belief |\nSecrets |\nfirewall refuses credential shapes; real secrets go in the encrypted side graph |\nDiff-aware resume |\nwhat's new, updated, and retracted since you left |\n\nRoutine memory is agent-managed through MCP. Users should not have to hand-save ordinary observations, decisions, risks, or tasks.\n\n```\nrecall mcp config --db .recall/recall.sqlite3   # print an MCP config block\nrecall-mcp                                       # start the stdio MCP server\n```\n\nPaste the config block into any MCP-capable client (Claude Code, desktop\napps, agent runtimes), then add the\n[LLM System Prompt](/H-XX-D/recall-memory-substrate/blob/main/docs/LLM_SYSTEM_PROMPT.md) to your agent's\ninstructions. The agent's loop becomes: compile, work, write back.\n\n| Tool | Purpose |\n|---|---|\n`recall_compile` |\nCompile a compact context packet for a task. Start here |\n`recall_write` |\nSubmit a strict, evidence-aware memory proposal |\n`recall_search` / `recall_semantic` |\nRetrieve graph evidence by exact or semantic match |\n`recall_subgraph` |\nCompose subgraphs from structured tags |\n`recall_daemon_run_once` |\nRun one outside-the-LLM maintenance pass |\n\nThere are 42 MCP tools in total, covering status, hyperedges, programs,\nDAGs, evals, ACP agent coordination, and calibration. The\n[LLM Integration Guide](/H-XX-D/recall-memory-substrate/blob/main/docs/LLM_INTEGRATION.md) is the full operating\ncontract, including the proposal shape.\n\nThe repo ships a Claude Code slash command at\n[ .claude/commands/recall.md](/H-XX-D/recall-memory-substrate/blob/main/.claude/commands/recall.md). Copy it into your\nown project, or make it global, and\n\n`/recall`\n\nbecomes a one-word way to wire a\nsession to Recall:\n\n```\n# global (available in every project):\nmkdir -p ~/.claude/commands && cp .claude/commands/recall.md ~/.claude/commands/\n\n# or per-project:\ncp .claude/commands/recall.md /path/to/your/project/.claude/commands/\n```\n\nAfter the one-time MCP setup above, typing `/recall`\n\nresolves your store\n(`RECALL_DB`\n\nif set, otherwise the local `.recall/recall.sqlite3`\n\n), ensures it\nexists, compiles a context packet for what you are about to do, and hands the\nagent the compile, work, write-back loop. No schema to manage, no setup to\nrepeat. `/recall <topic>`\n\ncompiles for that topic; bare `/recall`\n\norients on\nrecent state. If your memory already lives in a shared or global store, export\n`RECALL_DB`\n\nso `/recall`\n\ntargets it instead of minting an empty local db.\n\nThe MCP-config-and-system-prompt setup above is also available as a single\nidempotent command per agent runtime. `scripts/install.sh`\n\nruns these\nautomatically (fail-soft) when the corresponding CLI is present, and you can\nre-run them anytime to refresh to the latest bundled version:\n\n```\nrecall claude sync     # Claude Code\nrecall codex sync      # OpenAI Codex\nrecall claude status   # report which pieces are installed (codex status likewise)\n```\n\n**Claude Code** (`recall claude sync`\n\n) installs a SessionStart/UserPromptSubmit\nhook that nudges the agent to consult Recall, copies the recall skill into\n`~/.claude/skills/`\n\n, registers the recall MCP server in `~/.claude.json`\n\n, and\nsets `CLAUDE_CODE_DISABLE_AUTO_MEMORY=1`\n\nso Recall is the durable memory layer\ninstead of Claude Code's built-in note memory (keep native auto-memory with\n`RECALL_KEEP_AUTOMEMORY=1`\n\n; revert with `recall claude enable-auto-memory`\n\n).\nAlready accumulated native auto-memory? `recall import auto-memory [--root path] [--project name] [--apply] [--db path]`\n\nimports your\n`~/.claude/projects/<slug>/memory/*.md`\n\nfiles into Recall as calibrated cells\n(dry-run by default; pass `--apply`\n\nto write). It is idempotent per file content,\nand a changed file supersedes its prior version via a `contradicts`\n\nedge, the\nmigration wedge for owning your memory.\n\n**Codex** (`recall codex sync`\n\n) copies the recall skill into\n`~/.codex/skills/`\n\n, registers the recall MCP server under `[mcp_servers.recall]`\n\nin `~/.codex/config.toml`\n\n, and injects a marker-delimited Recall directive into\n`~/.codex/AGENTS.md`\n\n, Codex's always-read global instructions, the analog of\nClaude Code's SessionStart hook. Codex exposes no native-memory kill switch, so\nRecall is positioned as the durable memory layer at the prompt level via that\ndirective. All edits are backed up before write, preserve your existing config,\nand are idempotent.\n\n**Propose.** The LLM submits a`recall.write.v1`\n\nproposal with content, evidence, confidence, provenance, and structured tags.**Admit.** Admission validates the schema, applies firewall checks, attenuates unsupported claims, warns on near-duplicates, blocks secret-looking content, and journals a rollback entry.**Store.** Memory persists as addressable cells and n-ary hyperedges in SQLite, reachable by address, tag, relation, or semantic search.**Compile.** The compiler builds a compact, task-specific packet under a word budget, listing each cell's challengers alongside it and computing each cell's effective confidence from the live graph.**Maintain.** A quiet daemon runs stale-memory, contradiction, derivation, and eval passes outside the LLM, writing back through the same admission path as everyone else.\n\nThe base structure is a hypernetwork. DAGs are optional overlays for ordered workflows, evidence chains, and execution traces.\n\nHyperedges can also carry programs: declared, versioned, sandboxed\noperations (`recall.program.v1`\n\n) that run on demand. Bind a decision to its\nrisks and verifications and the bundle can score itself. Because the score\nreads live effective confidence, it works as a tripwire:\n\n```\nrecall program run <program-id>     # Friday deploy gate\n  → averageEffectiveConfidence: 0.7, score: 0.827\n\n# new evidence contradicts the load-test verification\n\nrecall program run <program-id>     # same gate, no model ran\n  → averageEffectiveConfidence: 0.322, score: 0.638\n\nrecall program run <program-id> --derive\n  → derives a witness cell, filed through the same admission gate as any\n    other write\n```\n\nOther memory systems store relations as passive records that only an\nexternal model can act on. Here, a deploy gate's score falls on its own\nwhen any member is contradicted, whether by a teammate, another agent, or\na failing test wired in through `test-contradicts`\n\nedges. See\n[Advanced Graph Operations](/H-XX-D/recall-memory-substrate/blob/main/docs/06_ADVANCED_GRAPH_OPERATIONS.md).\n\nThe `watch`\n\noperation turns a bundle into a standing reflex. It baselines\nagainst its own previous run (run history is the state, so no extra\nmachinery is needed), trips when the bundle's live effective confidence\nmoves more than `delta`\n\n, and derives nothing otherwise. A quiet watch\nmeans the value was checked and had not moved.\n\n```\nrecall program add <hyperedge-id> --json watch.json\n  # { \"schemaVersion\": \"recall.program.v1\", \"operation\": \"watch\",\n  #   \"params\": { \"delta\": 0.15, \"concernTarget\": \"<decision-cell-id>\" } }\n\nrecall program run <program-id> --derive\n  → untripped: derives nothing\n  → tripped:   files a concern against the target decision, through the\n               same admission gate as every other write, attributed to\n               program:<id>\n```\n\nA tripped watch does not modify its target. It files a concern through\nadmission like any other writer, which means reflexes carry `produced_by`\n\nand accumulate a calibration record. A watcher whose concerns keep getting\nrefuted gets discounted by the same loop that scores humans and LLMs.\nWatches can chain: a verification collapses, its watcher files a concern\non the decision built on it, that decision's effective confidence falls,\nand a watcher on the decision can fire next. Run a watch from cron and a\nstanding decision becomes a monitored service.\n\nTwo more operations round out the set:\n\n`drift`\n\nis watch with attribution. A tripped run names which member moved (`topMover`\n\n, plus a ranked`movers`\n\nlist), so you can see what caused a gate to fall.`quorum`\n\nis k-of-m sign-off as a graph object. A member counts as an approval when its live effective confidence clears`minEff`\n\n, counted across distinct actors so one writer cannot stack the gate. If an approver's cell is later contradicted, its effective confidence drops and the approval stops counting, with no policy code involved. Quorum runs always derive their attestation.\n\nCompile packets carry a `standing_programs`\n\nsection listing the gates,\nwatches, and quorums covering each returned cell, with program and bundle\nhandles, so an agent writing new evidence can tie it into the existing\nbundle instead of orphaning it. Deeper concepts live in the\n[docs](/H-XX-D/recall-memory-substrate/blob/main/docs/README.md): the [write schema](/H-XX-D/recall-memory-substrate/blob/main/docs/02_WRITE_SCHEMA.md),\n[tagging & subgraphs](/H-XX-D/recall-memory-substrate/blob/main/docs/03_TAGGING_AND_SUBGRAPHS.md), the\n[context compiler](/H-XX-D/recall-memory-substrate/blob/main/docs/04_CONTEXT_COMPILER.md), and\n[cells & graph views](/H-XX-D/recall-memory-substrate/blob/main/docs/14_ADDRESSABLE_CELLS_AND_GRAPH_VIEWS.md).\n\n`recall incept`\n\nis an experimental primitive for synthesis rather than\nretrieval. It compiles a slice of the graph for an open objective, then emits\na write-back template whose `depends_on`\n\nis pre-populated with the slice's\ncell ids. A model fills in the synthesis (a method, a connection, an insight\nimplied by a contradiction between cells) and admits it. Because the template\nis pre-grounded, any cell created this way is born linked to the sources it was\nsynthesized from.\n\nThe generative step stays in the model on purpose. Recall gathers the slice,\nguarantees the grounding, and admits the result, but it does not synthesize,\nbecause putting a model in the runtime would break the no-model trust loop. The\nnew cell lands as a `hypothesis`\n\nat conservative confidence, marked unverified,\nso it enters the graph and earns or loses trust over time through the same\neffective-confidence machinery as any other write. The model synthesizes,\nRecall grounds it and lets the graph vet it.\n\n```\nrecall incept \"novel approaches given what we know about X and Y\"\n```\n\nRecall makes a few opinionated bets that most memory layers don't:\n\n| Most memory layers | Recall |\n|\n|---|---|---|\nTrust model |\nAppend text, trust later | Every write passes an admission firewall: schema-validated, provenance-stamped, rollbackable |\nWhat returns to the model |\nThe whole store, or a top-k blob | A compiled context packet: the relevant subgraph, ranked by evidence, fit to a word budget |\nStructure |\nFlat notes or a single knowledge graph | Addressable cells plus n-ary hyperedges, with optional DAG overlays for ordered work |\nWhere it lives |\nA cloud service you send data to | Local-first. SQLite on your machine. No account, no network required |\nSecrets |\nMixed into the same store | A separate encrypted side graph, opt-in, never in the primary graph |\nMistakes |\nOverwrite and move on | Rollback instead of overwrite: supersede by relation, keep the audit trail |\nMaintenance |\nManual curation, or none | A quiet daemon runs stale-memory, contradiction, and derivation passes outside the LLM |\nCalibration |\nConfidence is decoration | Closed-loop calibration: each actor's stated confidence is scored against survived contradictions |\nConfidence |\nA static number typed once | A living number: effective confidence is recomputed from supports, challenges, and the writer's track record on every read, with no LLM in the loop |\n\nThe common thread is auditability: provenance on every cell, a firewall on every write, and a packet you can actually read.\n\nThe main design split in agent memory is how trust changes when new information arrives. The field has three mechanisms:\n\n| Mechanism | Who uses it | What happens to a contested claim |\n|---|---|---|\n| A model decides | mem0, Zep, Letta, Hindsight | An LLM resolves the conflict at ingest, invalidates the fact, or rewrites beliefs. Opaque, non-reproducible, and the losing claim is often deleted |\n| The clock decides | decay-based systems | Importance fades on a forgetting curve whether or not any evidence arrived |\n| The evidence decides | Recall |\nEffective confidence is recomputed from typed supports, challenges, and the writer's contradiction record. Same graph, same number, every time |\n\nOther systems ask a model what to believe. Recall computes it.\n\nThe rest are architectural design properties, not benchmark claims. Pick the tool that matches how much you care about auditability and local control.\n\n| Property | Vector RAG | Knowledge-graph memory | Cloud memory APIs | Recall |\n|---|---|---|---|---|\n| Runs fully local, no account | sometimes | sometimes | ✗ | ✅ |\n| Structured write schema enforced | ✗ | partial | varies | ✅ |\n| Admission firewall on every write | ✗ | ✗ | varies | ✅ |\n| Provenance + rollback per write | ✗ | partial | varies | ✅ |\n| N-ary hyperedges (not just pairwise) | ✗ | rare | ✗ | ✅ |\n| Word-budgeted compiled context | ✗ | ✗ | partial | ✅ |\n| Encrypted, segregated secrets store | ✗ | ✗ | varies | ✅ |\n| Single runtime, one memory API | ✗ | varies | n/a | ✅ |\n| Trust evolves with no LLM in the loop | ✗ | ✗ | ✗ | ✅ |\n| Tiered reads over trust-annotated claims (title → peek → full cell) | ✗ | partial | partial | ✅ |\n\nTiered, agent-navigated retrieval is an emerging pattern across the field. Letta pages between memory tiers, and progressive-disclosure indexes are appearing elsewhere. Recall's difference is what sits at each tier: not auto-summaries of activity, but gate-vetted claims carrying live trust state, addressed in the same namespace the evidence machinery uses. The index layer tells the agent where digging is warranted, not just that it may dig.\n\nRecall trades turnkey cloud convenience for local control and an audit trail. If you want a hosted, batteries-included memory service, projects like mem0, Letta, and Zep are excellent. Recall is the other kind of tool: the graph lives on your disk, every write comes with a receipt, and nothing in it is above being challenged.\n\nMost memory layers assume one user and one assistant. Recall's write path\nwas built for traffic. Humans, agents, CI jobs, the daemon, and tripped\nreflexes all write through the same admission gate, so every cell lands\nschema-checked, attributed, timestamped, and rollbackable no matter who\nsent it. That is what makes a single project graph safe to share: when a\ndecision changes overnight, a teammate does not ask around in chat, they\ncompile. The packet says who changed it, when, on what evidence, and what\nit contradicts. Run `recall compile \"what changed since Friday\"`\n\non Monday\nmorning and the briefing writes itself.\n\nThe gate is also vendor-blind. A proposal from GPT, Claude, Gemini, or a\nlocal model is the same `recall.write.v1`\n\nJSON, judged by the same rules,\nlanding in the same graph. Calibration then scores every writer\nseparately, human or model, on one ledger. Route work to whichever model\nis cheap this month, and let track records rather than logos decide how\nmuch to trust what comes back.\n\nIt is tier-blind for the same reason. The write contract asks for discipline, not brilliance, so a small model can hold the same memory standards as a frontier one. And because the compile packet carries the team's accumulated judgment, including the calls, the risks, and the open contradictions, a cheap model starts its session with the same briefing an expensive one gets. The packet does the remembering so the model does not have to.\n\nStanding programs turn the shared graph into something a team can watch\nwithout opening a terminal. The fully actuated setup puts the store on a\nbox everyone can reach and lets the tripwires do the talking. Point the\nwhole team at one graph by setting `RECALL_DB`\n\nonce on the host: the CLI,\nthe MCP server, and the helper scripts all read it, so agents, cron jobs,\nand exporters route to the same store with no per-command flag (pass\n`--db`\n\nwhen you want to override it). Then let a scheduler run each\nstanding gate on a heartbeat. Every program run prints plain JSON, so it\nwires into whatever the room already watches with no integration to\ninstall:\n\n```\nexport RECALL_DB=/srv/recall/payments.sqlite3   # one graph, whole team\n\n# cron, every 10 min: trip the deploy gate, ping the channel\nrecall program run <watch-id> --derive \\\n  | jq -e '.run.output.tripped' >/dev/null &&\n  curl -s -X POST \"$SLACK_WEBHOOK\" -H 'content-type: application/json' \\\n    -d '{\"text\":\"Deploy gate tripped: the load-test verification moved.\"}'\n\n# run history is a time series of gate scores (createdAt + output.current).\n# An exporter scrapes it into Prometheus/Grafana, where alerting fires when\n# a gate's effective confidence crosses your threshold.\nrecall program runs --limit 200\n```\n\nA panel of gate scores is the project's live status, read straight off the trust graph: each score is its bundle's effective confidence, so the board shows at a glance what is currently believed, what is contested, and what just moved. The tripped run has already filed its concern in the graph through admission, so Slack and Grafana are only the echo into the room, not the source of truth.\n\nOne caveat, stated plainly: today \"shared\" means the writers are processes\non that one host. Team SSH sessions, CI jobs, agents running there, and the\ncron watchers all hit the same store over SQLite WAL, which handles the\nconcurrency. Putting the file on a network share for many separate machines\nto write is not safe, by SQLite's own guidance. One graph served over HTTP\nwith authenticated actor identity, so remote machines write without sharing\nthe host, is next on the [roadmap](/H-XX-D/recall-memory-substrate/blob/main/ROADMAP.md).\n\nRecall is the memory layer of a four-part system. The other three parts plug into the same graph through the same admission gate.\n\n**Checker** is the verification layer, built on one rule: absence of\nrefutation is not verification. It runs declared checks and stores honest\nverdicts (`verified`\n\n/ `refuted`\n\n/ `unverifiable`\n\n/ `error`\n\n/ `partial`\n\n)\nin a ledger, and its attestation is git-native: `verify-commit`\n\nrefuses\ndirty trees and non-HEAD SHAs, `gate --ref`\n\nanswers whether a specific\ncommit is verified, and a fail-closed pre-push hook gates pushes on that\nanswer. Checker emits typed `checker-supports`\n\nand `checker-contradicts`\n\nedges into the Recall graph, where they already count for more than peer\ntestimony in effective confidence, and compile packets surface checker\nchallenges on every affected cell. Verification is tied to an exact\ncommit on a clean tree, not to a claim that the tests passed at some\npoint.\n\n**Solver** is the compute layer: a library of 96 small, fast, gated\nsolvers spanning control theory, signal processing, estimation, and\noptimization. Kalman filtering, FIR/biquad, CORDIC, Goertzel, count-min\nsketches, matrix-free conjugate gradient, and an Ising/simulated-annealing\ntier that makes QUBO formulations practical where hand-rolled heuristics\nused to be the only affordable option. The CPU tier is plain C, the GPU\ntier is CUDA, and every solver is validated against a reference oracle\nbefore any speed number is trusted. Each solver carries an optimality\ncontract declaring what class of claim its answers make: exact,\ntolerance-bounded, or heuristic. Results land in Recall as addressable,\npriced claims. The division of labor: the model formulates, Lattice maps\nthe code, Solver computes, Recall remembers, Checker attests.\n\n**Lattice** is the code-analysis layer, and the one part that is an\nenterprise capability rather than open source: access-gated, vetted, and\nnot bundled in the OSS distribution. It ingests a codebase over the\nLanguage Server Protocol into the same typed hypernetwork Recall uses\n(symbols, modules, and the import, call, and reference edges between them),\nthen runs structural analyses over that graph. `impact`\n\nreturns a change's\nreverse-reachability blast radius *before* you edit; `hunt`\n\nranks\nstructural bugs, including cross-signal findings no single diagnostic\nshows, like an exported path that reaches unimplemented code; `diagnose`\n\nsurfaces cycles, dead code, stubs, and coupling hotspots in one pass;\n`plan`\n\nlays out the ordered, verify-gated steps to land a change; and\n`verify`\n\nis a differential gate that reports only the structural\nregressions a change *caused*, measured against a git ref in a throwaway\nworktree. A gated security-audit mode maps attack surface and\nsource-to-sink reachability for authorized review of your own code. Every\nfinding carries the same explicit `verified`\n\n/ `not_verified`\n\ncontract\nChecker enforces: reachability tells you where to look, never that a bug\nis proven.\n\nWhat sets it apart is where the findings go. Lattice grounds everything it\ncomputes: the hard combinatorial step (the minimum feedback arc set that\nbreaks a dependency cycle) routes to Solver's gated QUBO tier and is\nverified locally before it is trusted, and results land in Recall as\naddressable, evidence-weighted cells through the same admission gate as\nevery other write. A structural regression stops being a console warning\nthat scrolls away and becomes a cell with provenance that a deploy gate\ncan score and a teammate can compile tomorrow. It ships an MCP server\nbuilt for the agent edit loop (ask `impact`\n\nbefore an edit, gate with\n`hunt`\n\nafter), served in milliseconds off a graph ingested once and\ncached.\n\nTogether they cover memory, verification, computation, and code structure behind one write path, with no model in the loop.\n\n**Checker org capabilities, Solver access, and Lattice (enterprise):**\n[todd@hendrixxdesign.com](mailto:todd@hendrixxdesign.com)\n\n```\n# inspect\nrecall version\nrecall status\nrecall tui [--watch]\n\n# retrieve\nrecall search \"query\"\nrecall semantic \"query\"\nrecall subgraph --project Recall --category memory --subject compiler\nrecall compile \"task description\" --words 900\nrecall incept \"open objective\"        # compile a slice into a grounded synthesis template\n\n# write (agent/debug path; normal memory flows through MCP recall_write)\nrecall validate --json proposal.json\nrecall admit    --json proposal.json\n\n# backup / restore\nrecall export > recall-export.json\nrecall import --json recall-export.json --db .recall/restored.sqlite3\nrecall import auto-memory [--project name] [--apply]   # import Claude Code auto-memory files as calibrated cells (dry-run default)\n\n# undo\nrecall rollback list\nrecall rollback show <journal-id>\nrecall rollback apply <journal-id>\n\n# advanced graph runtime\nrecall hyperedge add --json hyperedge.json\nrecall program add <hyperedge-id> --json program.json\nrecall dag analyze <overlay-id> --derive\nrecall eval run --derive\nrecall operate once --derive\n\n# health & trust\nrecall beliefs\nrecall calibration\nrecall maintenance --derive\nrecall repair [--apply]               # prune dangling/unresolvable trust edges (dry-run default; --apply deletes)\n\n# daemon\nrecall daemon run-once [--derive]\nrecall daemon run --interval-ms 60000\n\n# secrets (encrypted side graph, explicit confirmation required)\nprintf 'password\\nsecret-value' | recall secrets save \\\n  --title \"service token\" --confirm-secret-save --password-stdin --value-stdin\n```\n\nRun `recall help`\n\nfor the full command surface, or see the\n[CLI & TUI reference](/H-XX-D/recall-memory-substrate/blob/main/docs/05_CLI_TUI.md).\n\nRecall ships a reproducible public benchmark: a synthetic corpus in a\nthrowaway database, measuring latency and throughput across the\noperational surfaces (`admit_write`\n\n, `search`\n\n, `semantic`\n\n, `compile`\n\n,\npaging, daemon and operator passes, secrets):\n\n```\nnpm run bench:public\n```\n\nNumbers vary by machine. The point is that anyone can rerun the\nmeasurement. See [Public Benchmark](/H-XX-D/recall-memory-substrate/blob/main/docs/19_PUBLIC_BENCHMARK.md) for\nmethodology.\n\nStart with the [docs index](/H-XX-D/recall-memory-substrate/blob/main/docs/README.md), which routes by purpose and\nby audience. Highlights:\n\n[Installation Guide](/H-XX-D/recall-memory-substrate/blob/main/docs/11_INSTALLATION.md)[Architecture](/H-XX-D/recall-memory-substrate/blob/main/docs/01_ARCHITECTURE.md)[Strict Write Schema](/H-XX-D/recall-memory-substrate/blob/main/docs/02_WRITE_SCHEMA.md), the`recall.write.v1`\n\ncontract[Context Compiler](/H-XX-D/recall-memory-substrate/blob/main/docs/04_CONTEXT_COMPILER.md)[LLM Integration Guide](/H-XX-D/recall-memory-substrate/blob/main/docs/LLM_INTEGRATION.md)·[LLM System Prompt](/H-XX-D/recall-memory-substrate/blob/main/docs/LLM_SYSTEM_PROMPT.md)[Secrets Side Graph](/H-XX-D/recall-memory-substrate/blob/main/docs/12_SECRETS_SIDE_GRAPH.md)[Daemon, MCP & Semantic Search](/H-XX-D/recall-memory-substrate/blob/main/docs/13_DAEMON_MCP_SEMANTIC_SUBGRAPHS.md)[Public Benchmark](/H-XX-D/recall-memory-substrate/blob/main/docs/19_PUBLIC_BENCHMARK.md)[Backup And Recovery](/H-XX-D/recall-memory-substrate/blob/main/docs/20_BACKUP_AND_RECOVERY.md)\n\n```\nnpm install\nnpm run build     # tsc\nnpm test          # 162 unit/integration tests\nnpm run e2e       # 94 end-to-end checks across user + agent workflows\nnpm run smoke     # init + status on a throwaway db\nnpm run smoke:mcp # stdio MCP initialize + tools/list smoke\nnpm run test:python\nnpm run verify:full\n```\n\nContributions are welcome. See [CONTRIBUTING.md](/H-XX-D/recall-memory-substrate/blob/main/CONTRIBUTING.md) and the\n[Code of Conduct](/H-XX-D/recall-memory-substrate/blob/main/CODE_OF_CONDUCT.md). Keep changes schema-first, small,\ntested, and aligned with the single-runtime architecture. A good first PR\nruns `npm test && npm run e2e`\n\nclean; release-readiness changes should run\n`npm run verify:full`\n\n. The [Roadmap](/H-XX-D/recall-memory-substrate/blob/main/ROADMAP.md) lays out\ndirection by ring: Foundation, Runtime, and Interfaces. Working in this\nrepo with an AI agent? Point it at [AGENTS.md](/H-XX-D/recall-memory-substrate/blob/main/AGENTS.md).\n\nRead [SECURITY.md](/H-XX-D/recall-memory-substrate/blob/main/SECURITY.md) before using Recall with sensitive data.\nImportant defaults:\n\n- runtime databases and logs are git-ignored\n- primary-graph writes reject secret-looking content, matched against a broad set of credential shapes (cloud keys, vendor tokens, JWTs, private-key blocks, and secret-named assignments) and tuned to never trip on the graph's own cell ids\n- encrypted secret saves require explicit confirmation\n- primary-graph writes are schema-validated and rollbackable\n\nReport vulnerabilities via GitHub Security Advisories. See the policy for details.\n\nRecall is an early working runtime foundation. It is suitable for local experimentation and integration work, and it does not claim production-grade or state-of-the-art behavior without external benchmarks and deployment review. Interfaces may change before a stable release. Treat compiled context packets as evidence, not unquestionable truth, which is how Recall is designed to be used anyway.\n\nIf Recall helps your work, please cite it. See [CITATION.cff](/H-XX-D/recall-memory-substrate/blob/main/CITATION.cff)\nor use GitHub's \"Cite this repository\" button.\n\nRecall is licensed under the [Apache License 2.0](/H-XX-D/recall-memory-substrate/blob/main/LICENSE). See\n[NOTICE](/H-XX-D/recall-memory-substrate/blob/main/NOTICE).\n\nBuilt for agents that should\n\n**remember responsibly**.", "url": "https://wpnews.pro/news/push-vs-pull-agent-memory", "canonical_source": "https://github.com/H-XX-D/recall-memory-substrate", "published_at": "2026-06-18 03:03:48+00:00", "updated_at": "2026-06-18 03:23:25.832598+00:00", "lang": "en", "topics": ["ai-agents", "ai-tools", "developer-tools", "artificial-intelligence", "ai-infrastructure"], "entities": ["Recall", "Node.js", "SQLite", "MCP", "Claude Code", "OpenAI Codex", "H-XX-D"], "alternates": {"html": "https://wpnews.pro/news/push-vs-pull-agent-memory", "markdown": "https://wpnews.pro/news/push-vs-pull-agent-memory.md", "text": "https://wpnews.pro/news/push-vs-pull-agent-memory.txt", "jsonld": "https://wpnews.pro/news/push-vs-pull-agent-memory.jsonld"}}