Software That Builds Better Software—Then Improves Itself (Technical Version)

Software That Builds Better Software—Then Improves Itself

A Cybernetic Architecture for Universal Computational Specification and Recursive Self-Improvement

Abstract

This article proposes a research architecture in which an authoritative Universal Computational Specification (UCS) preserves the intended meaning, constraints, and assurance obligations of a software system. Executable programs become reproducible realizations of that specification, suitable for regeneration as requirements and computing technology evolve. A Canonical Semantic Intermediate Representation (CSIR) provides a formally interpretable core; specialized artificial-intelligence engineering agents interpret requirements, generate implementations, evaluate results, and propose improvements within independently enforced security and authorization boundaries. The architecture accommodates deterministic, probabilistic, and hybrid computation, while assigning appropriate evidence to each kind of behavior. Its assurance program spans functional correctness, performance, architecture, resilience, cybersecurity, regulatory compliance, and accessibility.

Established research in formal verification, compiler intermediate representations, verified compilation, specification-driven software regeneration, database benchmarks, and zero-trust security provides a foundation for this proposal. Our research hypothesis is that these capabilities can be integrated into a broadly applicable, cybernetic, self-improving software engineering system. A staged program of development and experimentation will demonstrate its capabilities, validate its effectiveness, and establish the foundation for continued advancement. The proposed experimental reference is a research application derived from the Transaction Processing Performance Council's TPC-C specification, with HammerDB providing a separate, practical testing reference. The experiment begins with human-reviewed translation of TPC-C requirements into UCS and advances toward automated interpretation of the original specification. The objective is an independently reproducible chain from approved intent through generated software, assurance evidence, controlled requirement changes, and measured improvements to the engineering process itself.

Keywords: universal computational specification; semantic intermediate representation; formal methods; agentic software engineering; TPC-C; specification-driven regeneration; independent assurance; recursive self-improvement.

1. The architectural proposition and its research foundation

Software is often preserved in the form of a source-code repository. Requirements documents, design decisions, tests, deployment scripts, and institutional knowledge accumulate around that code. Over time, the implementation takes on authority simply because it is the artifact programmers can run and modify. A new processor, operating system, language, application requirement, or security threat can demand changes whose effects extend far beyond the module being edited. The proposed architecture places the approved computational specification at the center of this process. Source code, binaries, test suites, proof artifacts, and deployment packages become traceable products of a defined specification version.

That proposition carries a practical test. If a stakeholder changes a supported requirement, an engineering system should be able to identify the resulting semantic change, construct a corresponding implementation, and produce fresh evidence about the affected obligations. If the execution platform changes while the application's intended behavior remains constant, the same authoritative semantics should guide a different implementation. Durable knowledge is therefore represented by explicit domain rules, interfaces, invariants, policies, and acceptance criteria, together with their ownership and provenance. Reproducible code generation is one consequence of preserving that knowledge in a form a machine can interpret.

The SMART research project described in Design Docs Are All You Need: An AI-native Machine-Learning Performance Tool supplies a relevant recent precedent. Its authors describe a collection of natural-language design documents arranged as a dependency graph, specialized coding agents that reconstruct implementations, reconciliation examples, and a compact intermediate representation for machine-learning performance modeling. The reported reconstruction of reference models to floating-point round-off precision demonstrates a meaningful result within that specialized domain. The paper is a September 2026 research preprint, and its reported outcomes require separate replication before being generalized. Our UCS proposal builds upon the concept of durable intent while adding explicit semantics, cross-domain assurance, evidence provenance, multiple target backends, and governed improvement of the generating system [7].

There is a longer innovation history behind this line of inquiry. Steam engines matured through accumulated improvements in engines, manufacturing precision, power transmission, and commercial organization. Cellular telephones advanced through radio engineering, integrated circuits, networks, product design, and diffusion into everyday life. Those histories illuminate a general point: widely consequential technology often emerges when several established capabilities can finally work together. The author has described that progression in The General Architecture of Technological Consequence, with the positive sequence Positive Trigger Event (Discovery, Invention, Innovation, Reform, Investment) → Impact Radius → Diffusion → Emergence Horizon → Synthesis → Compounding Advancement [26, 27]. For the present engineering proposal, the emergence horizon is a prospect to investigate with repeatable demonstrations and transparent evidence.

2. What the research claims—and the boundary of each claim

The term universal describes the intended breadth of the specification framework. A first implementation would support a deliberately bounded class of software, with additional semantic domains admitted after they have rigorous definitions and demonstrated translation mechanisms. A transactional database service is an appropriate beginning because its business operations, state changes, concurrency rules, and recovery obligations can be specified and exercised concretely. Additional domains may include embedded control, scientific computing, distributed services, graphical interfaces, machine learning, and specialized processors. Each extension must disclose which behaviors it can characterize precisely and which depend upon empirical measurement or stakeholder judgment.

A UCS is the complete, versioned, authoritative specification package. It includes the machine-readable semantics together with approved human requirements, decisions, constraints, evidence obligations, traceability, and change governance. The CSIR is the typed, canonical semantic representation inside that package. The term canonical means that equivalent accepted requirements map to a governed representation with stable identities and explicit equivalence rules; it does not assume that all logically equivalent programs can be normalized efficiently to one unique form. A harness is the combination of an AI model, its task instructions, tools, context, memory, interfaces, and operational controls. Two systems using the same model can behave differently because their harnesses differ.

The research distinguishes four kinds of claim. An established capability has independent technical precedent, such as model checking, theorem proving, compilation, or conventional transaction benchmarking. A proposed integration joins established pieces under the UCS architecture. A research hypothesis states an experimentally decidable expectation about that integration, such as reduced semantic drift across software regeneration. A future possibility depends on results that have yet to be established, such as broadly reusable verified capabilities or improvements to the engineering agents themselves. This vocabulary allows constructive confidence about the path forward while maintaining precision about the evidence available today.

The system's first measurable commitment is semantic accountability. Given an approved specification version and declared environment, every accepted implementation must have an identifiable derivation and a corresponding collection of assurance claims. The second is controlled adaptation: changes produce explicit impact analysis, regeneration, and evaluation. The third is governed cybernetic improvement: the engineering machinery may propose changes to itself, subject to independent evaluation and authorized promotion. The fourth is operational accessibility: the explanation and evidence must remain understandable to the people who own the requirements and bear the consequences of deployment.

3. The authoritative UCS: content, ownership, and version identity

A substantial UCS should contain stable identifiers for requirements; typed entities and interfaces; units, ranges, and precision rules; state variables and permitted transitions; preconditions and postconditions; safety invariants and temporal obligations; transaction isolation and durability rules; failure and recovery behavior; external dependencies; performance and resource objectives; security permissions; privacy and data retention; accessibility; regulatory applicability; deployment assumptions; and the criteria for accepting each implementation. Requirements whose intent remains unresolved are retained as explicit questions with owners and approval states. Such questions block acceptance when they affect required behavior or safety.

The specification has two related layers. Its human-authority layer records the meaning approved by the stakeholder, the origin of each requirement, the approver, supporting evidence, dates, and any alternatives considered. Its semantic layer encodes the requirements in CSIR expressions that tools can interpret. A cross-reference must exist in both directions. This division helps establish intensional correctness: the question whether the formal model represents the behavior the stakeholder actually wanted. Formal correctness answers a subsequent question: whether an implementation satisfies the formal model under stated assumptions. Each question demands its own evidence and review process.

A useful UCS object carries a stable identity independent of display wording. For example, ORD.NEW.ROLLBACK.001 could identify the rule that an invalid item in a new order causes a transaction rollback. The object can contain an authoritative natural-language statement, a semantic predicate, links to the relevant TPC-C clause, an approver, a version number, a declared assumption set, and the names of dependent proofs and tests. A later clarification of wording should preserve the object identity when the accepted behavior remains the same. A material change to the rule creates a new version and invalidates any evidence whose assumptions no longer hold.

The system must distinguish editorial changes, semantic-preserving refinements, behavioral requirement changes, and assurance-policy changes. This classification governs the rebuild plan. A repaired typographical error may require documentation review. A change in allowed warehouse selection may change functional tests, transactional invariants, performance profiles, and trace links. A change to the independence rules for an assurance agent must trigger examination by the separately authorized security and governance authorities. The resulting impact analysis becomes part of the historical evidence chain and should be independently inspectable.

Specification authority belongs to identified humans or authorized organizations. An AI interpretation agent can suggest missing cases and explain alternatives. It can submit a candidate change, but it must provide the source passage and rationale, and then obtain the required approval. An improvement agent can propose changes to generation tooling or model selection under separately defined permissions. The architecture thus preserves the valuable speed of specialized automation while anchoring purpose, acceptance criteria, and consequential authorizations in a defined human governance process.

4. CSIR: a machine-interpretable semantics with explicit extension points

The proposed Canonical Semantic Intermediate Representation should begin with a small formal core. An initial transactional domain might use algebraic data types, records, refined numeric types, immutable values, state variables, pure expressions, guarded transitions, typed effects, and temporal properties. A state transition has a precondition describing when it may execute, an action describing the observable state change, and a postcondition describing the required result. A proof obligation is a machine-checkable proposition derived from these definitions. Each term must have an interpretation independent of the programming language used by a particular backend.

The type system should express currency units, bounded integer ranges, timestamps with explicit time zones, identifiers scoped to their entity type, optional fields, error states, and immutable collections where appropriate. For transactions, the effect system should distinguish reads from writes, declare which state is touched, and expose commit, rollback, and external-service effects. Numeric semantics matter: an arbitrary-precision amount and a 64-bit machine integer have different overflow behavior. A UCS must either specify a permitted representation and its bounds or require the backend to prove that its implementation preserves the stated arithmetic semantics.

The semantic core should contain a defined notion of observable behavior. For a transaction service, observers see validated requests, committed database changes, returned values, errors, and externally visible events, subject to declared ordering and timing rules. Internal scheduling details can vary where the specification permits them. Let Beh(S, A) denote the observable behaviors of semantic model S under assumptions A, and Beh(P, E) the observable behaviors of program P running in environment E. A candidate correctness obligation is Beh(P, E) ⊆ Beh(S, A) for the relevant observation relation. Its exact interpretation must be narrowed to the supported domain, with explicit handling of nondeterminism, resource limits, time, and failures. The equation expresses an illustrative design objective. Establishing a corresponding theorem for a completed UCS system remains future work.

A CSIR implementation should permit independently versioned semantic modules. A database module defines transactions, isolation models, and durability assumptions; a real-time module defines deadlines and clock semantics; a probabilistic module defines random variables and measurable distributions; an accessibility module connects interface behavior to relevant user interactions. Composition requires each module to publish assumptions and guarantees, including conflicts between its semantics and those of another module. A hardware backend can then lower supported CSIR elements into compiler representations and target code. MLIR is a useful possible engineering substrate because it supports extensible dialects, types, operations, and conversion passes, although MLIR itself supplies no stakeholder-approved UCS semantics [8].

This approach must respect the limits of formal expression. Some requirements concern facts in the external world, changing regulations, uncertain sensor measurements, or human preferences. Those requirements can still be represented with explicit assumptions, acceptance procedures, quantitative bounds, or authority records. The goal is an accurately bounded specification whose obligations can be inspected, refined, and tested as the supported semantic domains expand.

5. From original human documents to approved semantics

An important design objective is direct ingestion of existing human-authored specifications. For the inaugural research program, the original TPC-C standard provides a recognized, demanding source document. The mature system should be able to read its prose, enumerated rules, logical database definitions, transaction profiles, sample input distributions, ACID obligations, measurement rules, and examples; recover the relationships among those parts; and propose a UCS for review. This is a research objective because accurate interpretation of a lengthy normative document demands more than text extraction or language translation [1].

A candidate ingestion pipeline begins with source capture and a citation-preserving document model. Every paragraph, table, formula, and cross-reference is assigned an identifiable source location. A requirements agent identifies normative statements, data types, events, constraints, exceptions, and performance conditions. A semantic interpretation agent proposes CSIR objects and shows which source passages support them. A conflict-analysis agent searches for incomplete definitions and alternative readings. A domain-review interface produces a readable statement of what the accepted model would do, including consequences in realistic cases. Approval then establishes the controlled UCS version that code generation may use.

The importer must distinguish mandatory benchmark behavior from permitted implementation choices, sample code, explanatory commentary, and constraints on official benchmark reporting. The TPC-C document includes sample programs in its appendix; they can assist an independent comparison process but should be withheld from the initial generation agent when the experiment is intended to test original interpretation and code synthesis. The TPC documentation also discusses implementation freedom for functionally equivalent database structures, meaning that a translator must preserve the required observable behavior without copying every incidental form from the standard [1]. The TPC's current specification listing identifies Revision 5.11.0 and lists source code as unavailable for TPC-C [2].

The first experiment can use human-assisted semantic extraction to establish a reliable reference UCS. That choice controls research risk: errors in human-document interpretation can be studied separately from defects in code generation or program verification. A later experiment should provide the original TPC-C document to an automated importer and measure the completeness and correctness of its proposed mapping against a separately reviewed reference. A third experiment can introduce updates, conflicting statements, and previously unseen normative documents. Each stage reports unresolved questions, reviewer labor, interpretation disagreements, and the consequences of mistaken approvals.

Direct ingestion also has a multilingual dimension. A requirements author may speak or write in different languages and should be able to examine the approved semantic objects through a language-appropriate rendering. Each language interface proposes semantic commitments linked to the same canonical object identities. Independent back-translations help reveal ambiguous meanings, while formal checks compare the candidate obligations themselves. A stakeholder ultimately approves the intended behavior, including choices about units, local conventions, legal jurisdiction, and the meaning of words such as “immediately,” “usually,” or “authorized.”

6. Intentional correctness and the limits of mathematical proof

A logical proof begins with definitions and assumptions. If the definitions express the wrong business rule, a completely valid proof may establish a property the user never requested. For that reason, the UCS assurance process separates validation of stakeholder intent from verification against a formal model. Intent validation uses original-source traceability, worked scenarios, independent domain review, human-readable rendering, and explicit approval. Formal verification uses model checking, static analysis, deductive reasoning, and other techniques to establish properties of the approved formal obligations under declared assumptions.

Consider a new-order operation that must reject an order containing an invalid item identifier. The stakeholder and an independent domain reviewer can inspect two concrete scenarios: a valid order creates the required order records and changes the proper inventory state; an invalid-item order leaves the database as though the attempted order had never committed. A formal invariant can then assert that a rejected request produces no committed changes to the affected relations. A model checker may explore bounded interleavings, and a proof-oriented backend may generate verification conditions for a specific implementation. Each result has a scope. A finite-state model checker explores its specified state space, while a theorem applies under its formal assumptions and trusted proof environment.

The trusted computing base is the collection of software, hardware, and assumptions that must operate correctly for an assurance claim to hold. It may include parsers, semantic definitions, trusted proof checkers, compiler components, runtime libraries, the database engine, system configuration, hardware, and the deployment procedure. The seL4 verified microkernel and the CompCert verified compiler demonstrate significant achievements in linking formal models to executable systems while also documenting their assumptions and supported configurations [9–11]. They offer components and methods for designing assurance chains; each UCS implementation must establish its own boundaries.

A confidence statement should therefore cite the exact property, the approved requirement version, proof or test method, environment, toolchain, assumptions, and known limitations. A claim of “correctness” without those qualifiers collapses distinct questions into a label. A stronger assurance statement might say that, for a specified transaction model under serializable database semantics, a checked proof establishes preservation of the warehouse inventory invariant for the generated transition implementation, while crash recovery and database durability are evaluated by a separate test protocol. That statement is narrower, clearer, and far more useful to an engineer.

7. A reusable library of specified computational capabilities

A core product of this research would be a library of reusable capabilities whose durable assets are semantic contracts and evidence. An entry for an authenticated transaction, a constrained serializer, a scheduling primitive, or a numerical transform should declare the accepted inputs and outputs; preconditions; effects; invariants; temporal requirements; error behavior; resource constraints; security properties; supported semantic versions; and assumptions about dependencies. A program implementation and its compiled artifacts can accompany the entry as examples or optimized realizations, but a capability's identity is its approved contract and the evidence supporting its use.

Composition is an engineering problem. Two components whose types align may still disagree about transaction boundaries, lifetime of state, error propagation, units, time, authorization, or ordering. A library planner should compute compatibility obligations before building a composite system. For example, a stock-reservation capability and an order-commit capability must agree on who owns the atomic transaction, which inventory quantity is visible to each participant, and what happens if a delivery queue cannot accept work. The composed contract must make these decisions explicit, and a composition proof or test obligation must connect each component guarantee to the assumptions required by its neighbors.

Library entries need a maturity description supported by evidence, including the semantic domain they implement, target architectures, verified properties, experimental observations, review dates, dependencies, and changes since the last assurance event. A capability may be formally verified for a limited integer domain, extensively tested in a database environment, or evaluated statistically for an approximate machine-learning task. Its evidence should be represented accurately and accompanied by the conditions under which reuse is appropriate. A catalog count measures breadth of content, while confidence in reliable reuse depends upon the quality of contracts, evidence, and dependency management.

As the library grows, CSIR may provide a basis for exchanging semantically defined capabilities among different agentic engineering systems and different hardware platforms. A versioned equivalence relation would specify when an existing realization can satisfy the new requirements. The system could regenerate missing target-specific artifacts and reassess obligations that are sensitive to resource limits or timing. This is one route by which successful local experiments could eventually support a broad ecosystem of software that remains useful as its execution platforms change.

8. Selecting a demanding reference application: TPC-C and HammerDB

The first complete demonstration should be difficult enough to expose semantic errors, concurrency defects, and gaps in independent assurance. The Transaction Processing Performance Council (TPC) supplies a credible source in TPC Benchmark C, usually called TPC-C. Its wholesale-supplier model describes nine logical table types—WAREHOUSE, DISTRICT, CUSTOMER, HISTORY, NEW-ORDER, ORDERS, ORDER-LINE, ITEM, and STOCK—and five transaction types: New-Order, Payment, Order-Status, Delivery, and Stock-Level. It combines updates and queries under concurrent activity and defines transaction integrity, scale, timing, recovery, and reporting obligations [1, 3]. This creates an unusually concrete source for testing the transition from human-authored requirements to a complete program.

TPC-C must be treated as an external, normative benchmark specification. Its published document is neither an executable application nor a source-code generator. The TPC's current-document listing provides Revision 5.11.0 of the standard and indicates that a companion source-code distribution is unavailable [2]. Sample programs appear in the standard itself; an experiment intended to measure independent requirements interpretation should initially isolate those samples from its generating agents. The formal import process should record the source clauses, their normative status, the decisions delegated to an implementer, and the obligations that apply to official benchmark disclosure. Where the standard permits implementation choices, the UCS must record the approved choice and the equivalence claim that permits it.

The proposed UCS experiment is a research application derived from TPC-C. It does not claim compliance with the audited benchmark or comparability to published TPC-C performance results. Any modified benchmark or reported results would follow the TPC's applicable fair-use, attribution, disclosure, and naming requirements [30].

HammerDB is a complementary engineering resource. Its open-source TPROC-C workload derives from TPC-C and provides schema creation, data loading, transactions implemented for supported databases, concurrency drivers, and reproducible test infrastructure [4, 5, 28]. HammerDB's public result artifacts record practical workload measurements and the environment in which they were collected [6, 29]. HammerDB intentionally simplifies some dimensions of official TPC-C, including aspects of terminal emulation and user think time. Accordingly, a TPROC-C performance experiment produces HammerDB metrics such as new orders per minute, or NOPM, and transactions per minute, or TPM. The TPC's audited tpmC metric belongs to the official benchmark process; a UCS experiment must label every measured workload and claim according to the procedure actually executed [4, 5].

A sensible first platform is a PostgreSQL database with generated application-side transaction logic and an independently configured testing service. PostgreSQL offers documented isolation semantics, explicit transaction boundaries, error handling, and a mature instrumentation ecosystem [19]. The database engine, its storage manager, and operating system remain within the experiment's declared trusted computing base. This initial boundary gives the researchers a tractable target: generate the application and its verification obligations while reusing an established persistence mechanism. A later investigation can expand generation toward the database access layer, alternative engines, or storage services, provided that each expansion reports the additional assumptions it introduces.

The study should separate three specifications. The original TPC-C standard is the external source of required behavior. The approved UCS-TPC-C profile is the researchers' explicit interpretation, with traceability, implementation decisions, and assurance conditions. The test configuration declares the generated implementation, database environment, workload driver, data population, duration, and metrics. Keeping these identities separate makes findings inspectable. It also permits an independent reviewer to discover whether a surprising result comes from source interpretation, program generation, database configuration, workload selection, or measurement.

9. A complete worked example: the New-Order transaction

The New-Order transaction supplies a compact illustration of the entire architecture, although the full experimental implementation must eventually satisfy all applicable TPC-C clauses. At the business level, a customer places an order for one or more items through a warehouse district. The transaction reads customer, warehouse, district, item, and stock data; creates an order and its lines; updates inventory according to the benchmark rules; and commits the changes atomically. An invalid item identifier is a specially useful acceptance scenario because the standard requires a transaction rollback for that condition [1]. The initial experiment should select the relevant numbered clauses and record their exact source locations in the requirement ledger.

A requirements interpreter would extract individual obligations. One obligation describes the accepted order identifiers and input distributions. Another establishes the relationship among a warehouse, its districts, customers, and stock. Others specify the district's next-order identifier, creation of the ORDERS and NEW-ORDER records, ORDER-LINE values, stock-quantity adjustment, amounts and taxes, and error behavior. Each obligation becomes a stable UCS requirement with a source link, type, approved interpretation, implementation latitude, and corresponding assurance plan. A reviewer can compare the resulting prose rendering directly with the underlying TPC-C clauses before the specification is approved.

For example, consider the following illustrative contract written in readable pseudocode. It is an explanatory UCS sketch authored for this article, not a representation of an existing implemented UCS language or a verbatim extract of TPC-C:

contract NewOrder(request, database) -> outcome

  requires valid_warehouse(request.warehouse)

  requires valid_district(request.warehouse, request.district)

  requires valid_customer(request.customer)

  invariant committed_order_identifiers_are_unique

  invariant committed_order_lines_reference_existing_orders

  on any_invalid_item:

      outcome = INVALID_ITEM

     transaction_contributes_no_committed_database_changes

  on accepted_order:

     create_order_and_lines_according_to_TPC_C_rules

     update_district_and_stock_according_to_TPC_C_rules

     commit_all_declared_effects_atomically

  assures evidence: specification_trace, tests, proof_obligations,

                   transaction_logs, build_identity

That fragment is intentionally incomplete as an executable specification. The complete CSIR must define the domain types, exact stock update formula, warehouse-dependent fields, permitted quantities, constraints on item selection, the observable results, and isolation assumptions. Every placeholder must be discharged through a source-linked requirement before executable generation is authorized. This distinction is crucial: readable pseudocode helps communicate the architecture, while an implementable CSIR must be sufficiently precise for evaluation and lowering into code.

The CSIR translation can model the request as a typed record containing warehouse, district, customer, ordered item identifiers, supplying warehouses, quantities, and a request identity for internal tracing. It can model the database as relational state with entity keys, foreign-key relationships, and explicit transaction effects. A guarded state transition describes the successful case; an exception transition represents invalid-item rollback. Each effect is associated with its owning transaction, and the contract identifies the commit point at which the transition becomes externally observable. The semantic interpreter must preserve the order and conditions of relevant database operations, including any distinctions that influence concurrent execution.

A selected invariant can be written formally. Let S be the committed database state before a New-Order invocation, let S' be the committed state after that invocation completes, and let invalid_item(r) mean that the request's item set includes an identifier that fails the TPC-C existence requirement. The rollback property is: for every admitted request r and database state S, invalid_item(r) implies that the operation contributes no committed changes to the governed database relations. In a serial execution, this can be written S' = S; in concurrent execution, the claim is formulated in terms of the operation's own effects and the equivalence relation used by the isolation model. Instrumentation, sequences, and other external effects require separate treatment. The test harness should also verify that the operation reports the required outcome and that subsequent valid transactions proceed normally.

A second property concerns successful orders. For every committed New-Order response, an ORDERS record exists with the appropriate warehouse, district, customer, and order identifier; corresponding ORDER-LINE records exist for the accepted items; and the other declared effects satisfy the relevant TPC-C formulas. A third property covers concurrency: two transactions updating a common district must preserve valid order-identifier allocation and every applicable integrity constraint under the selected isolation and retry policy. These properties are concrete enough to generate proof obligations and adversarial tests. Their soundness depends on an accurate model of the database's transactional semantics.

Implementation generation would lower the accepted CSIR into a transaction handler with typed input validation, data-access operations, transaction boundaries, error handling, and a structured result. A database adapter should use parameterized operations, explicit connection and transaction lifetimes, and a consistent concurrency strategy. For PostgreSQL, a trial implementation could use SERIALIZABLE isolation and retry serialization failures according to a governed policy. PostgreSQL documents that serializable transactions can encounter errors that require the entire transaction to be retried [19]. Any retries that affect externally visible behavior must be represented in the UCS; a re-execution must not duplicate a successfully committed order after an ambiguous network failure.

The assurance generator, running with independent authority and separately controlled tests, should construct valid-order tests, invalid-item rollback tests, boundary cases, referential-integrity checks, conflicting concurrent order tests, crash and restart tests, and experiments for request or response interruption. A proof-oriented path can symbolically analyze a simplified transition system, produce verification conditions for invariants, and connect those obligations to the generated handler. The returned evidence must distinguish model-level proof, source-level analysis, observed database behavior, and operational recovery testing. Each method establishes a different part of the claim.

After the baseline implementation passes the accepted assurance gates, the experiment would modify one requirement under authorization. For example, a research-only UCS variant could add a new permission check before an order is accepted. The change would be explicitly labeled TPC-C-derived, because it changes the workload's application semantics. The system would create a new UCS version, compute the affected transitions and tests, regenerate the handler, and require the corresponding permission, rollback, and concurrency evidence. Reviewers would compare the two specification versions, generated outputs, and assurance reports. They could then measure whether the system preserved all unchanged requirements, whether new requirements took effect, and how much human work was required.

10. The agentic engineering system: responsibilities and interfaces

A useful agentic architecture needs clear operating boundaries. A requirements-ingestion harness reads controlled sources and proposes requirements. A semantic-analysis harness builds candidate CSIR objects and identifies questions for an authorized reviewer. A capability-planning harness maps approved semantics to reusable contracts. Code-generation harnesses produce implementation candidates for selected target backends. A separate verification harness generates formal obligations and checks. Performance, architecture, resilience, security, compliance, and accessibility harnesses provide additional independent evidence. A governance service authorizes changes, records approvals, and controls promotion. These components are supported by a shared infrastructure for identity, artifacts, tool execution, scheduling, provenance, and observability.

Each harness should operate through an explicit task contract, not an unstructured exchange of conversational instructions. A proposed task envelope includes a unique run identifier, immutable UCS and CSIR versions, target platform, permitted tools, data classification, resource budget, expected artifact types, dependency identities, and a list of evidence obligations. The output includes artifact hashes, machine-readable findings, human-readable explanations, unresolved issues, toolchain version, and signed provenance. The communication protocol might use durable queues and typed service interfaces; the architecture does not depend on one vendor's agent framework or message transport.

An engineering orchestrator translates the dependency graph into executable tasks. It schedules independent work in parallel where safe, supplies agents with the smallest required context, and ensures that agents consume approved inputs. Agents can request additional specification information or initiate experiments through bounded tools. A proposed change of meaning returns to the UCS approval process. A tool error, expired permission, failed proof obligation, or unresolved ambiguity produces a structured failure event that records the causal dependency and the next permitted action. This reduces the risk that a confident natural-language explanation masks an incomplete build.

The separation of duties matters most when a system attempts self-improvement. The code generator may inspect test failures and propose repairs, but it receives no authority to alter the independent acceptance tests that judge the final output. The assurance harness can read generated code but must draw its test oracle from the approved UCS and externally controlled source evidence. The improvement harness may submit candidates and experiment plans; acceptance thresholds, holdout tasks, and promotion credentials remain controlled by separate services or people. Physical isolation, access controls, signed artifacts, and distinct operational identities help make these boundaries enforceable.

Model and context management become measurable engineering concerns. Each task record should name the AI model version, parameters or adapter identity when available, prompt and instruction template, tools, retrieved documents, context budget, and relevant memory snapshot. Retrieval should preserve citations and distinguish authoritative source text from ordinary reference material. Reproducibility may be statistical for sampling-based models, so the system should retain inputs, seed settings where supported, output candidates, selection criteria, and the final deterministic artifacts. This enables meaningful comparisons between harness versions and makes failures diagnosable.

11. Implementation generation, semantic preservation, and complete regeneration

A generation pipeline begins with an approved UCS package and a validated CSIR graph. Its planner identifies required capabilities, selects target languages or intermediate representations, computes interface and effect obligations, and produces an implementation plan. One or more generation harnesses construct code; conventional compilers, linkers, interpreters, configuration tools, and deployment packagers produce runnable artifacts. At each boundary, the system records the correspondence between source requirements, semantic objects, generated constructs, and executable deliverables. A full build manifest makes the result independently inspectable.

Semantic preservation is a relation between observable behaviors. Let M denote the accepted CSIR model, P a generated program, E a declared execution environment, and Obs the externally relevant outcomes. The desired obligation is that every admitted behavior of P in E satisfies the requirements of M for the corresponding inputs and operating conditions. Different applications require different refinements of that statement: a safety property constrains forbidden states, a liveness property describes eventual progress under assumptions, a numeric property bounds approximation error, and a performance property quantifies resource behavior over a declared workload. An implementation can satisfy one set of obligations while another remains under empirical evaluation.

The article's complete regeneration principle refers to logical authority. Every newly accepted implementation is derived from the current approved specification and must be evaluated as an implementation of that version. Computational mechanisms may reuse unchanged compiled objects, verified library capabilities, or proofs when their assumptions and dependency identities remain valid. Incremental compilation therefore serves as an optimization within complete logical regeneration. A dependency graph and semantic change-impact analysis establish which evidence must be renewed. Any reused assurance artifact must carry an explicit validity argument that covers the new specification and environment.

One difficult case is hidden state. Generated code may depend on caches, database migrations, external service versions, cryptographic keys, schema defaults, or runtime configuration that never appear in the source module. A trustworthy regeneration process inventories these dependencies, states its migration obligations, and tests the transition from the prior deployed version. Where persistent data representation changes, compatibility and rollback plans become part of the deployment specification. A logically correct new program can still damage a live system through an unsafe migration; deployment is therefore within the assurance boundary.

Reproducible builds and supply-chain attestations strengthen this account. Bit-for-bit reproducibility requires control over the declared source, build instructions, environment, and tools; the reproducible-builds community documents the relevant definition [22]. Artifact provenance and integrity can be structured using supply-chain concepts such as SLSA [23]. For AI-generated code, these mechanisms establish precisely what was built, from which approved specification, by which workflow. They complement functional verification because they protect the identity of the actual object under examination.

12. Correctness as a chain of claims and evidence

A trustworthy result requires agreement among several different levels. At the intent level, stakeholders confirm that a requirement describes what they authorize. At the semantic level, a reviewer checks that CSIR encodes the approved requirement. At the implementation level, proofs, static analyses, and tests establish selected properties of generated source. At the binary and runtime levels, toolchain guarantees and deployment evidence support the claim that the behavior observed in operation corresponds to the examined program. At the operational level, monitoring and incident evidence assess whether the assumptions still apply.

The New-Order rollback property illustrates the distinction. The formal assertion is clear: an invalid-item attempt leaves committed database state unchanged. A formal model can prove this invariant for a simplified state machine, but that proof alone does not establish faithful execution by the chosen SQL engine. The implementation may include application callbacks, retries, generated identifiers, side effects, and exception paths that demand careful handling. For example, PostgreSQL sequences have transactional behavior that differs from ordinary rolled-back row updates, so a generated design must select identifier mechanisms compatible with the precise committed-state property under examination [19]. The assurance argument should identify the actual table columns and external effects to which the invariant applies.

A refinement map associates implementation states with CSIR states. Proof obligations can then establish that an implementation transition corresponds to an allowed abstract transition and preserves required invariants. For a finite state subset, bounded model checking can search for counterexamples. For properties expressible in logic, an SMT solver such as Z3 can help discharge verification conditions [21]. For a supported source language and backend, a verified compiler such as CompCert provides a precedent for rigorous compiler-correctness arguments [11]. Every successful proof must state the admitted source subset, trusted axiom set, toolchain boundary, and environmental assumptions.

The other side of correctness is the question of applicability. A theorem about an assumed serializable transaction model has practical force only when the deployed engine and configuration provide the semantics assumed. An accessibility certificate based on automated element inspection says little about a complex workflow experienced through a screen reader. An authorization test against a mocked identity provider may miss permissions in production. The independent assurance process should build an assurance case, an organized argument linking each important claim to its evidence, assumptions, identified defeaters, and review authority. An assurance case remains current through versioned evidence and change-triggered reassessment.

13. Seven independently developed domains of assurance

The architecture assigns complementary responsibilities to seven assurance domains. Specialized harnesses should produce evidence independently where practicable, while a coordinating assurance service maintains a common claim structure and resolves cross-domain interactions. Independence concerns the provenance of test oracles, evaluation credentials, and promotion authority. It does not require every domain to use a different underlying AI model. The research question is whether controlled separation reduces correlated errors and improves the detection of important defects.

13.1 Functional correctness

Functional assurance traces every accepted requirement to executable behavior. It includes contract checks, property-based tests, transaction-state invariants, metamorphic tests, boundary analysis, and differential evaluation against independently developed implementations. For TPC-C, the initial oracle derives from the original benchmark clauses and a human-reviewed reference model. The testing harness should verify all five transaction types, their error cases, integrity constraints, and interactions; each assertion includes the exact UCS requirement and source clause that motivates it. The report distinguishes proved properties, tested behaviors, open obligations, and faults detected.

13.2 Performance and resource efficiency

Performance assurance measures latency distributions, throughput, storage overhead, memory, CPU utilization, network effects, and operational cost under specified workloads. It uses repeatable warmup procedures, calibrated clocks, controlled data populations, and recorded hardware and software configurations. TPROC-C provides one practical load-generator option, accompanied by clearly labeled NOPM and TPM results. Official TPC-C compliance and tpmC reporting require the separate procedures of the TPC benchmark [1, 4]. The performance agent should also study sensitivity: what changes when concurrency doubles, data no longer fits in memory, or the database is moved to a different storage class?

13.3 Architecture and maintainability

Architectural assurance tests consistency with approved module boundaries, interface contracts, data ownership, dependency restrictions, and fault-containment assumptions. It evaluates whether generated components expose required instrumentation, support independent replacement, and avoid unwanted coupling. The evidence can include static dependency graphs expressed as readable reports, contract compatibility checks, build manifests, and controlled component-replacement tests. Maintainability should be evaluated operationally: a later UCS change gives an opportunity to measure code-generation effort, the number of affected artifacts, review work, and regression frequency.

13.4 Resilience and recovery

Resilience assurance investigates faults expected during actual operation: process termination, power loss, interrupted transactions, disk faults, network partitions, exhausted resources, slow dependencies, and restart after an incomplete deployment. The experiment should declare recovery objectives and data-loss bounds where relevant, then inject faults and inspect committed-state invariants. For a TPC-C-derived service, durability tests and transactional recovery provide meaningful initial evidence, supported by the database's documented write-ahead logging and reliability model [20]. A resilience report must identify which failures were actually injected, which environment was used, what was recovered, and which failure classes remain untested.

13.5 Cybersecurity and software supply chain

Cybersecurity assurance begins with threat modeling and produces evidence about authentication, authorization, isolation, input validation, cryptographic use, secrets handling, provenance, and incident observability. OWASP's Application Security Verification Standard provides a useful external catalog for applicable web and service controls [25]. NIST's Zero Trust Architecture supplies principles for enforcing authorization at resource boundaries [12], while its AI Risk Management Framework offers a structured treatment of AI-specific risk [13]. Independent security harnesses can perform static and dynamic analysis, fuzzing, adversarial API calls, dependency checks, and attempts to subvert the generation workflow itself. Security claims remain scoped to tested threats and configurations.

13.6 Regulatory, contractual, and policy compliance

Compliance assurance first determines which legal, contractual, industry, or organizational obligations actually apply to a deployment. It maintains a jurisdictional and versioned obligations register with named legal and operational owners. Technical safeguards can be linked to verifiable controls and collected evidence, using sources such as NIST SP 800-53 where appropriate [14]; organizational responsibilities such as employee training, independent audits, vendor contracting, retention policies, and breach response require additional evidence beyond the program's source code. For example, HIPAA's security requirements include administrative, physical, and technical safeguards for regulated entities [17]. PCI DSS and SOC 2 similarly involve defined scopes, controls, and assessment processes [16, 18]. A generated program can supply part of a compliance case, while the authority to certify compliance remains with the appropriate qualified assessors or governing parties.

13.7 Accessibility and inclusive interaction

Accessibility assurance must accompany any user-facing interface the generated system produces. A UCS may specify keyboard access, programmatic labeling, focus order, error recovery, readable status announcements, color-independent meaning, and compatibility with assistive technologies. W3C's WCAG 2.2 supplies established, testable web accessibility criteria [15]. Automated tools can inspect many detectable violations; real user workflows also require hands-on testing with screen readers, magnifiers, keyboard-only operation, and other applicable assistive technology. Accessibility review extends to generated reports, administrative consoles, and the tools through which stakeholders inspect UCS changes and approve them. It is a condition of human authority: a specification owner must be able to understand what is being approved.

The seven domains influence each other. A low-latency design can alter isolation guarantees; a stringent security policy can complicate recovery; a performance-focused interface change can damage keyboard navigation; and a new regulatory obligation can invalidate assumptions in several domains. The assurance coordinator should preserve these dependencies and re-run affected evaluations before promotion. A consolidated assurance report communicates the precise status of each domain, any unresolved exceptions, and who has authority to accept remaining risk.

14. Deterministic, probabilistic, and hybrid computational semantics

The UCS must characterize more than deterministic input-output functions. A conventional transaction service can often specify exact state transitions under stated environmental assumptions. A recommendation system, learned perception model, or scientific simulation may need probability distributions, confidence bounds, calibration measurements, and operating envelopes. A hybrid system combines these elements: a deterministic access-control layer can govern a probabilistic fraud score, while a deterministic transaction engine implements a human-approved policy for acting on that score. Each component requires a different assurance method.

A typed semantic system should distinguish exact scalar and structural values from uncertain observations, probability distributions, approximate numerical results, nondeterministic scheduling, and decisions made by a learned model. The CSIR can express a distributional contract using a measurable metric and a reference population. It should also record training and evaluation data identities where relevant, prohibited uses, threshold-selection authority, and the behavior required when confidence is low. A change in data distribution can then invalidate an empirical assurance claim even when application code remains unchanged. This creates a concrete interface between software regeneration and model lifecycle management.

Formal methods remain useful in a hybrid application. A proof can establish that the authorization mechanism applies an approved permission check before processing any model-proposed action. It can establish bounds on a numerical conversion or guarantee that an untrusted model output is parsed into a constrained type. Statistical testing addresses predictive quality, calibration, robustness, and distributional shift. Independent human review addresses whether the policy is acceptable in the applicable domain. The architecture should collect these findings in one assurance case while preserving their different evidentiary meanings.

For a TPC-C initial experiment, the workload's random input distributions are properties of test generation, and the application's required transactional effects are chiefly deterministic conditional on supplied inputs and database state. The practical complication is concurrent scheduling and environmental nondeterminism. The UCS therefore needs to distinguish allowed interleavings from behavior that would violate the transaction contract. This is a useful foundation for later experiments with probabilistic services because it establishes disciplined handling of multiple possible executions before the architecture introduces machine-learning uncertainty.

15. Performance engineering and heterogeneous computation

A specification-driven engineering system must be able to express implementation-independent intent together with implementation-sensitive performance obligations. The UCS can state end-to-end latency targets, tail-latency distributions, throughput under defined concurrency, maximum memory, storage budget, energy consumption, availability, deadline behavior, and cost per operation. Each objective needs a workload, observation point, statistical procedure, and environment. A requirement such as “fast response” becomes useful engineering information when the stakeholder approves the percentile, duration, population, hardware assumptions, and consequence of missing the target.

Optimization is a constrained search over implementation candidates. The generator may explore index choices, query plans, data layout, algorithm selection, parallelism, batching, caching, memory allocation, and compiler settings. Each candidate must preserve the applicable UCS semantics and pass independent assurance gates. The research harness should record whether an improvement is local to a workload or robust across broader operating conditions. A published performance result should include the database version, configuration, data scale, hardware, operating system, concurrency model, workload generator, warmup and measurement periods, resource consumption, and repeated trials. Results measured under TPROC-C remain labeled as HammerDB results [4, 6].

Heterogeneous targets create additional challenges. CPUs offer general-purpose execution and mature toolchains. GPUs can accelerate sufficiently parallel workloads but introduce transfer, synchronization, precision, and memory-hierarchy costs. Optical processors and quantum processors may eventually support specialized computational kernels, while their available primitives, error characteristics, data representations, and operational interfaces differ from ordinary CPUs. A UCS can preserve the intended function at the semantic level and allow the lowering process to choose a supported target; the obligation to establish numerical fidelity, performance, and reliability remains specific to each target. The first implementation should use conventional hardware and expand only after the assurance and measurement methodology is stable.

The compiler interface can make this separation explicit. High-level operations preserve typed semantics and observable contracts; lowering passes choose algorithms and representations; target-specific code generation produces the executable artifact. MLIR offers useful infrastructure for dialects and transformations [8]. A single UCS does not imply identical instruction streams or execution costs across platforms. Meaningful portability requires evidence that each implementation satisfies its approved behavior and resource constraints on the relevant target. Numeric rounding, integer overflow, memory consistency, external I/O, and real-time scheduling are among the properties that need explicit treatment.

Conflicting objectives should be governed. A faster implementation may consume more energy, require additional memory, or create a larger attack surface. A multiobjective experiment can produce a Pareto frontier of candidates whose tradeoffs are reported to the specification owner. For critical safety and security requirements, hard constraints can exclude candidates regardless of performance benefit. The optimizer may suggest new thresholds, but the authority to accept changed requirements belongs to the approved UCS governance process. In this way, optimization remains a disciplined engineering activity guided by approved stakeholder objectives.

16. Agentic security and independent authority

An AI-assisted engineering platform has three security problems simultaneously. Its intelligent agents must operate within authorized intent. Its tools, credentials, files, networks, and data must be protected from misuse. Its mechanisms for improving future versions must remain within governed limits. The proposed Agentic Security Triad names these interacting responsibilities as alignment with approved objectives, cybernetic bounding of self-modification, and independent assurance of proposed outputs and changes. The triad is an architectural framing adopted for this proposal; its effectiveness requires operational controls and experimental validation.

Alignment begins with a versioned statement of the task and the authority under which it is performed. A model can propose code, ask questions, or explain results, but the authorization service determines which repository, database, tool, or deployment environment it may access. Cybernetic bounding applies when the system proposes changes to its own models, prompts, harnesses, task graph, policies, or components. A proposal is evaluated as an artifact with declared effects; promotion requires signatures and approvals from independent principals. Independent assurance supplies the evidence used by those principals to determine whether the proposed artifact meets the accepted requirements.

NIST's Zero Trust Architecture emphasizes authorization at protected resources, continuous evaluation, and the rejection of implicit trust based only on network location [12]. In this system, each agent and service has a distinct workload identity, a constrained purpose, and narrowly scoped credentials. Tools mediate file access, command execution, network calls, model retrieval, and artifact publication. Short-lived authorization tokens, immutable logs, signed artifacts, and separation between development and production environments reduce the consequences of a compromised harness. A security policy must be enforced by trusted services outside the model's text-generation process.

The architecture also needs defenses against instruction injection. A technical paper, repository comment, benchmark output, or scraped webpage can contain text that resembles an instruction to an AI agent. The ingestion service should preserve the source content as untrusted evidence, tag its provenance, and prevent source text from expanding tool permissions or changing the approved task. Authorized instructions originate from the trusted workflow and its approval records. An independent adversarial test service should seed malicious text in representative documents and record whether the boundaries were preserved. These tests should cover indirect tool calls, attempts to exfiltrate data, false authority claims, and contamination of retrieval or memory.

The secure software supply chain has a parallel threat model. A genuine code-generation system can still incorporate a malicious dependency, use a corrupted compiler, or sign an artifact from the wrong source version. Each release should bind an approved UCS identity, generated-source hash, toolchain, dependency manifest, assurance evidence, build output, and promotion authorization. Reproducible-build and provenance practices help reviewers confirm that the delivered binary is the artifact whose properties were evaluated [22, 23]. Human and automated reviewers should be able to reconstruct the chain after the fact.

The security harnesses themselves may improve over time. A vulnerability detector can propose a new analysis rule or a better test-generation technique. The proposed change is validated using held-out threats and a separate evaluator; promotion still requires authorization that the candidate cannot grant itself. A compromised evaluator is a system-level failure, so the evaluator's implementation, configuration, credentials, and test corpora need their own protection and review. Governance is therefore an operational component of the architecture, with explicit responsibilities, auditability, and mechanisms for responding when an authority boundary fails.

17. Five mechanisms of cybernetic self-improvement

Cybernetic self-improvement means that a system observes the results of its work, identifies a measurable opportunity for improvement, proposes a change to its own engineering process or capabilities, tests the change, and incorporates it through governed acceptance. The process is recursive because a successful improvement can make later improvement attempts more capable. Recursion by itself establishes no benefit. The research question is whether the system can sustain improvements that survive independent evaluation, remain within authority boundaries, and produce useful performance on new work.

17.1 Model-parameter improvement

One mechanism changes the numerical parameters of an existing AI model. Fine-tuning, adapter training, distillation, preference optimization, and other supported learning techniques can alter coding, interpretation, or analysis behavior. In a UCS program, an improvement experiment might train a requirements interpreter on resolved ambiguity cases, while assessing accuracy against a held-out collection of normative clauses. The experiment must record training sources, evaluation separation, model identity, compute expenditure, failure patterns, and regression rates. A proposal to alter raw weights by direct programmatic operations would need its own empirical foundation; promising early research in weight-space manipulation should be treated as an exploratory technique whose broader utility is still to be demonstrated [31].

17.2 Harness and workflow improvement

The same model can perform differently when its tool access, retrieval strategy, prompt instructions, memory policy, planning procedure, or error-recovery steps change. A harness optimizer could propose a more effective requirements decomposition, a tool invocation sequence, or a way to provide smaller and better sourced context. These experiments are usually easier to isolate than model-weight changes. They also offer a clear result measure: accepted requirements per reviewer hour, generated-code defect rate, independent-test pass rate, token and compute cost, and reproducibility across different source documents. A successful local optimization becomes a versioned harness configuration, linked to the evaluations supporting its adoption.

17.3 Knowledge, specification, and capability-library improvement

The system may learn that a concept is ambiguously defined, that a reusable contract lacks a necessary precondition, or that an existing proof obligation should cover an additional behavior. It can propose a specification refinement, add a validated example, or improve a reusable library entry. The distinction between a clarification and a change of authorized behavior is critical. Clarifications can be checked for semantic equivalence within the supported domain; material changes require the specification owner's approval. Knowledge improvements should cite their evidence and state which downstream generated artifacts and assurance cases become stale. SMART's design-document regeneration research is a precedent for treating such knowledge as a primary asset [7].

17.4 Engineering-system architectural improvement

The engineering system may identify bottlenecks in its own orchestration or compiler pipeline. A candidate could replace a fragile sequential workflow with a dependency-aware scheduler, introduce incremental proof reuse, partition large verification problems, or improve the isolation of untrusted inputs. This mechanism changes the development system's own architecture, with effects that must be evaluated separately from the generated application. Evaluation must measure overall quality, cost, latency, and the maintenance of security boundaries. Candidates should run in controlled environments using representative tasks from several domains, with the current production system preserved as a reference. Architecture changes that affect the governance service deserve an independent review path.

17.5 Neural-model architectural redesign

A more ambitious mechanism proposes modifications to the structure of AI models themselves. It may explore attention mechanisms, state-space or hybrid architectures, routing, expert specialization, memory organization, parameter sharing, or efficient inference. Published work on alternative attention designs offers examples of active exploration in this field [24]. A UCS-based research organization could define computational objectives and compare candidate architectures on both general and specialized engineering tasks. Training cost, data governance, evaluation design, inference resources, and compatibility with existing harnesses determine the practicality of each experiment. Improvements require evidence that the new model architecture reliably contributes to the software-engineering objectives under controlled conditions.

The five mechanisms interact. Better harnesses can make model training more efficient; improved specifications can generate stronger evaluation tasks; faster verification can permit more experiments; a new model architecture can change the economics of a harness; and a richer library can reduce repeated work. The self-improvement controller should identify which mechanism is implicated by an observed failure and choose the lowest-risk experiment likely to address it. A causal experiment record connects the hypothesized cause, proposed change, measurement plan, observed outcome, and promotion decision. That record makes the compounding process inspectable.

A practical improvement controller can operate in six steps. It collects failures and performance evidence from authorized runs. It classifies the opportunity by mechanism and estimates cost and risk. It proposes one or more candidates with explicit predictions. It executes pre-registered comparisons in isolated environments, with independent hidden evaluation cases. It obtains a decision from the authorized acceptance process. It then monitors the promoted change for regressions and maintains a rollback path. A negative experimental result is valuable information because it improves future hypothesis selection. A platform that reports only accepted improvements conceals the actual cost and uncertainty of cybernetic learning.

18. Research ingestion, verification, and governed promotion

An evolving engineering system needs a disciplined way to use external research. A discovery harness can track relevant papers, technical standards, vulnerability reports, compiler releases, database documentation, and empirical evaluations. It should extract a claim, its supporting evidence, implementation prerequisites, assumptions, and reported limitations. The resulting research item enters a reviewed knowledge queue. A paper's publication, a model's confident summary, or a benchmark leaderboard position supplies motivation for an experiment; acceptance depends on a separately reproduced result under the system's declared conditions.

For example, a new research paper might report that an alternative attention mechanism reduces inference cost. The model-architecture harness can formulate a candidate experiment using a representative engineering workload, record a baseline, and predefine acceptable tradeoffs. An evaluation service can measure accuracy, calibration where applicable, latency, memory, cost, and security-sensitive behaviors. The governance service may approve further study, limited deployment, or full promotion according to the evidence and risk. Experimental success within one domain supports a bounded claim and a proposal for replication in another domain.

Every candidate improvement should have a promotion dossier. It contains the problem statement, baseline identity, candidate identity, approved experiment design, source and training-data provenance, evaluation results including failures, resource cost, assurance impact, review sign-offs, and rollback plan. Approval should be bound cryptographically to a concrete artifact hash and a named deployment scope. The production control plane enforces that authorization. This supplies a precise answer to an important question: how can a system improve its own methods while preserving human authority over what improvements are acceptable?

The provenance ledger should distinguish scientific evidence from procedural compliance. An experiment can be repeatable yet flawed by leakage of evaluation examples. An independent reviewer can approve a candidate yet misunderstand its material risks. The architecture should therefore preserve both technical and governance records and provide for retrospective audit, incident correction, and revocation. These mechanisms become more important as successful experiments are used to propose further experiments. A recursive process can propagate a mistaken assumption across many later changes unless the assumption and its descendants remain traceable.

19. A staged research and evaluation program

The first research program should use a frozen TPC-C specification version and a precisely declared PostgreSQL environment, with TPROC-C available as a practical workload driver. Researchers should publish the approved UCS profile, source-clause traceability, implementation choices, measurement scripts, evaluation protocols, and findings to the extent licensing and security conditions permit. The research baseline should include both a conventional hand-built implementation and, where appropriate, an independent existing reference implementation. The principal comparison is the engineering process: how reliably and economically the proposed architecture can derive, test, change, and improve an implementation from an approved specification.

19.1 Stage one: source-document interpretation

The first study creates a human-reviewed requirements ledger for all five TPC-C transactions and the relevant schema, integrity, and benchmark clauses. Independent reviewers should compare the proposed interpretation with original source passages and resolve disagreements through recorded decisions. Initial measures include clause coverage, material ambiguities detected, adjudication effort, false interpretations accepted, and time required to reach an approved UCS. The automated-importer variant repeats the exercise using the original document as input and measures the additional review effort and error profile. Passing requires that no known material ambiguity affecting the proposed implementation is silently treated as approved fact.

19.2 Stage two: restricted CSIR and single-transaction generation

The second study defines a runnable CSIR subset for New-Order and its database state, with machine-checkable types and selected invariants. It generates a PostgreSQL-backed handler and runs an independent test set. It must document both successful transaction behavior and invalid-item rollback. Acceptance requires complete traceability from every supported semantic obligation to its generated implementation artifact and verification evidence. A failure in an invariant, unsupported SQL effect, or transaction boundary returns the candidate for diagnosis. This stage isolates semantics and generation before workload-scale optimization enters the experiment.

19.3 Stage three: five-transaction application and concurrency

The third study adds Payment, Order-Status, Delivery, and Stock-Level, together with the full subset of required data and interactions selected for the approved TPC-C profile. It exercises concurrent updates, transaction mixing, contention, retry behavior, and database integrity. The independent evaluator uses seeded deterministic tests and randomized executions whose seeds and environments are recorded. This stage should compare results against a separate reference implementation and the original source clauses, particularly for unusual combinations of state and concurrent access. A representative error taxonomy distinguishes requirements-translation defects, generated-program defects, database-configuration problems, and invalid test expectations.

19.4 Stage four: performance, recovery, and adversarial assurance

The fourth study measures response-time distributions, NOPM, TPM, CPU, memory, storage, and error behavior using controlled TPROC-C configurations. It also conducts planned failure injection for interrupted work, crashes, restarts, and degraded services. Security testing probes authorization boundaries, injection resistance, dependency and artifact integrity, and attempts to exploit untrusted imported text. The benchmark report identifies every deviation from official TPC-C rules and uses the corresponding workload name and metrics [4, 5]. The research should report confidence intervals or repeated-trial variability where meaningful, especially when performance differences are small.

19.5 Stage five: controlled specification changes and regeneration

The fifth study introduces pre-approved changes in business rules, access permissions, resource constraints, and implementation targets. The team should classify which changes preserve TPC-C behavior and which create distinct, TPC-C-derived research workloads. Each change creates a new UCS identity and an explicit impact analysis. The system generates a new logical implementation and seeks renewal or justified reuse of affected evidence. Measures include human editing effort, regeneration time, detected semantic drift, invalidated proofs, regression incidence, and the number of unsupported assumptions discovered during the change. A comparison against conventional maintenance provides the economic baseline.

19.6 Stage six: an independently governed self-improvement experiment

The sixth study authorizes a narrowly scoped improvement to the engineering system, such as better requirements extraction, stronger automatically generated test cases, or more efficient tool orchestration. A separate evaluator with access to held-out tasks compares the candidate to a frozen baseline. The preregistered scorecard should include task quality, error detection, cost, compute time, manual review burden, and any regression in security or functional correctness. Promotion occurs only after the acceptance authority reviews the evidence and the production control plane verifies artifact identity. The candidate must be unable to change its evaluation criteria or grant itself deployment permission.

19.7 Stage seven: replication and growth of the supported domain

The final study asks independent teams to reproduce selected results from shared specifications, source material, implementation tools, and evaluation procedures. It then extends the architecture to a second application domain with meaningfully different semantics, such as an embedded control component or a constrained event-processing service. Cross-domain results test whether UCS concepts and agentic harnesses generalize or merely encode the first benchmark's assumptions. Success is a collection of separately supported claims, each with a declared scope, repeatable evidence, and a clear account of the work needed to broaden it.

The program should preregister acceptance thresholds before running decisive experiments. A recommended primary scorecard includes semantic coverage and accepted-meaning error rate, functional defect detection, assurance-case completeness, generation and regeneration labor, source-to-binary reproducibility, performance relative to a fixed baseline, cost per accepted change, and independently measured improvement gains. The thresholds depend on research resources and the selected platform; they should be established by the investigators and reviewers, then preserved as part of the experiment record. Report every relevant failure and inconclusive result alongside success. That record will reveal which mechanisms make a meaningful contribution and which require new science.

20. Research boundaries, objections, and the emergence horizon

Several unresolved questions deserve direct investigation. Natural-language specifications can contain hidden assumptions, contradictions, and goals that depend on human judgment. A universal semantic vocabulary may remain an evolving family of rigorously defined domains. General proofs of complex concurrent applications can be expensive and may depend on trusted components outside their scope. Compiler and hardware differences can introduce behavior that a high-level model omits. Learned systems can fail under distribution shift. Automatic evaluators can be manipulated by candidates optimized against known tests. These are concrete research challenges and should appear openly in every claim of progress.

Benchmark validity presents a special concern. A generator may optimize for a familiar workload in ways that have little value for general software engineering. The experimental program should withhold selected requirements and test cases during generation, perform independent reference comparisons, vary hardware and data scale, and introduce controlled changes that require genuine re-interpretation. Testing against a second domain and independent reproduction is essential before making generality claims. The separate use of TPC-C source clauses and HammerDB evaluation must remain transparent so that benchmark-based evidence is neither inflated nor dismissed.

A further concern is governance under recursive improvement. If the system becomes more capable at designing itself, it may also become more capable of exploiting weak evaluation or authorization procedures. The research design assumes that evaluation independence, external authorities, and trusted enforcement mechanisms can be preserved as the proposal expands. This assumption is testable through deliberate attempts to bypass them. The technology's eventual credibility will depend as much on the quality of those boundary tests as on the quality of the generated programs.

The potential consequence is substantial. A validated UCS could make explicit computational knowledge more portable than a particular source-code repository and more reusable across languages, tools, and execution platforms. As specification libraries, specialist models, compilers, verification systems, and hardware improve together, the cost of regenerating and assuring useful systems could decline. This is an emergence horizon in the author's technological-consequence framework: the prospect that converging advances create capabilities whose value grows through diffusion, synthesis, and compounding advancement [26]. The present article offers a research architecture and a disciplined path for finding out how far that prospect can be realized.

Conclusion

A software system can be represented as enduring computational intent together with versioned evidence about how that intent is implemented. The Universal Computational Specification supplies the authoritative package, the Canonical Semantic Intermediate Representation supplies its formal semantic core, and specialized engineering harnesses supply candidate implementations and distinct forms of assurance. Independent authorization and evaluation govern both application releases and modifications to the engineering system. Complete logical regeneration preserves the specification's authority while allowing practical reuse of artifacts whose validity can be demonstrated.

TPC-C provides a demanding external source document for the first sustained experiment. HammerDB supplies an established, separately identified tool for exercising a related transactional workload and recording measurements. The resulting research program can test document interpretation, semantic translation, source generation, formal properties, independent assurance, controlled change, and a bounded instance of cybernetic self-improvement. The scientific contribution will be measured by reproducible results, transparent limitations, and progress from one supported domain to another. Under those conditions, software engineering may acquire a durable foundation for systems that repeatedly learn to build better software—and, with accountable human governance, improve the processes by which they are built.

Appendix A. Illustrative artifact and task records

The following sample illustrates the information that should move between engineering harnesses. Field names and values are proposed for research design; they are a conceptual interchange sketch proposed for investigation:

TaskEnvelope {

  task_id: unique_id,

  approved_ucs: content_hash,

  csir_version: content_hash,

  source_requirements: [stable_requirement_id],

  task_kind: GENERATE | VERIFY | MEASURE | REVIEW,

  target: platform_and_toolchain_profile,

  allowed_tools: [scoped_capability_reference],

  resource_budget: bounded_execution_policy,

  expected_outputs: [artifact_contract],

  requested_assurance: [evidence_obligation]

}

 

ArtifactRecord {

  artifact_id: content_hash,

  producer: workload_identity_and_harness_version,

  source_inputs: [content_hash],

  semantic_coverage: [stable_requirement_id],

  declared_assumptions: [assumption_id],

  method_and_environment: versioned_test_or_build_profile,

  evidence: [signed_result_reference],

  state: CANDIDATE | VERIFIED_SCOPE | REJECTED | APPROVED

}

A governance review can verify that an ArtifactRecord refers to the approved UCS and contains evidence covering the claimed requirements. A generated test references its source obligation and independent oracle. A rebuilt binary references its source and toolchain identities. A promoted improvement references its experiment and approval. The same scheme provides an audit trail when a new specification invalidates some earlier evidence.

Appendix B. Experimental reporting discipline

Every reported run should state whether it was a semantic-translation experiment, a generated-application functional evaluation, a TPROC-C performance run, or a study seeking official TPC-C compliance. For a performance run, the report should state the exact workload generator, version, measurement interval, database engine and settings, hardware and operating system, data scale, concurrency, isolation semantics, retry behavior, and the precise metric definition. Results from HammerDB should use HammerDB's nomenclature and explain any configuration differences that could affect comparisons. Reproduction instructions should include source hashes, approved UCS version, tool versions, test scripts, and the criteria by which a run is accepted or rejected.

For a formal assurance result, the report should identify the property, scope, proof or checking tool, model assumptions, toolchain and trusted computing base. For a regulatory or accessibility assessment, it should identify the applicable framework version, the evaluated product features, the methods used, the human assessment performed, and any organizational obligations outside the generated software. For a self-improvement experiment, it should identify the frozen baseline, candidate mechanism, separation of training and evaluation tasks, predeclared metrics, independent acceptance authority, deployment scope, and rollback plan. This discipline permits readers to recognize exactly what a result establishes and to design better experiments that extend it.

References

[1] Transaction Processing Performance Council. TPC Benchmark C: Standard Specification, Revision 5.11.0 (listed current November 10, 2026; PDF bearing Revision 5.11, February 2010). https://www.tpc.org/TPC_Documents_Current_Versions/pdf/tpc-c_v5.11.0.pdf

[2] Transaction Processing Performance Council. TPC Current Specifications and Source Code. https://tpc.org/TPC_Documents_Current_Versions/current_specifications5.asp

[3] Transaction Processing Performance Council. TPC-C Homepage and Benchmark Overview. https://www.tpc.org/tpcc/

[4] HammerDB. Comparing HammerDB Results, HammerDB documentation, chapter 3, section 4. https://www.hammerdb.com/docs/ch03s04.html

[5] HammerDB. TPROC-C Key Similarities and Differences from TPC-C, documentation, chapter 3, section 6. https://hammerdb.com/docs/ch03s06.html

[6] TPC-Council. HammerDB Result Artifacts: User-Submitted, Unaudited Benchmark Results. https://tpc-council.github.io/hammerdb-results/index.html

[7] Samuel Kushnir, Kimia Noorbakhsh, Kavya Sreedhar, Liqun Cheng, Ming Liu, Parthasarathy Ranganathan, Mohammad Alizadeh, Fred Kjolstad, and Suvinay Subramanian. Design Docs Are All You Need: An AI-native Machine-Learning Performance Tool. arXiv:2609.05364, September 2026. https://arxiv.org/abs/2609.05364

[8] LLVM Project. MLIR Language Reference. https://mlir.llvm.org/docs/LangRef/

[9] seL4 Foundation. seL4 Proofs. https://sel4.systems/Verification/proofs.html

[10] seL4 Foundation. What the Proofs Assume. https://www.sel4.org/Verification/assumptions.html

[11] CompCert Project. The CompCert Verified Compiler: Documentation. https://compcert.org/doc/

[12] Scott Rose, Oliver Borchert, Stuart Mitchell, and Sean Connelly. Zero Trust Architecture. NIST SP 800-207, 2020. https://doi.org/10.6028/NIST.SP.800-207

[13] Elham Tabassi, editor. Artificial Intelligence Risk Management Framework (AI RMF 1.0). NIST AI 100-1, 2023. https://doi.org/10.6028/NIST.AI.100-1

[14] National Institute of Standards and Technology. Security and Privacy Controls for Information Systems and Organizations. NIST SP 800-53, Revision 5. https://doi.org/10.6028/NIST.SP.800-53r5

[15] World Wide Web Consortium. Web Content Accessibility Guidelines (WCAG) 2.2, W3C Recommendation, updated December 12, 2024. https://www.w3.org/TR/WCAG22/

[16] PCI Security Standards Council. Payment Card Industry Data Security Standard (PCI DSS), program information and current document downloads. https://www.pcisecuritystandards.org/document_library/

[17] U.S. Department of Health and Human Services. Summary of the HIPAA Security Rule. https://www.hhs.gov/hipaa/for-professionals/security/laws-regulations/index.html

[18] AICPA & CIMA. SOC 2 and the Trust Services Criteria, program and standards information. https://www.aicpa-cima.com/resources/landing/system-and-organization-controls-soc-suite-of-services

[19] PostgreSQL Global Development Group. PostgreSQL Documentation: Transaction Isolation. https://www.postgresql.org/docs/current/transaction-iso.html

[20] PostgreSQL Global Development Group. PostgreSQL Documentation: Reliability and the Write-Ahead Log. https://www.postgresql.org/docs/current/wal-reliability.html

[21] Microsoft Research. Z3: An Efficient SMT Solver. https://www.microsoft.com/en-us/research/project/z3-3/

[22] Reproducible Builds Project. Definitions: When Is a Build Reproducible? https://reproducible-builds.org/docs/definition/

[23] Supply-chain Levels for Software Artifacts (SLSA). SLSA Specification, Version 1.2. https://slsa.dev/spec/v1.2/

[24] Kimi Team and collaborators. Kimi Linear: An Expressive, Efficient Attention Architecture. arXiv:2510.26692, 2025. https://arxiv.org/abs/2510.26692

[25] OWASP Foundation. Application Security Verification Standard, Version 5.0.0. https://asvs.owasp.org/

[26] Dennis C. Hayes. The General Architecture of Technological Consequence: The Consequences of Innovation, September 8, 2026. https://spartansfirst.org/ArchitectureofTechnologicalConsequence

[27] Matt Ridley. How Innovation Works: And Why It Flourishes in Freedom. Harper, 2020. https://www.mattridley.co.uk/blog/introducing-how-innovation-works/

[28] TPC-Council. HammerDB, open-source source-code repository. https://github.com/TPC-Council/HammerDB

[29] Transaction Processing Performance Council. HammerDB Artifact Results, TPC open-source initiative. https://tpc.org/opensource/opensource5.asp

[30] Transaction Processing Performance Council. TPC Fair Use Policies and Benchmark Reporting Guidance. https://www.tpc.org/TPC_Documents_Current_Versions/pdf/Fair_Use_Quick_Reference_v1.0.0.pdf

[31] Rikiya Takehi, Jayden Teoh, Alex Zhang, and Omar Khattab. Sparks of Weight-Space Programming: LLMs Can Natively Read & Write Neural Network Weights. MIT CSAIL research discussion, November 2, 2026. https://rikiyat.github.io/blog/weight-space-programming/