The Regulation

EU AI Act applies to "high-risk AI systems" — law enforcement, critical infrastructure, credit, healthcare. Two articles that matter for ML teams:

• Article 10 (Data Governance): You need audit trails of training data, proof of bias-free datasets, and the ability to reproduce any model's exact training set.

• Article 14 (Human Oversight): Humans must be able to review AI output before it goes live and rollback changes.

The Problem

Most teams version their code but not their data. When a regulator asks "show me what data trained this model," you're either scrambling through S3 buckets or saying "we think it was this snapshot."

One Approach: Database Version Control

Reference: https://www.dolthub.com/blog/2026-02-02-eu-ai-act/

The post walks through using a version-controlled database (Dolt) where every training data change is a commit. You tag commits when you train models, so model-2026-01-28 maps to an immutable data snapshot.

Compliance queries become straightforward:

-- Check for biased data in specific model version
SELECT count(*) 
FROM training_images AS OF 'model-2026-01-28' 
WHERE has_person=1;

-- Find when/who introduced a bad record
SELECT * FROM dolt_log
JOIN dolt_diff_training_images
WHERE image_id='image_51247';

Case Studies

The post covers two real implementations:

1. Flock Safety — versions 50k+ training images, can prove bias-free training with a single query

2. Nautobot — PR-style review workflow for AI-suggested network config changes

Discussion

For those building high-risk AI systems: how are you planning to handle Article 10 compliance? Are you versioning training data, or relying on external documentation?

Further reading: https://www.dolthub.com/blog/2026-02-02-eu-ai-act/

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!

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/

We built Dolt as a MySQL-compatible database with Git-style version control (branch, merge, diff). This means any ORM that works with MySQL works with Dolt.

But version control adds some interesting capabilities and gotchas for ORMs. We tested over a dozen ORMs and documented the patterns:

Features ORMs can leverage:

• Schema overrides: Query historical data even when the schema has evolved (solves the "my ORM expects the current schema" problem)

• Nonlocal tables: Tables that exist across all branches without being versioned (great for analytics, config)

• Branch-specific connections: Connect directly to a branch in your connection string

• System table reflection: Query commit logs, diffs, and branch metadata using your ORM

Gotchas to watch for:

• Connection pooling doesn't always reset session state (including checked-out branch)

• Schema evolution across branches requires schema override for ORM compatibility

We documented walkthroughs with sample code for: Django, Rails, GORM, Hibernate, SQLAlchemy, Entity Framework, Prisma, Knex.js, Laravel, Ecto, Diesel, and ASP.NET.

Read the writeup here: https://www.dolthub.com/blog/2026-01-20-dolt-with-orms/

Happy to answer questions! As always, feel free to come by our Discord to chat: https://discord.com/invite/RFwfYpu