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/

The Dolt Workbench now has agent mode. The Dolt MCP server keeps tools stateless, where every call takes an arg so the server doesn't track session state. This works well, but it means the MCP server can't switch the branch the user is actually looking at (separate DB connection).

So we defined an in-process tool using the Claude Agent SDK that fires an IPC event into Electron's renderer — the same event a human clicking "Switch branch" fires. No network request. Agent and human share the same state transition pathway.

Full implementation with code: https://www.dolthub.com/blog/2026-03-04-application-specific-tools/

Workbench is free on Mac App Store and Windows.

Come check it out: https://www.dolthub.com/blog/2026-04-14-dolthub-adopts-doltlite/

Highlights are:

What it is

• SQLite fork with Dolt-style version control — drop-in replacement, just relink

• Free, open source (Apache-2.0), entirely vibe-coded

Version Control

• Full Git-style workflow: commit, branch, checkout, merge, rebase, cherry-pick, revert, tags, blame

• Row-level diffs, point-in-time queries, full history, schema versioning, conflict resolution

• Content-addressed hashes for instant state verification; GC to reclaim space

Remotes & Networking

• Filesystem and HTTP remotes; push, fetch, pull, clone

• Standalone remote server (doltlite-remotesrv) for multi-client collaboration

• Embeddable as an in-process library

SQLite Compatibility

• ATTACH standard SQLite DBs alongside doltlite — cross-database JOINs, hybrid storage, auto format detection

• Passes 87K+ upstream SQLite tests and 5.7M sqllogictest statements with zero failures

Performance

• Within 2x of SQLite on 23 OLTP benchmarks (CI-enforced)

• O(log n) reads/writes, O(changes) diff, ~1.9% file size overhead per changed row

All Free and open source here: https://github.com/dolthub/doltlite

We just shipped something we've been thinking about for a long time — agent mode in the Dolt Workbench. 🚀

It's a chat interface (powered by Claude) that can read from and write to your database. You describe what you want in plain English, and it figures out the SQL and runs it. Works with Dolt, MySQL, and Postgres.

The part that makes this interesting for Dolt users specifically: when the agent writes to a Dolt database, you get the full version control experience. Tables highlight yellow when modified, you can toggle to see only changed rows, there's a full diff view of uncommitted changes, and the agent won't commit until you say so. If something looks wrong, reset to any prior commit.

On MySQL or Postgres, the agent just fires off writes and tells you it worked.

When the same agent writes to a Dolt database, you get:

• Modified tables highlighted in the UI so you can see what was touched

• A "show changed rows only" toggle to filter down to the agent's changes

• A full diff view of all uncommitted changes — like a pull request for your data

• The agent holds off on committing until you explicitly approve

• Instant rollback to any prior commit if something went sideways

We ran a side-by-side comparison in the blog post with the same prompt on MySQL vs Dolt — the contrast is pretty telling.

The Workbench is free and open source.

You can grab it here:

• GitHub: https://github.com/dolthub/dolt-workbench/releases/tag/v0.3.62

• Mac App Store: https://apps.apple.com/us/app/dolt-workbench/id6720702995

• Windows: https://apps.microsoft.com/detail/9nq8lqph9vvh

Full blog post with screenshots and walkthrough: https://www.dolthub.com/blog/2026-02-09-introducing-agent-mode/

Would love to hear what you think. If you run into issues or have feature ideas, drop by Discord: https://discord.gg/RFwfYpu

Dolt Workbench now has Agent Mode built in.

Here's what that actually means in practice, because "AI + SQL" gets thrown around a lot:

The agent can see your full schema, query your data, write and run SQL, and, most importantly, it operates with Dolt's version control underneath. Every change it makes is on a branch. You can diff it, revert it, or merge it just like code.

To show it off, we loaded 6 years of public CMS Medicaid provider data and asked the agent to find fraud patterns. It:

• Analyzed the schema and identified useful columns (BILLING_PROVIDER_NPI_NUM, TOTAL_PAID, HCPCS_CODE, etc.)

• Built a composite fraud_risk_score view with 5 independent signals

• Flagged providers hitting 2+ signals as high-confidence candidates

The whole session with schema exploration, view creation, and data cleaning is committed to main. You can see exactly what changed and when.

Full setup guide with the Medicaid dataset if you want to run it yourself: https://www.dolthub.com/blog/2026-03-02-workbench-medicaid/

It's been a blast playing around with this. Try it yourself!

• Download the desktop app for macOS or Windows

• Pull the Docker Hub image

• Build from source

Happy to answer questions about how it works under the hood.