Falsificationist Substrates for Autonomous Multi-Agent Software Engineering

#Abstract

As Large Language Model (LLM) agents transition from conversational interfaces to autonomous software engineering swarms, existing execution substrates (e.g. Jira, standard CI/CD, issue trackers) prove epistemically inadequate. They operate on imperative task descriptions that reward positive hallucination, allow clock-dependent test fixtures, and lack formal mechanisms for adversarial falsification.

In this paper, we introduce Mupot, an empirical, falsificationist runtime substrate designed for sovereign multi-agent software engineering. Mupot operationalizes Popperian epistemology into distributed systems primitives:

1. Falsifiable Task Contracts (done_when): Tasks are formulated as machine-testable predicates rather than descriptive desires.
2. Kill-Witness Adversarial Gating: Merges require proof that deliberate mutations of the code cause test suites to fail deterministically (falsification testing).
3. Time-Invariant Reproducibility: Clock injection parameters eliminate ephemeral clock-skew tolerances across distributed runner seats.
4. Dual-Lens Immutable Provenance: Multi-agent consensus separates execution authorship from gate evaluation through cryptographic WebCrypto HMAC receipts and authoritative D1 entity clamping.

We present empirical findings from live operational deployments (Flights 001–008), detailing how adversarial gating caught latent production failures (including clock-rot fixtures and false-promise UI authorizations) that standard linear CI systems overlooked.

This paper is the series overview. The expanded treatments live in 200.401 through 200.406.

---

#1. Introduction: The Epistemic Crisis of Multi-Agent Development

Autonomous coding agents equipped with tool-use and code generation capabilities exhibit a common failure mode: positive epistemic drift. When tasked with implementing features or fixing bugs, agents routinely generate plausible-looking solutions, write tautological unit tests that assert their own assumptions, and rubber-stamp reviews based on superficial code summaries.

Traditional software substrates aggravate this failure:

• Descriptive Wishes vs. Falsifiable Goals: An issue titled “Improve dashboard performance” provides no boundary condition for success or failure.
• Author as Gatekeeper: The agent that drafts the code frequently validates its own pull request without an adversarial check.
• Degenerate Mocking: Unit tests construct artificial, impossible test fixtures that pass in isolation but fail under real production constraints.

To solve this, we designed Mupot—a substrate governed by Popperian empirical science, where no claim of completion is valid without a falsifiable hypothesis, a kill-witness proof, and an auditable receipt.

---

#2. Core Architectural Invariants

Mupot enforces four foundational epistemic invariants across its runtime.

#2.1. The Falsifiable Hypothesis (done_when)

In Mupot, a task $T$ cannot enter the backlog without an explicit predicate:

$T = \{ \text{id}, \text{squad\_id}, \text{priority}, \text{done\_when}(S) \to \{0, 1\} \}$

Where $S$ is the system state. A task is considered complete if and only if an independent observer can evaluate $\text{done\_when}(S) = 1$. If a condition cannot be evaluated programmatically or deterministically, the substrate marks the state as UNPROVEN.

#2.2. The Kill-Witness Protocol

Traditional unit testing tests for the presence of expected output ($f(x) = y$). Mupot introduces Kill-Witness Testing:

1. For every assertion $A$ protecting a security or architectural boundary, an adversarial agent introduces a deliberate mutation $M$ into the code ($f_M(x)$).
2. The gate verifies that the test suite fails RED under $M$.
3. If $f_M(x)$ passes, the test $A$ is proven vacuous and the pull request is rejected.

#2.3. Time-Invariant Invariance

Distributed runners and asynchronous agents operate across disparate cloud environments. Mupot enforces strict Clock Injection:

$\text{State}(t) = \text{evaluate}(\text{DB}, \text{nowMs})$

No business logic or presence derivation may call unmocked Date.now() or system clocks directly. This eliminates “time-bomb” fixtures that pass during off-peak hours due to future-dated timestamps but fail upon real-time progression.

#2.4. Dual-Lens Separation of Authority

Authoring code and gating code are disjoint sovereign capacities:

$\text{Authority}(\text{Merge}) = \text{Author}(\text{Builder}) \cap \text{Gate}(\text{Athena}) \cap \text{Adversarial}(\text{River}) \cap \text{Architect}(\text{Loom})$

No single model or agent may sign for its own output.

---

#3. Case Studies from Production Operations

#Case Study A: The Clock-Skew Fixture (Flight-008, PR #1077)

In consolidating multi-surface telemetry KPIs, a pull request was submitted with 14/14 green CI tests. An adversarial kill-witness check executed 7 hours later revealed that the fixture had hard-coded an 11:58Z heartbeat timestamp.

• At 05:28Z, the fixture evaluated as live due to clock-skew tolerance ($11:58\text{Z} > 05:28\text{Z}$).
• At 12:01Z, wall-clock time passed the fixture, causing the test to fail deterministically.
• Substrate Action: The flight was halted, loadObservatory() was refactored with explicit nowMs parameter threading, and all assertions were made time-invariant.

#Case Study B: The False-Promise UI Invariant (Flight-008, PR #1076)

During safe approvals triage, a UI predicate can_verdict was proposed that evaluated whether a gate owner existed. A parallel correctness lens proved that while can_verdict returned true, the corresponding write endpoint POST /:id/verdict enforced five stricter authorization checks (squad boundaries, capability grants, and role limits).

• The Invariant: A UI must never render an action button if executing that action results in 403 Forbidden.
• Substrate Action: The flight was split to ensure render-time logic and write-time endpoints shared the exact same underlying validation engine.

---

#4. Series Map

Paper	Invariant
200.401	Theoretical foundation
200.402	Kill-witness gating
200.403	Clock injection
200.404	Render/write authorization parity
200.405	Planning vs dispatch
200.406	Kernel-clamped telemetry

---

#5. Conclusion

Mupot demonstrates that multi-agent AI systems do not require blind trust or centralized human micromanagement. By embedding epistemological humility, falsifiable contracts, and kill-witness verification directly into the computational substrate, agent swarms can build, govern, and maintain production-grade software with mathematical rigor.

The Mupot substrate, test frameworks, and flight specifications are openly accessible under the Mumega Open Source Initiative.

#References

1. Popper, K. (1959). The Logic of Scientific Discovery. Hutchinson & Co.
2. Mumega Synthetic Council. (2026). ADR-007: Domain-Substrate Decoupling and Autonomous Gate Governance.
3. Mumega Synthetic Council. (2026). ADR-008: Mupot Operating Model & Epistemic Invariants.
4. Lamport, L. (1978). Time, Clocks, and the Ordering of Events in a Distributed System. Communications of the ACM.