{"slug": "when-your-coding-agent-needs-a-scribe-not-a-memory-engine", "title": "When Your Coding Agent Needs a Scribe, Not a Memory Engine", "summary": "A developer distinguishes between two tools for giving AI coding agents persistent memory: AgentMemory, which automatically captures all session observations, and Qiju, which requires intentional logging of decisions. The developer argues that AgentMemory answers 'what happened' while Qiju captures 'what matters,' making them complementary rather than interchangeable.", "body_md": "Over the past few weeks, I have had several conversations about the right way to give AI coding agents persistent memory.\n\nSome developers ask about AgentMemory. Others ask about Qiju, which I built and maintain.\n\nMy usual response is: they are not solving the same problem. But I have not written that distinction down clearly.\n\nThis post is my attempt to do that.\n\n**The same surface problem**\n\nBoth tools address the same frustration.\n\nEvery new coding session starts without context. The agent does not know which file is authoritative. It does not know what was decided in the previous session. It does not know which approaches have already failed or which assumptions have been verified.\n\nThe developer spends the opening minutes of every session reconstructing what the previous session established.\n\nBoth tools try to reduce that cost. But they approach it differently, and the difference matters in practice.\n\n**What AgentMemory does**\n\nAgentMemory runs as a local server and hooks into the lifecycle events of your coding session automatically.\n\nWith Claude Code, Codex, or another supported agent, it captures:\n\nevery prompt submitted;\n\nevery tool call the agent makes;\n\nevery result the agent receives;\n\nsession start and session end.\n\nThose observations are compressed using a language model, embedded using a local or cloud embedding model, and indexed with BM25 and vector search. At the start of the next session, the most relevant memories are retrieved automatically and injected into the conversation. You do not need to do anything.\n\nAgentMemory has published reproducible benchmark results: 95.2% recall accuracy on LongMemEval-S. Semantic retrieval can find \"database performance\" when you actually wrote \"N+1 query fix.\" Keyword search cannot do that.\n\n**What Qiju does**\n\nQiju does not capture anything automatically.\n\nWhen I want a record to persist, I or my agent intentionally invokes `/qiju-log`\n\ninside Claude Code, or `$qiju-log`\n\ninside Codex.\n\nThat produces a structured handoff record:\n\n```\ntitle:         Selected token refresh strategy\ntags:          auth, architecture\nsearch_terms:  refresh token, 401 retry\nnext_steps:    implement bounded retry, add expiry regression test\nbody:          Decision, evidence, rejected alternatives, and handoff notes.\n```\n\nThe record is stored in plain JSONL files on the developer's machine. Nothing is embedded. Nothing leaves the machine. Retrieval is deterministic keyword and tag search.\n\nIn the next session, the agent searches for what it needs. The developer sees exactly what was recorded and why.\n\n**The real distinction**\n\nIt is tempting to describe AgentMemory as \"automatic Qiju,\" or Qiju as \"manual AgentMemory.\" That is not quite accurate.\n\nThe two tools are answering different questions.\n\nAgentMemory asks: what did the agent observe during previous sessions?\n\nQiju asks: what did the developer judge worth preserving about this project?\n\nAn internal log of every tool call is not the same as a structured record of why a decision was made, what evidence supported it, and which approaches were already rejected.\n\n```\nA memory engine accumulates what happened.\nA record layer captures what matters.\n```\n\n**Why the distinction is practical**\n\nImagine a session in which I investigated an authentication bug, tried three approaches, found that the second one caused a regression, and decided to roll back the change and record a specific boundary condition in the architecture notes.\n\nAn automatic memory capture would produce:\n\nobservations of every file read;\n\nobservations of every command run;\n\nobservations of every test failure;\n\na compressed session summary.\n\nThat is useful background.\n\nA deliberate Qiju record would produce:\n\nthe specific file that is the current ground truth;\n\nthe decision and the reason for it;\n\nthe two rejected approaches and why they failed;\n\nthe next step for the following agent.\n\nThe next agent does not need the full observational trace. It needs to know what was decided, where to find the evidence, and what not to repeat.\n\nThose are different artefacts.\n\n**A concrete example**\n\nIn the post I wrote about Codex's SQLite logging problem, I described this kind of record:\n\n```\nGround truth:  design/pypi-packaging-execution-plan.md\nDecision:      Use one canonical src/qiju package for source and PyPI installs.\nVerified:      Wheel and sdist passed artifact inspection and installed-wheel smoke tests.\nRejected:      Renaming scripts to qiju only during the staging build.\nNext:          Publish to TestPyPI and repeat the clean-install lifecycle test.\n```\n\nA complete session transcript might contain tens of thousands of words around those conclusions. The durable project record is much smaller.\n\nThe next agent does not need the whole session. It needs the right record.\n\n**The operational differences**\n\nBeyond philosophy, the two tools make different operational assumptions.\n\nAgentMemory requires:\n\na Rust binary (iii-engine) running as a background daemon;\n\nNode.js installed;\n\nan embedding model, either local or from a configured API provider.\n\nIf an external embedding provider is configured, content leaves the machine. The local `all-MiniLM-L6-v2`\n\nmodel avoids this but adds setup steps. AgentMemory supports over twenty agents including Claude Code, Codex, Cursor, Cline, Gemini CLI, and others. It runs on macOS, Linux, and Windows.\n\nQiju requires:\n\nPython 3.11 or later;\n\nnothing else.\n\nRecords stay in plain JSONL files on the developer's machine. They can be committed to git alongside the code. Qiju supports Claude Code, Codex, Kiro, and Cursor. It runs on macOS and Linux. Windows is not yet supported.\n\n**Where they compose**\n\nI do not think of these tools as competitors.\n\nA team could run AgentMemory for automatic background capture — what the agent did, when, and in which files — and run Qiju for the intentional layer — what was decided and why.\n\nAgentMemory recalls what the agent did.\n\nQiju records what the developer decided.\n\nThat is a natural division of responsibility.\n\n**Current limits of both**\n\nAgentMemory's automation is valuable precisely because most developers will not log anything if the effort is nonzero. But automatic capture at PostToolUse granularity produces high volume. The compression step reduces it, but the signal-to-noise ratio depends on how well the LLM identifies what was important. The daemon and embedding pipeline add operational complexity.\n\nQiju's intentional capture is a feature to some developers and a friction point to others. If you forget to log something, it is not recorded — though a Stop hook in your agent configuration can instruct the agent to run `qiju-log`\n\nbefore the session closes, which reduces the chance of an unrecorded session. There is no semantic search. Retrieval depends on using good keywords and tags at log time. The record is only as good as the effort put into writing it.\n\nNeither tool solves all the problems. Both have been honest about their current limits.\n\nNeither tool solves all the problems. Both have been honest about their current limits.\n\n**My conclusion**\n\nThe question of agent memory is not settled. The tooling is early and changing quickly.\n\nIf zero-friction automatic capture matters most, and you are comfortable with the operational requirements, AgentMemory is worth exploring.\n\nIf deliberate, auditable, file-based records matter most, and you want something with no background services and no external dependencies, Qiju fits that model better.\n\nIf both matter — the tools compose.", "url": "https://wpnews.pro/news/when-your-coding-agent-needs-a-scribe-not-a-memory-engine", "canonical_source": "https://dev.to/timetxt/when-your-coding-agent-needs-a-scribe-not-a-memory-engine-3bj", "published_at": "2026-06-26 04:58:25+00:00", "updated_at": "2026-06-26 05:03:39.269490+00:00", "lang": "en", "topics": ["artificial-intelligence", "large-language-models", "ai-agents", "developer-tools"], "entities": ["AgentMemory", "Qiju", "Claude Code", "Codex", "LongMemEval-S"], "alternates": {"html": "https://wpnews.pro/news/when-your-coding-agent-needs-a-scribe-not-a-memory-engine", "markdown": "https://wpnews.pro/news/when-your-coding-agent-needs-a-scribe-not-a-memory-engine.md", "text": "https://wpnews.pro/news/when-your-coding-agent-needs-a-scribe-not-a-memory-engine.txt", "jsonld": "https://wpnews.pro/news/when-your-coding-agent-needs-a-scribe-not-a-memory-engine.jsonld"}}