The Missing Axiom for Stateless Agents

#machinelearning #designpatterns #agents #architecture

Jeffrey Sabarese (@ajaxstardust)
Part V of the contract-style-comments Series

Abstract: Classical Design by Contract (DbC) implicitly relies on the "Memory Axiom"—the assumption that human collaborators possess persistent contextual memory. The emergence of stateless AI agents as primary code-producers invalidates this axiom. We propose that in an agentic workflow, the contract must transcend its role as a correctness specification and become a complete, self-contained reconstruction of system intent.

I. The Memory Axiom in Classical Engineering

Bertrand Meyer’s Design by Contract (1988) provided the foundational vocabulary for robust software components: Preconditions, Postconditions, and Invariants. This framework was designed for an era where the primary bottleneck was human error, yet it relied on an unstated premise: the collaborator has memory.

The developer who writes the contract carries it forward. The compiler tracks types across files. The runtime enforces assertions in the context of state it has been accumulating since the process started. Even the junior engineer reading the code has yesterday's standup, last month's code review, and a vague memory of the conversation where someone said "never change that sort order."

Everyone in the room has context. The contract fills gaps. It does not have to fill everything.

II. The Stateless Disruption

The introduction of stateless AI coding agents introduces a critical failure mode: Contextual Erasure. Unlike human developers who accumulate systemic understanding over months of iteration, an AI agent initializes every session with zero prior context. It has no recollection of architectural trade-offs, historical production failures, or the nuanced "tribal knowledge" that prevents regressions.

In this environment, classical DbC contracts function as mere correctness specifications—they identify deviations from a baseline that the reader is already assumed to understand. For an agent, this is insufficient. A contract within the contract-style-comments (CSC) framework must function as a total reconstruction of intent, providing a cold-start anchor for every interaction.

If the invariant is not written down, the agent does not know it exists. It will make a change that "works" — compiles, runs, produces output — and silently violates something that took three debugging sessions to figure out. Not because it is careless. Because it genuinely had no way to know.

The tweak is one sentence.

DbC assumes memory. Stateless agents require that the contract itself be the memory.

That is the missing axiom. It does not invalidate the original theory. Preconditions, postconditions, invariants — those are still the right vocabulary. But the completeness requirement changes fundamentally.

A human-facing contract can be terse. The reader fills in gaps from experience.

An agent-facing contract must be self-contained. Every invariant that matters. Every ID that must not be renamed. Every shape that callers depend on. The reason why, not just the what. The consequence of violation, not just the rule.

This is why the LAST REVIEWED timestamp matters. Why REVIEW TRIGGER lists the exact conditions that require an update. Why the document explicitly says this is law before the agent reads a single line of code. These are not stylistic choices. They are the mechanism that keeps the contract trustworthy as a cold-start document — the only handoff that survives a stateless boundary.

What this means in practice

You are not just writing documentation. You are writing the working memory of every future agent that touches this codebase.

If you write it well, the agent inherits your understanding. If you let it drift, the agent inherits your gaps.

The contract is not a safety net. It is the entire floor.

III. Conclusion: The Contract as Persistent State

The "Missing Axiom" forces a re-evaluation of the developer’s responsibility. We are no longer merely writing documentation for human peers; we are encoding the working memory of an agentic system. To adopt the CSC standard is to acknowledge that in the absence of persistent human presence, the contract is not just a safety net; it is the entire floor.

The contract-style-comments Framework

I. The Case for Formalization — Bridging the alignment gap between humans and stateless agents.
II. The Agentic Trivium — Implementing CONTRACT.md as the system's root invariant document.
III. The Narrowest-Scope Update Rule — Minimizing documentation entropy through operational precision.
IV. Governance and Stewardship — Authorizing AI agents as active maintainers of the system's truth.
V. The Missing Axiom — Reconcieving Design by Contract for the epoch of stateless collaboration.

The vocabulary is Meyer's. The problem is new. The solution is to close the gap between what the theory assumed and what stateless collaboration actually requires.

The original insight belongs to Jeffrey Sabarese (@ajaxstardust) and the collaborators documented at whatsonyourbrain.com. This is a natural extension of that work, surfaced in practice while building Finga Studio.