Why agents fail today — and how separating memory, execution, and decision fixes it.

LegiVellum is a modular architecture that preserves accountability by separating obligation memory, planning, execution, cognition, and artifact storage into explicit, auditable primitives.

The Problem: Obligation

AI agents do not fail because they are unintelligent. They fail because our systems give them no reliable way to remember what they owe.

For decades, we've focused on making systems faster, more parallel, and more autonomous. We've solved asynchronous execution. We've solved retries. We've solved fan-out, queues, workers, and orchestration.

What we have not solved is how systems remember their obligations once execution becomes distributed across time, processes, and agents.

When something goes wrong, we always ask the same questions:

  • Was this obligation actually accepted?
  • Is it still open, or was it fulfilled?
  • Is it safe to retry?
  • Who owns the next decision?

Most systems can tell us that something happened. Very few can tell us what they are still responsible for.

That gap is where agentic systems collapse into amnesia, blocking, and chaos — not as bugs, but as structural failure modes.

The Three Structural Failures of Agentic Systems

Every modern AI agent framework eventually encounters the same three breakdowns. These are not implementation mistakes. They are consequences of missing primitives.

1. Amnesia

Agents forget what they were doing.

State is stored implicitly in conversation history, ephemeral task objects, or transient queues. When a process restarts, a session expires, or a tool call fails mid-flight, the agent wakes up without a clear answer to the simplest question:

What am I still responsible for?

Without durable obligation tracking, memory becomes narrative instead of authoritative. Agents hallucinate continuity — or restart work they already performed.

2. Blocking

Agents are bad at waiting.

Long-running tasks force agents into uncomfortable tradeoffs:

  • Block the entire reasoning loop while waiting for I/O
  • Or fire-and-forget work, hoping the result returns someday

Both approaches break agency. Either the agent stalls, or it loses the causal chain between decision and outcome.

3. Chaos

Delegation without accountability explodes unless extreme measures are taken to constrain entropy — a losing battle. Agents call other agents. Agents call tools. Tools spawn workers. Somewhere down the chain, ownership dissolves. No one knows:

  • Who accepted the obligation
  • Whether it completed
  • Whether it failed safely
  • Who should decide what happens next

This isn't just messy — it makes reliable autonomy impossible.

The Core Insight: Obligation Must Be a First-Class Concept

LegiVellum is built on a single observation:

Intelligence without obligation tracking is not agency.

If a system cannot answer what obligations are open, who accepted them, and what receipts exist, then retries, recovery, and delegation are fundamentally unsafe.

So instead of building "smarter agents," LegiVellum introduces a small set of primitives that treat obligations as durable, inspectable, and auditable objects.

The LegiVellum Architecture

LegiVellum separates concerns that most agent frameworks conflate. Each primitive does one thing — and does it explicitly.

Glossary (LegiVellum Terms)

Gate
A Gate is a narrowly scoped system component with a single, explicit responsibility. Gates do not overlap duties. They communicate through receipts, artifacts, and well-defined contracts across MCP and API interfaces.

Obligation
A unit of responsibility accepted by a component or agent. An obligation answers the question: "What am I accountable for completing or deciding?"

Receipt*
An immutable record that an obligation was accepted, progressed, completed, failed, or escalated. Receipts are append-only and form the authoritative timeline of responsibility.

Artifact
A durable work product produced by fulfilling an obligation (plans, results, summaries, datasets, outputs). Artifacts are stored separately from receipts.

Plan
A first-class artifact that decomposes an obligation into explicit steps, dependencies, and acceptance criteria, suitable for safe delegation.

*Receipts are not logs. Logs describe events that happened; receipts describe responsibility that was accepted or discharged. Receipts are normative (what the system is accountable for), not merely observational (what occurred).

MetaGate — Bootstrapping Responsibility

MetaGate is the system's entry point.

It bootstraps new agents and components by establishing identity, capability boundaries, and initial obligations. MetaGate answers the question:

What is this component, and what is it allowed to be responsible for?

By emitting bootstrap receipts, MetaGate ensures that even system startup is auditable and crash-safe.

MemoryGate — Remembering Obligations

MemoryGate is not chat history. It is an authoritative ledger of receipts.

A receipt records:

  • That an obligation was accepted
  • That work began
  • That work completed, failed, or escalated

Receipts are append-only and durable. They answer the question:

What does the system still owe, and why?

MemoryGate is the system's ground truth for responsibility.

AsyncGate — Executing Without Blocking

AsyncGate handles time.

It provides asynchronous task execution without blocking the caller. Crucially, it does not coordinate decisions, retries, or ownership. It simply ensures that work can happen later, elsewhere, without freezing the agent that requested it.

AsyncGate answers:

How do we let work happen without losing control flow?

DepotGate — Storing Artifacts

DepotGate is where work products live.

Plans, results, summaries, and other artifacts are stored durably and versioned independently of execution or reasoning. DepotGate does not track responsibility — that belongs to receipts — but it ensures that outputs remain accessible long after execution completes.

DepotGate answers:

Where is the thing that was produced?

DeleGate — Turning Obligation Into Plans

DeleGate is the missing piece in most agent systems.

It does not execute work. It does not store history. It does not reason deeply.

DeleGate's responsibility is singular:

Given an obligation, produce a plan that can be safely delegated.

A Plan is a first-class work artifact. It contains:

  • A stable plan identifier
  • Explicit steps and dependencies
  • Acceptance criteria
  • Delegation boundaries
  • References to obligations and receipts

When DeleGate accepts responsibility for planning, it emits a receipt. From that point forward, the system knows:

  • A plan exists
  • Who owns it
  • What remains open

Execution happens elsewhere. Accountability does not.

CogniGate — The Cognitive Worker

CogniGate is the system's reasoning engine.

It is responsible for making decisions, interpreting artifacts, and determining next actions based on open obligations. CogniGate consumes:

  • Receipts (from MemoryGate)
  • Plans (from DeleGate)
  • Artifacts (from DepotGate)

And produces:

  • Decisions
  • Escalations
  • New obligations

CogniGate does not execute long-running work and does not invent state. It reasons only over what the system can prove. CogniGate never blocks on execution and never guesses state; it reasons over receipts and artifacts that already exist.

Why This Separation Matters

Because each concern is isolated, the system gains properties that agent frameworks usually promise — but rarely deliver:

  • Crash-safe continuity: Agents can restart and still know what they owe.
  • Safe retries: Receipts tell you whether work was accepted, completed, or abandoned.
  • Inspectable autonomy: Humans and agents alike can ask, "What is still open?"
  • Composable delegation: Plans can be handed off without losing accountability.

Most importantly, failure becomes legible.

When something breaks, the system does not shrug. It can explain itself.

What LegiVellum Is (and Is Not)

LegiVellum is not:

  • A monolithic agent
  • A task orchestrator
  • A workflow engine

It is a cognitive substrate — a set of primitives that let intelligent systems remain coherent across time, failure, and delegation.

Closing

Modern AI systems are powerful, but fragile. Not because they lack intelligence — but because they lack memory of obligation.

LegiVellum does not make agents smarter.

It makes them accountable.