Why Git and the Filesystem Are Enough for Durable AI Systems

Durable AI work needs a record of what happened, where the work lives, and what changed between runs.

The MVP uses git and the filesystem for that record. This is not a shortcut. It is a product constraint inherited from the matic ontology: operational state should be readable, diffable, branchable, and recoverable with ordinary tools.

The persistence layer

The persistence foundation introduces three small primitives:

• OrgStore: creates and loads the org record.
• TaskQueue: stores pending, running, complete, and failed tasks in queue directories.
• Journal: appends markdown entries with timestamps and the current git commit when available.

Each primitive writes files that a person can inspect directly. The queue is not hidden in an opaque database. The journal is not trapped in an application log stream. The org record is not a black box.

Queue directories are operational state

The MVP queue lives under .matic/queue/:

.matic/queue/
  pending/
  running/
  complete/
  failed/

Moving a task from pending to running is a filesystem state transition. It is simple, but it establishes an important rule: work has a visible lifecycle. That rule will carry into later runtime execution, awaiting states, human review, and replay.

The journal is the early audit trail

The journal records operational events in markdown:

## 2026-05-11T17:00:00Z - task.enqueued

- Git commit: `abc123`
- Message: Enqueued task `write-post`.

The full ontology has richer Feed and Audit primitives. M0 does not need all of them on day one. It does need a durable habit of recording consequential state changes as they happen.

Why this matters before runtime integration

Adding an Agent Runtime too early can make the project look alive before it is reliable. The persistence foundation does the opposite. It creates the state substrate first, so later runtime calls have:

• a task to execute,
• a run to record,
• artifacts to produce,
• a journal to explain what changed,
• and a filesystem workspace that can be committed.

That is the practical foundation for durable AI systems: not smarter prompts, but operational memory that survives the prompt.