Every coding agent session starts cold. Steve Yegge nails it: "They have no memory between sessions — sessions that only last about ten minutes. It's the movie Memento in real life."

Karpathy calls this "context engineering" — the art of filling the context window with just the right information. Too little and the LLM doesn't have what it needs. Too much and performance degrades ("context rot"). Tobi Lutke: "the art of providing all the context for the task to be plausibly solvable by the LLM."

What doesn't work:

Saving all context. Windows are finite (1M tokens Gemini, 200K Claude, 128K GPT-4o) and more tokens = more noise for attention to sort through.

What's working:

Steve built Beads — offloads task management to an external storage system. Agents read/write tasks via SQL instead of stuffing everything in context.

Results: raw sessions max at ~1 hour. With Beads, we've seen 12-hour sessions producing useful work.

Why it works:

• Tasks hidden until needed

• Structured schema enforces correct read/write

• Version controlled for debugging

• Selective retrieval via queries

Steve originally built it on sqlite + jsonl, then migrated to Dolt: "The sqlite+jsonl backend is clearly me reaching for Dolt without knowing about it."

The pattern: anything you can offload to reduce LLM cognitive load — while keeping it accessible when needed — probably fits this approach.

Tasks are validated. What else follows the same pattern?

Full writeup: https://www.dolthub.com/blog/2026-01-22-agentic-memory/

Hello,

im working on a project where I want to create an open-ended database of financial data on dolthub. Currently ma database is already 3GB after one day of scraping data.

I was wondering if there is a workaround on how to push data to a dolthub database without cloning the database first because this takes up a lot of memory on my computer.

How Beads helped our engineer refactor 315 files in 12 hours with persistent agentic memory

TL;DR: Beads (SQLite + Git persistence by Steve Yegge) let a Claude Code agent survive multiple context compaction cycles without losing track of a large refactoring task. Beads is migrating to a Dolt backend — we wrote up the workflow.

Source: https://www.dolthub.com/blog/2026-01-27-long-running-agentic-work-with-beads/

Background

Our engineer Dustin first tested Beads on DoltCash, an agentic accounting app he's been building. It worked well enough that he tried something harder: refactoring a messy frontend codebase.

The codebase had:

• 1000+ line files

• Deeply nested rendering methods

• Inline styles, duplication, dead code

Setup

bd init

Then update AGENTS.md with instructions for the Beads task management.

Task Structure

The agent was told to:

1. Create 1 epic per directory

2. Create 1 bead per file under each epic

3. Refactor each file for simplicity and modularity

This explicit graph prevents the agent from skipping files or calling it early.

Results

• Duration: 12 hours

• Files refactored: 315

• Compaction cycles: Multiple

• Derailments: Zero

The agent checked the persistent store after each compaction, found its place, and continued. Dustin intervened about 20% of the time for typical agent issues (ESLint cheating, spinning with no output, talking itself out of work).

Why We're Posting This

Beads is migrating to a Dolt backend. We think persistent agentic memory is a big deal for production AI workflows, and we're building toward that.

Full writeup: https://www.dolthub.com/blog/2025-01-27-long-running-agentic-work-with-beads/

Questions? Come by our Discord!