The Third Restructuring of Software Form: From the Three-Tier Architecture to Storage, Models, and Agents

Abstract: Software form has undergone two paradigm shifts since its inception: Software 1.0, in which instructions determine behavior, and Software 2.0, in which data determines behavior (machine learning). This paper argues that a third shift - Software 3.0, in which context and reasoning determine behavior - is now underway, and contends that its terminal form converges to three elements: a generalized database (the unified abstraction of all persistent state and memory), a large model (the intelligence core that performs reasoning and generation), and an agent (the execution loop connecting the first two). The core argument is as follows: in the traditional three-tier architecture, the user-interface layer will be absorbed by the model's ability to generate interfaces on demand, the business-logic layer will be re-partitioned along "expressibility x criticality" into model reasoning and storage constraints (with residual deterministic logic retained as tools), and only the data layer will be elevated into the sole persistent infrastructure. We formalize this convergence thesis, present a minimal reference architecture, report evidence from real prototypes and a live model, and systematically analyze both the conditions under which it holds and the boundaries where it fails - determinism, cost, security, and verifiability delimit the thesis's domain of applicability. We argue that the thesis holds in task domains that are expressible, verifiable, externally stateful, and tool-complete, and that it will reshape the roles of developers, the database industry, and the software-engineering discipline.

• The paper proposes replacing the traditional three-tier architecture with unified storage, a stateless reasoning model, and an agent that plans, recalls memory, and uses tools, subject to explicit scope conditions.
• Experiments show that declarative storage constraints rejected all 20 infeasible schedules generated by Qwen-Plus, while solver-tool delegation produced feasible schedules in 10 of 10 trials, demonstrating how storage and deterministic tools can contain model errors.
• The thesis is limited by determinism, latency, security, verifiability, tool completeness, governance, and cost, with storage acting as an arbiter of consistency rather than a guarantee of factual correctness.

Overview and central claim

This position paper argues that software is undergoing a third paradigm shift—Software 3.0, in which context and reasoning determine behavior—and that its terminal form converges to three elements: a generalized database, a large model, and an agent. The authors formalize the claim as a replacement of the traditional three-tier architecture $S = (U, L, D)$ by $S' = (\mathcal{D}, \mathcal{M}, \mathcal{A})$, where $\mathcal{D}$ is a unified storage abstraction over heterogeneous stores, $\mathcal{M}$ is a stateless reasoning core, and $\mathcal{A}$ is a plan–memory–tool execution loop. The thesis is deliberately scoped: it holds only within task domains that are expressible, verifiable, externally stateful, tool-complete, and economically viable. The paper's most distinctive feature is that it pairs this vision with an explicit boundary analysis—determinism, cost, security, and verifiability delimit where the thesis fails.

Positioning relative to prior strands

The thesis synthesizes four research lines that the authors argue have developed independently: Karpathy's Software 2.0/3.0 framing and "LLM OS" analogy; DBOS's argument that the database rather than the OS should anchor distributed applications; agent research (ReAct, Toolformer, AutoGPT, Voyager) establishing models as autonomous multi-step executors; and database–AI convergence via text-to-SQL, vector retrieval, RAG, and MemGPT's hierarchical memory. The claimed gap is that no prior work unifies these into a single macro-level convergence thesis answering "what gets replaced, what does not, and under what conditions."

Notably, the paper engages directly with skeptical literature on code hallucination and industry reliability concerns. Rather than disputing those findings, it reframes them: the model need not be reliable because correctness should be enforced by deterministic storage constraints, confining hallucination damage to regions where verification can catch it. This move makes the skeptical literature an argument for the storage layer's centrality.

The collapse mechanism

The paper argues layer by layer why the three-tier architecture dissolves:

• UI layer: interfaces become model-generated on demand, but only partially. The layer splits into a deterministic projection layer (balances, compliance disclosures, accessibility semantics—state-driven UI) and a generative decoration layer (layout, wording). Mis-generation of the former is a substantive safety failure, so it must remain a projection of stored state.
• Business logic layer: re-partitioned along "expressibility × criticality" into three kinds—(1) expressible, non-critical rules absorbed by model reasoning; (2) critical but declaratively expressible rules sunk into storage constraints (uniqueness, foreign keys, CHECK constraints, triggers); (3) critical yet non-declarative rules surviving as verified deterministic tools. The third kind is presented as a correction to naive readings of the thesis: not all logic can be absorbed, and the thesis's scope is delimited by how small this residual class can be made.
• Data layer: elevated to sole persistent infrastructure, because model reasoning is stateless, the model's capability ceiling is set by visible state, and only databases provide transactional guarantees.
• Control flow: reconstructed as the agent's plan–memory–tool loop, replacing the main loop frozen into traditional control flow.

The paper instantiates this split with an intelligent production-scheduling (APS) domain carried through all experiments.

Reference architecture and empirical evidence

The reference architecture composes a stateless model core, an agent layer (Planner, Memory, Tool Dispatcher), and a heterogeneous storage layer augmented with constraints and version history. Three experiment classes support the mechanism:

Storage-as-arbiter simulation. A Python/SQLite job shop (10 machines, 200 operations) with exclusion as a UNIQUE constraint and precedence as a trigger, driven by a deliberately noisy planner perturbing up to 30% of assignments. The persisted schedule remained feasible at every error rate (16/33/45 rejections at $\varepsilon = 0.1/0.2/0.3$), with enforcement costing ~1.1 ms per 200 operations. This demonstrates the central mechanism—correctness independent of upstream reasoning quality—at toy scale.

Live-model hallucination test. Qwen-Plus was asked to schedule a 3×3 job shop directly in twenty trials. The striking result: zero of twenty schedules were feasible—all violated machine exclusion, eighteen also violated precedence—with apparent makespans averaging 8.9 against a true optimum of 9. The storage layer rejected all twenty, a 100% catch rate. When the same model delegated to a CP-SAT solver tool, it produced the correct answer in ten of ten trials. Together these show the 0% feasibility reflects entrusting combinatorial correctness to reasoning, not an inherent model limitation. This is the paper's strongest empirical claim, though it rests on one small instance and one commercial model.

Fault injection. Hand-written inline checks versus declarative constraints: when a single capacity check was omitted from hand-written code, over-capacity schedules leaked; declarative storage constraints enforced regardless. The authors concede declarative constraints are not novel—their contribution is arguing their role becomes critical when upstream logic is an unreliable model.

The CP-SAT experiments also surface a cost boundary honestly: one hard 12×12 instance took 9.67 s, illustrating that the residual-tool tier carries real, variable computational cost.

Conditions, boundaries, and falsifiability

Four necessary conditions are stated: expressibility and verifiability of the task; externalization of state (the thesis applies to stateful, long-lived software, not one-shot computation); completeness of the tool boundary; and economic viability. The tool-boundary condition contains an acknowledged dilemma the paper does not resolve: completeness and closedness cannot both hold—a pre-declared toolset is safe but incomplete, while self-bootstrapping toolsets are complete but unbounded. Moreover, per-tool permissions cannot express composed multi-step side effects. The constructive corollary is that authorization's final enforcement point can only be the storage layer.

The economic analysis reframes the comparison around decision value density rather than call frequency: low-value, high-concurrency decisions favor hand-written logic; high-value, low-concurrency decisions favor inference. The boundary is dynamic and engineerable (caching, distillation, batching), moving over time in the thesis's favor—a claim asserted rather than measured.

The boundary analysis identifies four failure classes: strongly deterministic/formally verified tasks; high-frequency, low-latency systems (trade matching, network forwarding); security and compliance, including prompt injection and the attribution problem—an agent's decision is emergent across model, state, and tool feedback, leaving no single accountable subject, and human-in-the-loop faces a responsibility paradox since human comprehension does not scale with agent capability; and unverifiable tasks where hallucination escapes detection. A notable corollary limits the storage layer's arbiter role: the database is an arbiter of consistency, not of fact—it can veto outputs conflicting with stored state but cannot adjudicate fabricated novel entities violating no existing constraint. Correctness for novel outputs requires external oracles or humans.

The paper also addresses the tautology objection head-on: its substance is the falsifiable architectural claim that after collapse, the only durable artifact is exactly storage—not storage plus a thin logic layer. It further offers a concrete falsification criterion for the database-industry prediction: if future agent+database forms still require a separate governance control plane outside the database, the elevation claim weakens.

Limitations and open questions

The empirical evidence is preliminary by the authors' own account: the simulated-planner prototype uses SQLite at trivial scale; the live-model experiments use a single 3×3 instance, a single model, and no comparison against a hand-written baseline; the APS scenario is synthetic rather than deployed. The tool-boundary dilemma (completeness vs. closedness) is identified but unresolved. The attribution problem—how an unintelligible, hard-to-scale human backstops superlinearly growing agents—is explicitly left unanswered, and the paper concedes that in regulated domains the pure converged form lacks any human component and must degrade to "storage constraints + human-in-the-loop." Whether storage-level consistency arbitration yields quantifiable correctness guarantees for probabilistic reasoning remains open, as does the methodology of constraint-driven development.

Conclusion

The paper converts the "software = storage + model + agent" slogan into a scoped, testable proposition with precise definitions, a reference architecture, small-scale but pointed evidence (most notably the 0%-feasible / 100%-caught live-model result), and an unusually candid boundary analysis enumerating which software categories will not be replaced. Its value lies less in the novelty of individual components than in the integrated claim that storage alone survives as durable infrastructure, with correctness anchored deterministically rather than entrusted to probabilistic reasoning. Confirmation or refutation will require scaling beyond toy instances and resolving the governance gaps the paper itself identifies.