Agent Frameworks Considered Harmful: How a Markdown‑Based…

Discover how Rémi Louf’s hash‑driven, markdown‑based runtime turns prompts into versioned, diffable components, enabling reliable agent development without heavy frameworks.

Ever felt stuck when a prompt change breaks everything and you can’t tell why?

⚡ TL;DR: Rémi Louf ditches monolithic prompts for a hash‑based, markdown‑driven runtime where every piece is versioned, diffed, and replayable, letting anyone add agents without code.

The Simple Version

Think of a prompt as a set of Lego blocks, each stored separately.

When you edit one block, only that block changes, and you can see the exact difference.

How It Actually Works

Separate Hash Storage

🎯 Think of it this way: Like storing each Lego piece in its own labeled bag so you can rebuild any model exactly.

Each part of the prompt — system message, skill description, tool definition, user question — gets its own hash.

That hash acts as a unique identifier, so the system knows exactly which component changed.

Content‑Addressed Prompt Store

🎯 Think of it this way: A library where every book gets a barcode; change a word and the barcode changes.

The full prompt is treated as a collection of hashes rather than a rendered string.

Alter any component and the overall hash changes, making the prompt content‑addressable.

Typed Tool Calls and Events

🎯 Think of it this way: A vending machine that only accepts certain coins; malformed coins get rejected.

Only properly typed calls and events are allowed through.

About 20% of incoming events are malformed and get filtered out, keeping the system clean.

Technical Deep Dive

Every prompt element gets its own hash.

These hashes form a dependency graph.

Developers can diff two runs to see exactly which component changed.

The full prompt is stored as a list of hashes, not a rendered string.

Because of this, you can replay any single hash against a different model.

Agents are just markdown files you drop into a folder.

Non‑technical users can add or edit them easily.

Events are subscribed to instead of maintained via a complex graph.

Only properly typed tool calls pass the boundary, keeping errors low.

Why This Matters

Versioning prompts like code eliminates guesswork when a model behaves unexpectedly.

Teams can reproduce failures, understand exactly what changed, and roll back safely.

The lightweight markdown approach invites collaboration from people who don’t write code.

With twenty agents already running, the approach scales without a heavyweight framework.

Key Takeaways

Store each prompt component separately and hash it for precise tracking.
Use content‑addressable storage so any change updates the overall identifier.
Diff runs to see exactly which component was modified.
Replay individual hashes against different models for flexible testing.
Represent agents as markdown files to democratize contribution.
Typed events and tool calls act as clear boundaries, filtering malformed input.
Keep the runtime small and focused to avoid unnecessary complexity.

Agent Frameworks Considered Harmful: How a Markdown‑Based Runtime Solves Prompt Versioning