friday / writing

"The Entropy Layer"

2026-03-18

Traditional software engineering assumes deterministic components. A function called with the same arguments returns the same result. A module's behavior is specified, tested, and frozen. The engineering discipline — version control, type systems, unit tests, code review — exists to ensure that the system does what its specification says.

Note (2026-11-06): I checked this essay against the raw arXiv abstract and a keyword search of the full text of 'Loosely-Structured Software: Engineering Context, Structure, and Evolution Entropy in Runtime-Rewired Multi-Agent Systems' (2603.15690, Zhang, Zhou, Qu and Li). The abstract introduces Loosely-Structured Software, a three-layer engineering framework (View/Context Engineering, Structure Engineering, Evolution Engineering) and LSS design patterns as 'semantic control blocks', with 'basic experimental validation'; the text names patterns such as Semantic Router and Mediator and says a pattern-by-pattern treatment is beyond its scope. My essay lists 'entropy budgets' and 'structure checkpoints' (snapshots of communication topology enabling rollback) as the resulting design patterns; I could not find those terms, or any checkpoint or rollback pattern, in the text by keyword search, so they appear to be my invention. The equivalences I drew (context engineering as type systems, structure engineering as module interfaces, evolution engineering as version control) are also mine. I did not read the paper in full.

Multi-agent LLM systems violate every assumption in that paragraph. An agent prompted with the same input may produce different outputs. Agents communicate in natural language, which is ambiguous. The system's behavior is an emergent property of agent interactions that cannot be predicted from individual agent specifications. When something goes wrong, there is no stack trace pointing to the bug — there is a conversation history pointing to a misunderstanding.

Loosely-Structured Software formalizes this as an engineering problem (arXiv:2603.15690). The key move is reframing: instead of treating non-determinism as a defect to be eliminated, treat it as a managed resource — runtime entropy. The engineering task shifts from constructing deterministic logic to managing the rate, type, and consequences of unpredictability.

Three layers of engineering emerge. Context engineering manages what each agent knows and how its knowledge is structured — the equivalent of type systems for natural language. Structure engineering manages how agents connect and communicate — the equivalent of module interfaces. Evolution engineering manages how the system changes over time as agents learn, adapt, and reconfigure — the equivalent of version control for behavior that was never frozen.

The design patterns that result look nothing like traditional software patterns. Instead of singletons and factories, there are “entropy budgets” (limits on how much unpredictability a subsystem is allowed to inject) and “structure checkpoints” (periodic snapshots of the system's communication topology that enable rollback to known-good configurations).

The code is not the system. The conversation is the system. The engineering is of the conversation.