06 / Remember

Remembering why

How do decisions, evidence, and intent survive agents, branches, and time?

A session log explains what happened. A task graph explains what remains. Neither automatically preserves why a consequential decision was taken.

What do we need to remember after the agent leaves?

01

Preserve coding-session history

Keep useful evidence and context connected to agent-generated work.

Trade-off: Recorded history can become noise unless it stays navigable.

02

Carry context across runs

Retain information that would otherwise vanish as agents, tasks, and sessions turn over.

Trade-off: Persistent context can become stale or contradictory.

The comparison: a task graph records commitments; session history records activity. Decision rationale needs another layer.

WHAT TO WATCHTasks reopened because a dependency was forgotten.

Quote

3.25.6 field report: daemon ↔ MCP last-writer-wins still drops MCP-session writes

github.com · Comment on issue #2621, The write drop is reproducible in ~30 lines

“Every one of the 50 writes returned success: true, and the DB stays integrity_check: ok. One process's entire batch was obliterated.”
— sparkling, on GitHub
Take

Two processes wrote 25 rows each; all 50 writes were acknowledged and 25 rows remained. The test forced the sql.js fallback path, so it doesn't apply to every backend. The remaining race moved to #2878, closed in August 2026.

  • Remember
Quote

Agent pull requests are everywhere. Here’s how to review them.

github.blog · 2. Code reuse blindness

“The cost of leaving duplicated logic is that agents will find it as prior art and replicate it further.”
— Andrea Griffiths, GitHub
Take

An agent’s local context misses what already exists elsewhere in the repository, so duplication compounds.

  • Remember
Quote

AgentDB (sql.js) corruption: 185MB memory.db malformed under concurrent daemon+MCP writes

github.com · Issue #2584, Summary

“This is a data-durability bug in the AgentDB persistence layer: a long-running store should not be one interrupted/concurrent flush away from total loss.”
— ruvnet (Ruflo maintainer), on GitHub
Take

A shared memory database with about 16,700 entries became unreadable, then broke again about half an hour after a restore. PR #2585 added atomic flushes; cross-process locking was left for later.

  • Remember
Video

Building an Autonomous Engineering Org - Angie Jones, Agentic AI Foundation

youtube.com · Angie Jones · from 14:52

“the agents need to understand where everything lives and what depends on what. So, we built a company world modeled based on the entirety of our 25,000 repo code base”
Take

Alongside it, Block built its own orchestrator, Builder Bot, to coordinate the agents. Quoted from YouTube’s auto-generated captions.

  • Remember
  • Coordinate
Video

Devin’s 80% Moment: Background Agents, 7x PRs, & End of Hand-Held Coding — Walden Yan & Cole Murray

youtube.com · Walden Yan, Cognition · from 45:53

“I think we found that the state-of-the-art in December was you could probably run this for about two weeks. By the end of those two weeks, you’d find that, hey, you want to like change a color of a button. Well, turns out this button is implemented in like 10 different places”
Take

An internal experiment: agents building on each other’s work with auto-merge and no code review. The speaker is inferred from context; quoted from YouTube’s auto-generated captions.

  • Remember
  • Verify
Quote

Durable state anchored to raw process.cwd(): agent cwd drift silently resets autopilot/neural/metrics/memory

github.com · Issue #2633, Summary

“The result is that state is written to whichever subdirectory the session drifted into, and then never read again. Nothing errors.”
— sparkling, on GitHub
Take

On one 12-repository workspace this left 109 state directories (97 stray) and about 25 daemons. Fixed in the reporter's fork; the upstream issue is still open. A 2025 issue (#765) describes the same root cause.

  • Remember
  • Isolate
Quote

Effective harnesses for long-running agents

anthropic.com

“The core challenge of long-running agents is that they must work in discrete sessions, and each new session begins with no memory of what came before. Imagine a software project staffed by engineers working in shifts, where each new engineer arrives with no memory of what happened on the previous shift.”
— Justin Young, Anthropic
  • Remember
Quote

Gas Town, Beads, and the Rise of Agentic Development

softwareengineeringdaily.com · Transcript, 0:15:01

“There's a JSON file, one line per issue, and it has merge conflicts all the time, and it gets xlerped into the database, and there's a daemon, and it gets stale.”
— Steve Yegge
Take

This describes the early Beads storage, which the move to Dolt replaced. It isn't how Beads works today.

  • Remember
  • Coordinate
Quote

Gas Town, Beads, and the Rise of Agentic Development

softwareengineeringdaily.com · Transcript, 0:28:41

“It's so wild because like 8 out of 10 get done, and 2 out of 10 get lost.”
— Steve Yegge
Take

A rough personal estimate. In the same answer he says lost designs sometimes have to be redone from scratch.

  • Remember
Quote

Gas Town: from Clown Show to v1.0

steve-yegge.medium.com · Beads: Ready for v1

“The inherent fragility of the v0.x Beads architecture, with its bidirectional sync, 3-way merge, two sources of truth, race conditions, and tombstone hell — that's all gone now.”
— Steve Yegge
  • Remember
Quote

Harness engineering: leveraging Codex in an agent-first world

openai.com · Entropy and garbage collection

“Our team used to spend every Friday (20% of the week) cleaning up “AI slop.” Unsurprisingly, that didn’t scale.”
— Ryan Lopopolo, OpenAI
Take

Agents copy whatever patterns already exist, so drift compounds. The replacement for the Friday cleanup was recurring agents that open small refactoring PRs.

  • Remember
Quote

memory_retrieve serves stale or deleted values when two MCP servers share a store (per-process cache)

github.com · Issue #3360, Summary

“When two ruflo MCP servers share one memory store, memory_retrieve on one server keeps returning a value after the other server has updated or deleted it.”
— HF-teamdev, on GitHub
Take

Shown with a two-process reproducer: a per-process cache served old values for up to five minutes while the database held the right one. Fixed by PR #3361 in September 2026.

  • Remember
Quote

The Tower Keeps Rising

lucumr.pocoo.org

“Each change can be reasonable in isolation but since it’s frictionless, none of us necessarily has to talk to the others or familiarize ourselves with the code we are changing.”
— Armin Ronacher
Take

The friction that used to force people to coordinate is gone. In his words, construction can continue after shared understanding has already collapsed.

  • Coordinate
  • Remember
Quote

Welcome to Gas Town

steve-yegge.medium.com · WARNING DANGER CAUTION

“Some bugs get fixed 2 or 3 times, and someone has to pick the winner. Other fixes get lost. Designs go missing and need to be redone.”
— Steve Yegge
  • Coordinate
  • Remember
Quote

worker-daemon.js:saveState() race on a shared .tmp filename

github.com · Issue #2782, Relationship to #1637

“the maintainer's fix prevents cross-process corruption, but does not prevent two saveState() calls within the same process from racing on the shared <file>.tmp name.”
— mjbfg1995, on GitHub
Take

The fix for the run-count race introduced a new one: about 56,000 errors in one daemon log. The damage was log noise, not lost data. Fixed by PR #2788.

  • Remember

Tools filed under remember

Preview · not yet reviewed by a human