https://chatgpt.com/share/6a367102-293c-83eb-a4a1-7c4b59981476  
https://osf.io/ne89a/files/osfstorage/6a3670ec9f05c74aeb1cd36f

From Imaginary-Time Multiplication to Semantic Invariants

An Operator-First Method for Finding Effective Coordinates, Invariants, and Semantic Density in Markets, AI, and Organizations

Abstract

Imaginary time is often introduced through formal substitution, complex eigenvalues, Wick rotation, or the transformation of oscillatory propagation into exponential suppression. These ideas are mathematically powerful, but they become difficult to interpret when extended into macroscopic systems such as financial markets, artificial-intelligence agents, organizations, biological checkpoints, and social institutions. What does it mean for imaginary time to operate in a macro-system? More importantly, what is the multiplication operation that makes such a system imaginary-time-like?

This article proposes an operator-first answer. Instead of beginning with a pre-assumed semantic spacetime or a general-relativity-like interval such as dx² + dy² + dz² + (idT)², we begin with the local multiplication operator that produces the algebraic signature of imaginary time. In a bounded self-referential system, a directive or evaluative pressure λ pushes a realized structure s; the realized structure then returns pressure to λ. If the return path corrects the original pressure, the doubled Signal–Structure system supports an elliptic signature. If the return path confirms the original pressure, it supports hyperbolic selection.

The central local operator is the signed conjugacy operator:

(0.1) C_χ = [[0,F],[χM,0]].

Here F maps Signal displacement into structural displacement, M maps structural displacement back into Signal displacement, and χ records the orientation of the return path. If F = M⁻¹, then:

(0.2) C_χ² = χIdentity.

When χ = −1, the system has a local complex structure:

(0.3) C₋² = −Identity.

This is the macro-analogue of multiplication by i. The directional sequence is:

(0.4) δλ → δs → −δλ → −δs → δλ.

When χ = +1, the system has a hyperbolic selector:

(0.5) C₊² = +Identity.

The directional sequence becomes:

(0.6) δλ → δs → +δλ → +δs.

This article uses that distinction to build a research path from imaginary-time multiplication to semantic invariants. The argument proceeds in four stages.

First, the multiplication operator must be identified. One must find the conjugate variables λ and s, estimate their two-way response, and test whether C_χ² is locally negative, zero, or positive.

Second, the effective coordinates of the system must be discovered, not assumed. The diagnostic triple Ξ = (ρ,γ,ν) is not the same as (x,y,z). It is a protocol-bound diagnostic compass that helps locate loading, lock-in, and agitation. Effective coordinates X = (x,y,z,...) should instead be extracted from the dominant invariant subspaces of C_χ.

Third, invariants should be searched only after the multiplication operator and effective coordinates are known. A candidate invariant is a quantity, relation, or operator pattern preserved under admissible frame, protocol, or declaration transformation.

Fourth, semantic density should be defined as a local information price. Under a declared protocol P, baseline q, feature map φ, and tilted distribution p_λ, semantic density may be written as:

(0.7) ρ_sem(x;P) = p_λ(x) log[p_λ(x)/q(x)].

The global semantic price of maintaining structure is:

(0.8) Φ_P(s) = ∫ρ_sem(x;P)dμ(x).

The article’s guiding thesis is therefore:

(0.9) Operator first, coordinates second, invariant third, density fourth.

This does not prove that markets, AI systems, organizations, or biological systems are literal relativistic spacetimes. It proposes a disciplined method for asking whether they contain measurable signature-bearing operator grammar: corrective circulation, hyperbolic selection, declaration, ledger birth, and inherited child-time dynamics.

 

---

0. Reader’s Guide: Why This Article Begins with Multiplication, Not Spacetime

0.1 The temptation of semantic spacetime

Once a theory begins speaking of imaginary time, signature transitions, Wick-like rotation, ledgered time, and child-world dynamics, it is tempting to jump directly to a spacetime formula.

One may ask:

(0.10) Is there a semantic invariant like dx² + dy² + dz² + (idT)²?

Or:

(0.11) Is there a general-relativity-like metric for markets, AI agents, or institutions?

These are natural questions. They are also dangerous if asked too early.

The danger is that one may import the shape of a physical theory before identifying the operation that makes that shape meaningful. In physical mathematics, the symbol i is not a decoration. It expresses a specific algebraic structure. Multiplication by i rotates a state into a conjugate direction; multiplication by i again reverses the original direction.

The important identity is not merely:

(0.12) i² = −1.

The important structure is:

(0.13) one application rotates; two applications reverse.

If a macro-system is to be called imaginary-time-like, we must first identify what performs this rotation and reversal inside that system.

This article therefore does not begin with semantic spacetime. It begins with the multiplication operator.

0.2 The corrected order of inquiry

The corrected order is:

(0.14) multiplication operator → effective coordinates → invariant search → semantic density.

This order matters.

If we begin with an assumed metric, we may force a system into an attractive analogy. We may call three variables x, y, and z simply because physical space has three coordinates. We may call a hidden pressure iT simply because the theory needs an imaginary-time-like axis. We may then mistake naming for discovery.

The operator-first approach prevents that error.

It asks first:

(0.15) What local operation maps Signal into Structure and Structure back into Signal?

Then:

(0.16) Does applying that operation twice reverse the original direction, preserve it, or collapse it?

Then:

(0.17) Which coordinates make that operation simple?

Only after those questions have been answered should we ask:

(0.18) What invariant, if any, is preserved under admissible transformations?

0.3 Three kinds of coordinates

A major point of this article is that three kinds of coordinates must not be confused.

First, there are raw observable coordinates. These are the directly recorded quantities: prices, volumes, order flow, news counts, verifier scores, budget entries, meeting logs, transaction records, court filings, biological markers, and so on.

Second, there are diagnostic coordinates. In the PORE/Gauge Grammar style, these may be compressed into a triple such as:

(0.19) Ξ_P = (ρ_P,γ_P,ν_P).

Here ρ means loading, occupancy, or concentration; γ means lock-in, binding, boundary strength, or constraint rigidity; ν means agitation, turbulence, dephasing, or churn. The letter ν is used here instead of τ to avoid confusion with ledgered time.

Third, there are effective world-coordinates:

(0.20) X_P = (x₁,x₂,...,x_N).

These are not raw observables and not diagnostic summaries. They are the coordinates in which the system’s local dynamics become simplest, most stable, or most invariant.

The key distinction is:

(0.21) Ξ_P ≠ X_P.

The diagnostic triple helps find effective coordinates. It is not itself the effective coordinate system.

0.4 The heliocentric analogy

The distinction can be understood through the history of astronomy.

A geocentric observer sees complicated planetary motion from the Earth. The raw observables are real. The records are not fake. The problem is that the frame is not dynamically simple.

A heliocentric protocol changes the declared center and boundary. It does not merely rename the old coordinates. It changes the perspective so that a simpler dynamical structure becomes visible.

Likewise, PORE is not a trick for renaming market variables. It is a method for declaring the system boundary, observation rule, time window, and admissible intervention family so that false coordinate centers can be detected.

In this sense:

(0.22) PORE is heliocentric discipline.

And:

(0.23) Ξ is a diagnostic compass.

But:

(0.24) X is the effective coordinate system discovered after the compass has done its work.

0.5 The article’s path

The article proceeds through the following movement:

(0.25) Raw traces O_P → declared protocol P → Ξ diagnostic → signed operator C_χ → effective coordinates X_P → selection depth σ → invariant test → semantic density.

This path is deliberately conservative. It does not claim that every oscillation is imaginary time. It does not claim that every positive feedback loop is Wick-like. It does not claim that every complex system has a relativistic metric.

It asks a narrower question:

(0.26) Can a bounded self-referential system contain a measurable multiplication operator whose square reveals the local signature of correction, criticality, or selection?

If yes, the search for semantic invariants becomes concrete.

Recursive Self-Reference and the Emergence of Imaginary-Time Depth: Wick-Like Signature Transitions from Market Herding to AI Verifier Capture

https://chatgpt.com/share/6a35cdc5-f2f0-83eb-9315-15442aa0bbe3 
https://osf.io/ne89a/files/osfstorage/6a35ccd6a3d90927702bf2e9

Recursive Self-Reference and the Emergence of Imaginary-Time Depth

Wick-Like Signature Transitions from Market Herding to AI Verifier Capture

Abstract

Imaginary time is mathematically useful because it can transform oscillatory propagation into exponential suppression and selection. In conventional physical applications, Wick continuation replaces a real-time coordinate with an imaginary-time coordinate, changing the effective signature of the evolution operator. Modes that coexist through oscillation in one representation become differentially attenuated in another. Yet when this mathematical grammar is extended to biological, financial, organizational or artificial-intelligence systems, a fundamental question remains unanswered: what does it mean for macro-level imaginary time to advance?

This article proposes that a large and experimentally accessible class of imaginary-time-like macro-systems may arise from recursive self-reference. At the macro level, such a system is governed by an implicit self-consistency relation: beliefs affect actions, actions alter the world, and the altered world changes the beliefs used to interpret it. The relation appears circular and may contain no explicit internal chronology. At the microscopic level, however, bounded agents implement that circular relation through ordered operations in physical time. Investors observe, predict, trade and observe again. Artificial agents generate, critique, verify and revise. Each microscopic action occurs in ordinary time, while their recursive composition attempts to solve a macro-level closure problem.

The article distinguishes three non-equivalent temporal coordinates. Physical time t measures execution duration. Selection depth σ measures the accumulated suppression of incompatible possibilities during recursive closure. Ledgered time τ orders events that have crossed a declaration gate and become causally binding. The proposed sequence is:

Microphysical execution → recursive self-reference → imaginary-time selection depth → declaration → ledgered child time. (0.1)

Under this interpretation, imaginary-time depth does not measure how long a system has been running. It measures how far a distribution of unresolved possibilities has been compressed. A million microscopic operations may produce little selection if they repeatedly revisit the same alternatives. A single decisive verification may produce a large increment in σ if it eliminates an entire class of candidates.

The mathematical bridge is supplied by a signed self-reference operator. If the consequence of a system’s output generates pressure against its previous direction, the loop is self-negating and supports elliptic correction. If the consequence becomes evidence supporting the output that produced it, the loop is self-confirming and supports hyperbolic selection. A change between these orientations produces a Wick-like signature transition.

Financial herding provides an intuitive macro-example. Expectations influence orders, orders influence prices, and prices become evidence used to revise expectations. Artificial intelligence provides a more controllable laboratory. A coding agent can generate an artifact, evaluate it, revise it and eventually commit it. If its verifier remains externally anchored, the recursive loop may remain corrective. If the agent can modify or capture its own verifier, its output may become evidence for its own correctness, producing exponential confidence without corresponding external validity.

The resulting hypothesis is deliberately falsifiable. It predicts measurable mode suppression, complex-to-real eigenvalue migration, critical slowing near signature change, recovery asymmetry, recursive-depth scaling, gate-induced hysteresis and calibrated inheritance between pre-transition oscillation, incubation selection and post-commitment cadence. If these signatures cannot be distinguished from ordinary optimization, positive feedback, Bayesian updating or generic fixed-point iteration, the proposed imaginary-time interpretation should be rejected or reduced to metaphor.

Keywords: imaginary time, self-reference, Wick rotation, recursive selection, artificial intelligence, verifier capture, market herding, Gödelian residual, ledgered time, signature transition

 

1. The Missing Kinematics of Macro-Imaginary Time

https://chatgpt.com/share/6a359b92-042c-83eb-bb3e-51b9a22b7c15  
https://osf.io/ne89a/files/osfstorage/6a359ca6b73ce100911cd299 

When Oscillation Becomes Law: The Wick-Ledger Conjecture Beyond Nested Uplifts

A Signature-Bearing Theory of Imaginary-Time Transmutation in Biology, Markets, and Human Organizations

Abstract

Nested Uplifts Inevitability, or INU, provides a general account of how open systems accumulate deviation, cross evidence thresholds, change regimes, stabilize new residual structures, and repeat this process across nested scales. It explains why a system may pass from one effective world into another. It does not, however, determine whether the new world’s time is related to the parent world through a change of dynamical signature. A regime switch need not be a Wick rotation. A new organizational clock need not originate from the imaginary-time sector of its parent system.

This article proposes a stronger and narrower conjecture: the Wick-Ledger Conjecture. It defines a Signature-Bearing Uplift as a transition in which a conjugate oscillatory mode of a parent system undergoes a change from elliptic circulation to hyperbolic selection, is committed through a declaration gate, and reappears as part of the causal generator of a newly ledgered child system.

The proposed sequence is:

Oscillation → Phase Concentration → Signature Inversion → Hyperbolic Selection → Declaration Gate → Ledger Birth → Generator Inheritance → Child Time.

The conjecture begins from a precise distinction. Multiplication by i is not equivalent to sudden change, exponential growth, high complexity, or hidden computation. The relation i² = −1 expresses a complex structure: one application rotates a state into a conjugate direction, while a second application reverses its original orientation. In dynamical systems, this structure commonly appears through oscillatory eigenvalues. By contrast, real eigenvalues generate exponential amplification and suppression. A Wick-like transition becomes meaningful only when the same underlying coupling can be identified first as an oscillation frequency and later as a growth or decay rate.

The article anchors this proposal in four levels of decreasing certainty. At the first level, the harmonic oscillator, Wick rotation, elliptic-hyperbolic classification, and reversible-irreversible decomposition provide mature mathematical and physical foundations. At the second level, biological systems provide experimentally constrained extensions: segmentation clocks convert oscillatory phase into stable morphological boundaries, while bistable cell-cycle checkpoints convert continuous biochemical states into irreversible phase histories. At the third level, financial markets provide a quantitatively richer macroscopic laboratory in which Signal, price structure, liquidity, leverage, volatility, residual order flow, and transaction ledgers can be operationally distinguished. At the fourth and most conjectural level, human organizations are modeled as systems in which mandate, legitimacy, institutional structure, coordination cost, dissent, declaration, and procedural memory may undergo comparable signature-bearing transitions.

The central claim is not that firms, markets, embryos, or institutions are literally quantum systems. It is that complex structure, hyperbolic selection, ledger formation, and endogenous time may compose into a recurrent cross-scale grammar. If so, some organizational transformations would be more than ordinary INU events. They would involve the transmutation of a parent system’s oscillatory tension into an incubation process that exponentially selects one institutional mode, after which that selected mode becomes law-like inside a new organizational boundary.

The conjecture is designed to be falsifiable. It predicts complex-to-real eigenvalue migration, frequency-rate inheritance, phase-lag structure, susceptibility growth, option extinction, declaration discontinuity, endogenous cadence, hysteresis, residual extrusion, and measurable inheritance between pre-uplift dynamics and post-uplift organizational law. If these signatures cannot be distinguished from ordinary positive feedback, Hopf bifurcation, punctuated equilibrium, or generic INU regime switching, the conjecture must be rejected or reduced to a metaphor.

Keywords: imaginary time, Wick rotation, nested uplifts, organizational emergence, Signal-Entropy conjugacy, complex structure, hyperbolic selection, ledgered time, biological clocks, financial bubbles, institutional formation

 

1. The Missing Step Beyond Nested Uplifts

https://chatgpt.com/share/6a2c7796-c5b8-83eb-aa1d-4e9fec25b742  
https://osf.io/hj8kd/files/osfstorage/6a2c77608dd4dca4d18b879b

I’ll start the article in normal response format. This opening follows Part 1’s runtime grammar of declared projection, gate, trace, residual, ledger, and revision.

Enactive Artificial Intelligence as Self-Correcting World-Making: Gate Residuals, Admissible Revision, and Strong-Attractor Projection

From Ledgered Action to Evolvable Runtime Protocols

---

Abstract

The first part of this series argued that Enactive Artificial Intelligence becomes experimentally mature when active engagement is converted into a declared, trace-bearing, residual-honest runtime architecture. It proposed a loop:

(0.1) Field → Declaration → Projection → Gate → Trace + Residual → Ledger → Revision.

This second part asks the next question.

What happens when the loop itself is imperfect?

A Gate can approve too early or block too much. A Residual taxonomy can miss the real unresolved issue or produce useless caution notes. A Revision rule can improve the system, but it can also create policy drift, infinite loops, self-justification, or trace erasure. A Projection instruction can stabilize the agent’s perception, but it can also produce unstable collapse, frame drift, or inconsistent outputs across repeated runs.

These are not external objections to the SMFT-Enactive architecture. They are the next layer of residual inside it.

The central thesis of this article is:

(0.2) Mature Enactive AI is not a system with perfect gates, complete residual categories, stable projections, or flawless revision rules.

(0.3) Mature Enactive AI is a system that can discover the residuals of its own protocol, preserve them as trace, and revise its world-making machinery without erasing accountability.

This article introduces four second-order concepts: Protocol Residual, Meta-Gate, Residual Mining, and Strong-Attractor Projection. It also distinguishes two kinds of projection stability. Some prompts or instructions are stable because historical trace has already shown that they repeatedly collapse comparable tasks into a reliable output basin. This is Trace-Proven Stability. Others are only estimated to be stable because their structure resembles known attractor-forming forms. This is Structure-Inferred Stability. The same distinction applies to instability: some fragility is known by prior failures, while some fragility is predicted from structural warning signs.

The practical result is an evolvable runtime discipline:

(0.4) InitialProtocol → Application → ProtocolResidual → Trace → MetaGate → AdmissibleRevision → UpdatedProtocol.

The article’s claim is not that AI agents can become safe by unlimited self-modification. The opposite is true. Self-correction is dangerous unless it is gated, trace-preserving, residual-honest, testable, and reversible where possible. The goal is therefore not unconstrained self-improvement, but accountable protocol evolution.

In this view, civilization itself becomes the precedent. Law, medicine, accounting, military doctrine, education, and factory operations are not mature because their initial rules were perfect. They are mature because their failures became trace, their trace became residual categories, and their residual categories eventually revised their gates.

The same logic now becomes necessary for AI agents.

A mature Enactive AI must not only act in the world. It must learn how its own way of making a world fails.

 

Gemini Comments on "SMFT turns Enactive AI into a testable runtime architecture"

Does this article provide any valuablel insights to current AI/AGI development?  

Enactive Artificial Intelligence as Ledgered World-Making: An SMFT Framework for Action, Trace, Residual, and Self-Maintaining Agents 
https://osf.io/hj8kd/files/osfstorage/6a29d8138f5abdf103d14ddb

 

Yes, this article provides highly valuable, actionable insights for current AI/AGI development. It bridges the gap between cognitive philosophy (Enactive AI) and practical software engineering, offering a rigorous structural blueprint for building more reliable, self-correcting, and autonomous AI agents.

Rather than treating "embodiment" or "experience" as vague metaphors, it translates them into a concrete runtime architecture using Semantic Meme Field Theory (SMFT).

Here is a breakdown of the most valuable insights and how they apply to the state of AI in 2026:

1. Redefining "Embodiment" for Software Agents

A major critique of traditional Enactive AI is that it requires a physical body (like a robot or a biological organism) to truly "perceive" and "act." This article brilliantly bypasses this limitation by introducing the concept of the Operational Body for software.

• The Insight: A software agent's body is the sum of its maintained runtime structures: context windows, APIs, file permissions, memory retrieval tokens, and compute budgets.

• Value to Current Dev: Instead of treating tool use as a "magical capability access" (e.g., just calling an API), developers are given a Tool-Body Map formula. A tool must have a declared boundary, cost, risk, failure mode, and recovery protocol to be safely integrated into an agentic workflow.

2. Memory vs. "Trace" (The Curvature of Experience)

Current LLM agents handle memory passively—either by appending chat history or pulling raw chunks from a vector database (RAG).

• The Insight: Memory is not experience. It only becomes experience if it acts as a Trace—past records that actively bend or constrain future projection, gating, and action ($\partial \text{Future Policy} / \partial \text{Trace} \neq 0$).

• Value to Current Dev: It outlines a shift from dumping raw text into a context window to building Trace Ledgers. A trace record must include the cause, gate status, outcome, and most importantly, a future constraint (e.g., "Source A failed because it lacked 2026 data; future queries on this topic must use Source B").

3. "Residual Governance" as a Safety Primitive

AI models are currently engineered to be "fluent closers"—they are optimized to smoothly generate answers, frequently resulting in hallucinations because they collapse uncertainty too early.

• The Insight: Every action or answer produces a partial closure, leaving behind an unresolved remainder (Residual). True maturity is not achieving total closure, but the disciplined management of what remains outside that closure.

• Value to Current Dev: It introduces Residual Honesty into agent architecture. Agents must track what they don't know (missing evidence, ambiguous user intentions, contested interpretations) and carry that residual forward to explicitly constrain future gates or trigger human escalations.

4. Upgrading Reinforcement Learning (RL)

While RL introduces an agent-environment loop, the article accurately diagnoses its current architectural blind spots.

• The Insight: RL is adaptive but not necessarily self-maintaining. Optimizing for a scalar reward often leads to "reward hacking" because the scalar compresses and hides massive residual risks or environmental drift.

• Value to Current Dev: It proposes upgrading from a Reward Policy to a Ledger Policy. Actions shouldn't just maximize expected reward; they must evaluate task gain against resource dissipation, hidden residual risk, and trace damage.

5. A Concrete, Testable Runtime and Benchmark Suite

The most valuable part of the article for engineers is that it leaves no room for vague interpretation. It provides an immediate, testable framework.

• The Loop: It expands the naive Observe → Think → Act paradigm into the Declared Enactive Runtime Loop:

  $$\text{Field} \rightarrow \text{Declaration} \rightarrow \text{Projection} \rightarrow \text{Gate} \rightarrow \text{Trace} + \text{Residual Ledger} \rightarrow \text{Revision}$$

• The Benchmarks: It establishes five highly practical benchmark families (Action-Perception Coupling, Residual-Honesty, Tool-Body Embodiment, Self-Maintenance Audits, and Gauge Robustness) to test whether an SMFT-declared agent actually outperforms a standard ReAct or RAG agent in long-horizon task coherence and safety.

Summary for an AI Engineer

If you are building LLM agents, coding assistants, or enterprise workflow automation today, this article argues that your systems are fragile because they lack an epistemic accounting system.

By implementing the Minimal Runtime Architecture outlined in Appendix B—specifically splitting your agent's state into a strict Declaration State, a Trace Ledger, and a Residual Ledger—you move away from prompt fragility and toward an agent that can form, maintain, and revise its operational world responsibly.

Would you like to explore how to implement one of the specific modules from the appendix, such as the Tool-Body Map or the Gate Module, using current developer frameworks?

 

You mean this article clarified may open questions that the author of 

Toward Enactive Artificial Intelligence

want to answer but did not provide answers?

https://chatgpt.com/share/6a29d90d-a6d4-83ed-8049-69d4e8a4ca1d  
https://osf.io/hj8kd/files/osfstorage/6a29d8138f5abdf103d14ddb  
Toward Enactive Artificial Intelligence

Enactive Artificial Intelligence as Ledgered World-Making: An SMFT Framework for Action, Trace, Residual, and Self-Maintaining Agents

From Active Perception to Declared Runtime Protocols

Abstract

Enactive Artificial Intelligence begins from a powerful correction to mainstream AI: intelligence should not be understood as passive representation followed by output generation. Perception is not the construction of an internal picture from sensory input. It is active, situated, embodied engagement with the world. An agent perceives by acting, and acts by perceiving. The world that matters to the agent is not merely a pre-given dataset, but a field of affordances disclosed through ongoing interaction.

This article accepts the enactive turn as a necessary step for AI. However, it argues that Enactive AI still needs a sharper operational grammar if it is to become a mature engineering program. Concepts such as experience, action–perception inseparability, autonomy, and embodiment are philosophically rich, but they remain under-specified for practical AI runtime design. How should an AI system declare its body? How should its action reshape future observation? When does memory become experience? What distinguishes task completion from autonomy? How can an agent preserve uncertainty instead of collapsing every situation into fluent answerhood?

Semantic Meme Field Theory, or SMFT, supplies one possible answer. SMFT treats perception as declared projection, experience as trace, embodiment as operational body, autonomy as governed self-maintenance, and action as a gated intervention that must leave trace and residual. In this view, an agent does not simply receive the world. It declares a boundary, projects a field, gates commitment, writes trace, preserves residual, and revises itself under admissible constraints.

The core proposal is:

(0.1) Enactive AI gives the direction: cognition = active world-engagement.

(0.2) SMFT gives the operational loop: Field → Declaration → Projection → Gate → Trace + Residual → Ledger → Revision.

(0.3) Mature Enactive AI = active engagement + declared protocol + trace ledger + residual governance + self-maintenance.

This article therefore reframes Enactive AI as ledgered world-making. A mature AI agent is not merely a model that answers, a policy that maximizes reward, or a tool-user that executes actions. It is a bounded world-forming system whose actions reshape future disclosure, whose experience is stored as future-causal trace, whose body is its maintained runtime structure, and whose autonomy depends on its ability to preserve coherence under budget, drift, failure, and residual uncertainty.

The practical result is a research program that can be tested today. Current LLM agents, RAG systems, tool-use systems, workflow agents, and reinforcement learning environments can be compared under SMFT-inspired benchmarks: action–perception coupling, residual-honest answering, tool-body embodiment, self-maintenance audits, and gauge robustness under equivalent task framings.

The article’s central thesis is simple:

(0.4) Enactive AI becomes experimentally mature when active engagement is converted into declared, trace-bearing, residual-honest runtime architecture.

 

---

https://chatgpt.com/share/6a21276e-ed1c-83eb-91de-41236251a75b  
https://osf.io/q8egv/files/osfstorage/6a20b02ef378e08fb9a94d5a

ENIAC/IAS-Style State-Transition Protocols for Reliable AI Agent Execution

A White Paper on Strict Skill Engineering, Agent Control Kernels, and the “Today” Opportunity

Abstract

AI agents are becoming capable enough to perform multi-step coding, analysis, document, and business-process tasks, yet their reliability remains uneven. The central weakness is not merely model intelligence, but execution discipline: agents often drift from instructions, skip implicit assumptions, over-edit, fail to preserve state, or self-declare success without verifiable evidence.

This paper proposes ENIAC/IAS-style state-transition protocols as a practical control layer for AI agents. The core idea is to convert ordinary natural-language tasks and reusable agent skills into explicit execution protocols of the form:

input state → operation step → output state → verification gate → next state

Two execution modes are proposed. ENIAC-mode represents fixed, linear, no-branch procedures where the plan is effectively “wired” before execution. IAS-mode represents stored-program execution with explicit program counter, branching, flags, validation, and recovery logic. Together, these modes provide a conceptual and practical grammar for making AI agents more stable, auditable, and reusable.

The paper further argues that the opportunity is especially urgent “today” because three forces have converged: many programmers are underemployed or displaced by AI pressure, enterprises urgently need stable AI automation, and current agent tools already expose enough extension mechanisms—skills, hooks, subagents, project instructions, scripts, and tool calls—to implement a first generation of strict agent workflows. This creates a short but significant window for programmers to become Agent Skill Engineers: professionals who translate messy human/business tasks into strict, reusable, verifiable AI execution protocols.

 

---

1. Problem Statement: AI Agents Are Powerful but Not Yet Procedurally Stable

Modern AI coding agents can read codebases, edit files, run commands, generate pull requests, and automate multi-step developer workflows. They are no longer merely autocomplete systems. They are increasingly autonomous task executors. [S1]

However, autonomy introduces a new class of problems:

1. The agent may misunderstand the task boundary.

2. The agent may silently make assumptions.

3. The agent may skip planning or revise the plan during execution.

4. The agent may change unrelated files.

5. The agent may claim completion without adequate evidence.

6. The agent may pass through a failure state without stopping.

7. The agent may rely on self-audit rather than external validation.

8. The agent may produce useful output once, but fail to reproduce the same procedure reliably.

These are not only “prompting problems.” They are execution-control problems.

Traditional software engineering solved similar problems through concepts such as preconditions, postconditions, invariants, transactions, logs, test suites, rollback, schemas, interfaces, and state machines. AI agents need a comparable procedural discipline.

This paper argues that the next practical reliability jump for AI agents will come from treating agent work not as free-form conversation, but as controlled state transition.

---

2. Core Thesis

The core thesis is:

AI agent skills should be engineered as verifiable state-transition protocols, not merely as reusable prompt instructions.

A skill should not merely say:

“Review this code carefully and fix any bugs.”

Instead, it should define:

Input State:
- Source files provided.
- Error message provided.
- Runtime or database engine known.
- Scope of allowed edits specified.

Step:
- Inspect only.
- No code modification allowed.

Output State:
- Module inventory.
- Suspected failure regions.
- Missing information.
- Risk level.

Gate:
- Do not proceed to modification unless evidence exists.

This transforms the agent from a loose assistant into a bounded execution worker.

In short:

Normal Agent Skill:
instruction → action → answer

Strict Agent Skill:
input state → operation → output state → validator → next step

---

3. ENIAC-Mode: Fixed Wiring for Linear Procedures

ENIAC-mode is used for tasks that can be expressed as a fixed sequence of steps with little or no branching.

Examples include:

• formatting files,

• generating documentation from a fixed template,

• converting schema A to schema B,

• applying known lint rules,

• producing a standard audit report,

• scanning a workbook using a defined checklist,

• extracting fields into a known JSON schema.

The metaphor is that the plan is “wired” before execution. Once the plan is frozen, the agent should not invent new steps unless a failure gate explicitly allows escalation.

A typical ENIAC-mode protocol is:

P0 SPEC
→ P1 PLAN FREEZE
→ P2 EXECUTE TRACE
→ P3 AUDIT

Each step has one expected input state and one expected output state.

Example:

Step 1:
Input State:
- Excel workbook is available.
- Target worksheet name is known.

Operation:
- Inspect headers only.

Output State:
- Header list.
- Column index map.
- Missing required columns.

Validator:
- Every reported header must exist in the inspected worksheet.

ENIAC-mode is especially effective where repeatability matters more than creativity.

Its strength is simplicity:

No hidden branches.
No vague progress.
No silent plan mutation.
No uncontrolled scope expansion.

---

4. IAS-Mode: Stored-Program Execution for Branching Procedures

IAS-mode is used when the task may require conditional branching, loops, retries, or failure handling.

Examples include:

• debugging SQL errors,

• fixing failing tests,

• migrating code between frameworks,

• refactoring multi-file modules,

• diagnosing build failures,

• implementing a feature with test feedback,

• resolving ambiguous legacy behavior.

IAS-mode treats the skill as a stored program. The agent has an explicit current step, allowed operations, flags, and branching rules.

A simplified IAS-style protocol contains:

STATE:
- PC: current step
- FLAGS: success/failure/uncertain
- MEMORY: accumulated facts, files, test results, assumptions
- LOG: append-only execution trace

OPCODES:
- INSPECT
- LOCALIZE
- HYPOTHESIZE
- PATCH
- TEST
- VERIFY
- REPORT
- ASK_USER
- HALT

INVARIANTS:
- Do not patch before evidence.
- Do not proceed after failed validation.
- Do not alter unrelated files.
- Do not convert hypothesis into confirmed fact.

A typical IAS loop is:

fetch current step
→ decode operation
→ execute bounded action
→ validate output state
→ update flags
→ branch, continue, ask user, or halt

IAS-mode is the natural mode for real programming work, because debugging and refactoring are rarely purely linear.

---

5. From Prompt Skill to State Skill

Most current agent skills are still written as rich instructions. This is useful, but incomplete. A stricter skill requires a grammar.

A proposed Strict Skill Schema includes:

skill:
  name:
  purpose:
  scope:
  risk_level:

input_state:
  required:
  optional:
  forbidden_assumptions:

allowed_operations:
  - INSPECT
  - PATCH
  - TEST
  - REPORT

forbidden_actions:
  - rewrite unrelated modules
  - delete files without explicit permission
  - claim test success without command output

steps:
  - id:
    mode:
    input_required:
    operation:
    output_required:
    validator:
    failure_policy:

completion:
  done_when:
  audit_report:
  unresolved_risks:

This schema turns a skill from a prompt into an executable contract.

The result is not full determinism. LLM reasoning is still needed. But the reasoning is now contained inside controlled steps.

The guiding principle is:

The LLM may reason freely inside a bounded operation, but it may not freely redefine the workflow.

---

6. Verification: The Agent Must Not Be Its Own Judge

A central rule of strict agent engineering is:

The same agent that performs the work should not be the only authority deciding whether the work succeeded.

Self-audit is useful, but insufficient. It should be supplemented by external validators.

Validators can include:

Validator Type	Example
Schema validator	Output must match JSON/YAML schema
Text validator	Cited evidence must exist in source text
Diff validator	Only allowed files/lines changed
Test validator	Unit tests, lint, type checks, SQL parser
Command validator	Required command executed successfully
Human gate	User approval needed before risky step
Independent model review	Separate reviewer checks reasoning

This is where modern agent platforms become relevant. Current coding-agent ecosystems already expose mechanisms such as skills, project instructions, hooks, subagents, plugins, and tool integrations that can support this layered design. [S2]

The best architecture is therefore not prompt-only. It is:

LLM = semantic worker
Skill = state-transition contract
Kernel = execution controller
Validator = external enforcement layer
Audit log = evidence trail

---

7. The Execution Kernel

A true strict-agent system requires an execution kernel.

The kernel is not necessarily a large system. A minimum viable version can be a CLI wrapper:

strict-agent run task.yaml

The kernel performs the following:

1. Load the state contract.

2. Check required input state.

3. Ask clarification questions if required data is missing.

4. Freeze the plan.

5. Execute one step at a time.

6. Validate the output state.

7. Commit, rollback, retry, branch, ask user, or halt.

8. Write an audit report.

A simple folder structure may look like:

.strict-agent/
  skills/
    sql-debug.yaml
    vba-review.yaml
    excel-report-generation.yaml

  validators/
    schema-validator.js
    diff-validator.js
    evidence-validator.js
    test-runner.js

  runs/
    2026-06-04-001/
      input-state.json
      plan.yaml
      step-01-output.json
      step-01-validation.json
      final-audit.md

This architecture changes the status of the LLM. The LLM is no longer the whole system. It becomes a processor inside a procedural runtime.

---

8. The “Today” Factor: Why This Matters Now

The word “today” is critical.

This is not only a long-term research direction. It is an immediate socio-technical opportunity because three forces have converged.

8.1 Many Programmers Need a New Economic Role

AI coding tools are changing the labour market. The pressure appears especially strong for early-career and AI-exposed software roles. The result is not simply that programmers become obsolete. Rather, many programmers are being pushed away from ordinary implementation tasks and need a higher-leverage role. [S3]

Strict skill engineering offers that role.

Programmers already understand:

• state,

• tests,

• logs,

• preconditions,

• postconditions,

• rollback,

• schemas,

• version control,

• execution traces,

• failure handling.

These are precisely the concepts needed to turn unstable AI workflows into stable agent skills.

Thus, the displaced or underemployed programmer can become an Agent Skill Engineer.

8.2 Businesses Need Stable AI Tasks, Not Just AI Chat

Enterprises are rapidly adopting AI, but the critical bottleneck is trust and control. Developers already use or plan to use AI tools at high rates, yet trust in AI-generated output remains limited. [S4]

This creates a gap:

High AI usage
+ Low AI trust
= Demand for verification and control layers

Businesses do not merely need AI that can answer. They need AI that can perform repeatable tasks safely:

• generate reports,

• review code,

• validate invoices,

• migrate scripts,

• produce test cases,

• inspect contracts,

• update documentation,

• audit configurations,

• transform data,

• diagnose errors.

These tasks require skill stability.

8.3 Current Platforms Already Have the Building Blocks

The opportunity is immediate because the necessary building blocks already exist.

Modern tools already support:

• reusable skills,

• project instructions,

• hooks,

• shell commands,

• scripts,

• subagents,

• plugins,

• MCP-style external tools,

• CI integration,

• local and cloud execution.

However, these parts are not yet widely unified into a simple developer-facing state-transition protocol.

That gap is the opportunity.

8.4 The Flywheel

The “today” opportunity can be expressed as a flywheel:

Underemployed programmers
→ learn strict skill engineering
→ convert messy business tasks into AI workflows
→ businesses obtain more reliable AI automation
→ trust and usage increase
→ demand for more strict skills increases
→ more programmers become Agent Skill Engineers
→ more reusable skills and kernels are created

This is a self-boosting cycle.

It is not only a product opportunity. It is a labour-market conversion mechanism.

---

9. Business Implication: A New Reliability Layer for the Agent Economy

The market opportunity is not simply “another AI coding assistant.”

The more important product category is:

Agent reliability infrastructure.

Possible products include:

1. Strict Skill Compiler
   Converts ordinary prompts or skill documents into ENIAC/IAS-style protocols.

2. Agent Execution Kernel
   Runs state contracts step by step with validation gates.

3. Validator Library
   Provides reusable validators for code, SQL, spreadsheets, documents, schemas, APIs, and regulated workflows.

4. Strict Skill Registry
   Marketplace of reusable, audited agent skills.

5. Agent CI System
   Runs agent tasks in continuous integration with trace logs and rollback.

6. Enterprise Agent Governance Layer
   Monitors agent actions, cost, permissions, risks, and evidence.

The best commercial framing is not “prompt engineering.”

It is:

Deterministic control layer for AI agents.
State-verified workflow kernel.
Agent reliability compiler.
Agent governance and audit runtime.

---

10. Example: SQL Debugging Skill

A normal user request may be:

Why does this Oracle SQL give ORA-00907?

A strict IAS-mode skill converts it into:

skill: oracle_sql_debug
mode: IAS

input_state:
  required:
    - sql_text
    - error_message
  optional:
    - error_position
    - oracle_version
    - generated_sql_source

forbidden_assumptions:
  - do_not_assume_schema
  - do_not_rewrite_business_logic

opcodes:
  - INSPECT
  - LOCALIZE
  - HYPOTHESIZE
  - PATCH
  - VERIFY
  - REPORT
  - HALT

steps:
  - id: inspect_input
    operation: INSPECT
    output_required:
      - dialect
      - error_type
      - missing_inputs

  - id: localize_fault
    operation: LOCALIZE
    output_required:
      - suspicious_fragment
      - evidence
      - confidence

  - id: propose_minimal_patch
    operation: PATCH
    precondition:
      - suspicious_fragment exists
      - evidence exists
    output_required:
      - original_fragment
      - fixed_fragment
      - explanation

  - id: report
    operation: REPORT
    output_required:
      - confirmed_findings
      - hypotheses
      - remaining_uncertainties

This structure prevents common agent failure modes:

• It cannot patch before evidence.

• It cannot claim certainty without a cited fragment.

• It cannot rewrite the whole query unless allowed.

• It must separate confirmed bugs from hypotheses.

• It must halt or ask the user if required input is missing.

---

11. Example: VBA Workbook Review Skill

A normal request:

Review this VBA and tell me where to change it.

A strict ENIAC/IAS hybrid skill:

skill: vba_review
mode: IAS

input_state:
  required:
    - workbook_or_vba_text
    - user_goal
  optional:
    - error_log
    - expected_behavior

phases:
  P0_SPEC:
    output:
      - target_modules
      - user_goal
      - no_edit_confirmation

  P1_PLAN:
    output:
      - inspection_steps
      - risk_areas
      - plan_signature

  P2_TRACE:
    steps:
      - inventory_modules
      - identify_entry_points
      - trace_call_paths
      - locate likely change points
      - separate confirmed bugs from risks

  P3_AUDIT:
    output:
      - exact change locations
      - manual edit instructions
      - risks
      - test checklist

For the user, this produces a practical outcome. For the agent, it creates a stable execution path.

---

12. Why ENIAC/IAS Is a Useful Metaphor

The ENIAC/IAS distinction is historically meaningful as a metaphor for agent control.

ENIAC-mode represents fixed wiring:

Known procedure.
Known sequence.
No branching.
Strict trace.

IAS-mode represents stored-program control:

Program counter.
Memory.
Branching.
Flags.
Conditional execution.

AI agents need both.

A linear document-generation task may be ENIAC.
A debugging task is usually IAS.
A complex enterprise workflow may be a DAG built out of ENIAC and IAS subroutines.

The metaphor also helps programmers understand the design quickly. It translates fuzzy agent behaviour into familiar computational terms.

---

13. Limitations

This proposal does not make AI agents perfectly deterministic.

Several limitations remain:

1. Some tasks require creativity or judgment.

2. Some output states cannot be automatically verified.

3. Human confirmation is still needed for high-risk decisions.

4. LLM reasoning may still be wrong inside a bounded step.

5. Overly rigid protocols can reduce useful exploration.

6. Skill design itself requires expertise.

7. Validators can be incomplete or misconfigured.

8. Business tasks may contain hidden assumptions not captured in the input state.

Therefore, the goal is not full determinism.

The goal is:

disciplined nondeterminism.

That means the model may still reason probabilistically, but the workflow around it is explicit, traceable, and bounded.

---

14. Implementation Roadmap

A practical implementation can proceed in five stages.

Stage 1: Strict Skill Builder

Create a skill that asks the user structured questions:

What is the goal?
What input state is required?
What output state proves success?
What files may be changed?
What files must not be changed?
What assumptions are forbidden?
What tests or validators should run?
What should happen on failure?

The output is a strict skill document.

Stage 2: Skill Compiler

Convert the strict skill document into YAML or JSON:

Markdown Skill → State Contract YAML

Stage 3: Step Runner

Run one step at a time:

current_state + step_instruction → LLM output → validator

Stage 4: Validator Library

Add reusable validators:

schema check
diff check
evidence check
test runner
lint runner
SQL parser
Excel structure validator

Stage 5: Enterprise Kernel

Integrate with:

GitHub Actions
CI/CD
Claude Code
Codex
OpenCode
VS Code
Jira
Slack
internal audit logs

---

15. New Professional Role: Agent Skill Engineer

The proposed role is not merely prompt engineer.

An Agent Skill Engineer must understand:

Area	Required Competence
Business analysis	Convert messy human tasks into process definitions
Software engineering	State, tests, diffs, rollback, version control
Prompt engineering	Guide LLM reasoning inside bounded steps
QA	Define validators and acceptance criteria
Governance	Audit trails, risk levels, permissions
Workflow design	Break work into reusable skills

This role is highly suitable for programmers because it reuses their existing mental models.

The labour-market implication is important:

Programmers displaced from routine coding can become the people who make AI agents reliable enough for enterprise work.

---

16. Conclusion

AI agents are becoming powerful, but power without procedural discipline produces unstable automation. The immediate need is not only stronger models, but stricter execution structures.

ENIAC/IAS-style state-transition protocols offer a practical way to impose that structure. They transform agent skills from vague prompt instructions into auditable, reusable, state-governed workflows.

The key pattern is simple:

input state
→ operation
→ output state
→ verification gate
→ next state

ENIAC-mode handles fixed linear procedures. IAS-mode handles branching, debugging, recovery, and test-driven loops. Together, they provide a useful grammar for strict agent execution.

The “today” factor makes this especially urgent. Many programmers need a new economic role. Many businesses need reliable AI execution. Current agent platforms already provide enough primitives to build skills, hooks, validators, and execution kernels. The convergence of these forces creates a significant opportunity: the emergence of Agent Skill Engineering as a practical discipline and Agent Reliability Infrastructure as a major software category.

The next phase of AI adoption will not be won only by more intelligent models. It will be won by systems that can make intelligent models work reliably.

In that sense, strict state-transition protocols may become one of the missing control layers of the agent economy.

 

 

 

 © 2026 Danny Yeung. All rights reserved. 版权所有 不得转载

 

Disclaimer

This book is the product of a collaboration between the author and OpenAI's GPT-5.4, X's Grok, Google Gemini 3, NotebookLM, Claude's Sonnet 4.6, Haiku 4.5, GLM's GLM-5 language model. While every effort has been made to ensure accuracy, clarity, and insight, the content is generated with the assistance of artificial intelligence and may contain factual, interpretive, or mathematical errors. Readers are encouraged to approach the ideas with critical thinking and to consult primary scientific literature where appropriate.

This work is speculative, interdisciplinary, and exploratory in nature. It bridges metaphysics, physics, and organizational theory to propose a novel conceptual framework—not a definitive scientific theory. As such, it invites dialogue, challenge, and refinement.

I am merely a midwife of knowledge.