acceptodds
Under review as a conference paper at ICLR 2027

A Typed Latent-State Architecture for Experience-Conditioned Structural Revision

Abstract

We introduce a typed structural latent-state architecture in which experience revises the executable structures governing an agent's subsequent prediction, action, and learning. Its learnable state is a discrete structural world model: concepts are typed Metadata clusters whose generation structures, scopes, and relations participate directly in identity and computation. We implement finite slices in software agents in simulated worlds. In early studies, matched version-space and complete-context cache controls reproduce the tested prediction and reuse behaviors. In later studies, experienced outcomes change method selection and active interfaces, while failure attribution produces structures that persist across processes and guide later candidate generation. Across twelve new experience streams, an interface-revision policy improves predictive accuracy over the frozen predecessor in ten and ties in two, but yields lower cost-adjusted returns in all twelve under the tested tariffs. Revision does not by itself ensure model adequacy: a connected attribution–revision–reuse loop can still generalize incorrectly when the true relation lies outside its available hypothesis family. Matched interventions on what later computation consumes establish executable experience-conditioned revision of an agent's computational state.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
structured latent states, continual learning, experience-conditioned structural revision, neurosymbolic AI, persistent agents, world models, provenance-aware learning, hypothesis-space adaptation

Reviews

Among:
Shape:
1234this paper, Bottom 2%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.33 over 3 reviews, above 2% of the others.
Reviewer_tNuaOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

The paper proposes a "typed structural latent-state architecture" in which an agent's learnable state is a discrete, executable structural world model: concepts are typed metadata clusters (a field map, typed relations, and a declared interface/scope), where generation structures participate in identity and computation rather than only labeling retrieved text. The core loop is Decide → World → Revise, in which a decision record is committed before the outcome, and revision may eliminate hypotheses, change a field reader or selection condition, store an attributed structural difference, or keep a case pending. The claimed novelty is that revised structures sit on the decision/learning path itself and are consumed by later computation, which the authors test via matched interventions on state consumers (use vs. store-without-use; revised vs. frozen interface; history vs. current-only input; structural vs. ordinary program). Evidence comes from a sequence of finite "development studies" (labeled P0–P2, G9, G19–G32) in deterministic Boolean/modular worlds plus one probabilistic decision diagnostic, continued across saved learner states rather than a single learner on an independent benchmark. The three headline findings are honest and partly negative: (1) early behaviors are reproduced by ordinary version-space learning and complete-context caching; (2) across 12 new experience streams, interface revision improves accuracy over the frozen predecessor in 10 and ties in 2, but yields lower cost-adjusted return in all 12, and attribution results are acquired/persisted/consumed by later processes; (3) the connected attribution–revision–reuse loop can still generalize incorrectly when the true relation lies outside the hypothesis family. The contribution is explicitly framed as an architectural formulation plus matched interventions, with competitive cost, broad robustness, and autonomous language growth all disclaimed as unestablished.

Critical strengths
  1. Methodological discipline in separating "presence" from "consumption," and unusual epistemic honesty throughout. The central design choice — intervening on what a later computation actually consumes (G29's USE vs. STORE, G20's revised vs. frozen interface, G30's history entering filtering) rather than showing that a stored object exists — is the right way to make a claim about executable state, and it is executed cleanly. The paper repeatedly refuses the overclaims this area invites: it reports a negative cost result against itself in all 12 streams, flags that complete search dominates, distinguishes a new process from a new generalization sample (G30's 512 vs. 493 common-unseen denominators), and labels author-side audits as not part of learner experience. This candor is rare and genuinely valuable; the pre-registered-style seed freezing (92001–92012 fixed before inspecting pilot tables) and the version-space/cache controls that defuse the paper's own early claims are the marks of a careful investigator.

  2. The failure analysis is a real contribution in miniature. G29/G31 cleanly dissociate three things usually conflated in continual-learning loops — remembering that a question exists, reconstructing candidate explanations, and obtaining discriminating new evidence — and show a connected feedback loop that is locally validated yet wrong on 64/128 full-domain points because the stop rule accepts a locally surviving candidate without establishing coverage. This is a precise, reusable diagnosis of why "self-describing, persistent, locally validated" does not imply "correct," and it is more informative than many papers' positive results.

Critical weaknesses
  1. The paper is extremely difficult to read, and this is disqualifying at the level of the current draft, not merely a polish issue. The architecture is introduced through dense invented terminology (typed metadata clusters, work-currency W, "qualified shared knowledge," continuation boundaries) with no running concrete example that a reader can hold onto, and the entire empirical case is carried by opaque study IDs (G9, G19, G20, G28–G32, P0–P2) whose lineage, world, and question must be reverse-engineered from scattered sentences and Appendix A. A reviewer cannot presently reconstruct what task each study solves or why one follows another without substantial effort, and I do not believe most of the intended audience will invest it. Because the contribution is explicitly "an architectural formulation plus a set of matched interventions," comprehensibility is the contribution here — if the reader cannot follow the interventions, there is nothing left to evaluate. This is consequential because it caps how much the community can learn from or build on the work regardless of the underlying merit.

  2. The empirical scope is too narrow to support an architectural claim, and the one quantitative result is negative. The evidence is finite Boolean/modular worlds, mostly reusing known function families, with the central R1 study drawing 12 streams from a single fixed ancestor and function collection — which the authors correctly state are "not independent world families," so the paired bootstrap resamples streams, not worlds. There is no comparison against any capable continual learner, neural world model, or modern program-synthesis agent trained end-to-end (P2 runs Stitch, but no matched DreamCoder-style agent exists; the World Models and neural-learner comparisons are explicitly deferred). And the one headline number is that revision loses on cost-adjusted return in all 12 streams while complete computation attains 512/512 everywhere. The paper is honest that this establishes only "executable experience-conditioned revision" and not efficiency, robustness, or language growth — but once those are subtracted, the positive claim that survives ("a paid update can change what later computation consumes, in finite hand-built worlds") is a narrow existence result that does not yet justify the architectural framing. The "decisive continuation" the authors describe in §7 is, by their own account, the experiment that would actually test the thesis, and it is not in the paper.

Questions for authors
  1. Could you add one fully worked end-to-end example — a single concrete task, its typed state before and after one Revise step, the actual record contents, and the downstream prediction that changed — early in the paper? Without it I cannot verify that the formalism in §2 corresponds to what the G-studies run. (Clarification — materially affects whether the architecture is assessable at all.)

  2. What is the positive claim that survives the negative cost result? Given that complete computation attains 512/512 at lower net W in all 12 streams, under what reuse distribution or horizon would experience-conditioned revision be expected to win, and is there any evidence (even a projection) that such a regime exists? (Clarification — bears directly on significance.)

  3. The studies "continue the same saved learner" in some cases and "introduce a new diagnostic or an author-modified mechanism" in others, and you note that an author repairing a mechanism between studies differs from a learner updating its state. For each of G19→G20→G29→G30→G31, which transitions are learner-internal updates and which are author interventions? A single table making this explicit would let a reader judge what the system achieved versus what the authors achieved between runs. (Clarification — central to interpreting every result.)

  4. Is there any experiment, even small, that compares this architecture against a non-trivial external continual learner with the same histories and budget? The matched controls are all internal (frozen/retire/complete-search variants); without an external comparator it is hard to locate the contribution relative to existing KWIK, version-space, or library-learning methods you cite. (Clarification.)

  5. R1's intervals resample 12 streams from one ancestor. How much of the +18.17/512 revise-vs-frozen effect is a property of that specific ancestor and function collection versus the architecture? Even two additional ancestors would indicate whether the effect is stable.

Reviewer_1eE1OpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

The paper proposes a typed structural state architecture for agents, representing their knowledge as executable, typed metadata items, concepts, and generation structures, rather than opaque neural weights. It argues that true operational self-explanation requires mediated internal changes, execution-grounded histories, and self-readable dependencies. Through a series of controlled experiments in deterministic modular-relation and Boolean-program worlds, the authors test whether experience-conditioned revision can update active interfaces and preserve attribution records. The results show that while interface revision can improve accuracy over a frozen predecessor, it consistently yields a lower cost-adjusted return. Furthermore, while decision records can preserve the reasons for past actions, the agent fails to expand its hypothesis space to cover unseen relations. The paper deliberately scopes its claims, concluding that structural state can change computation locally but does not yet guarantee reliable adaptation, economic advantage, or autonomous hypothesis growth.

Critical strengths
  1. Unusual intellectual honesty regarding negative results. It is rare to see a paper so transparently report that its proposed complex mechanism (interface revision) consistently produces worse cost-adjusted returns than simpler baselines (like freezing or complete computation) across all twelve streams. The authors do not hide this; instead, they use it to precisely delineate the boundary of their claims.

  2. The conceptual distinction between different states of knowledge is thoughtfully constructed. Distinguishing between remembering a case exists, reconstructing candidate explanations, and obtaining discriminating new evidence provides a useful vocabulary for evaluating continual learning agents. The execution-grounded history prevents the agent from rewriting its past based on later outcomes.

Critical weaknesses
  1. The experimental results fundamentally undermine the practical motivation of the architecture. The core mechanism studied consistently incurs higher costs than it saves. If simple freezing or complete search achieves equal or better accuracy with lower operational costs, the massive conceptual overhead of typed structural states is not justified by the evidence. Furthermore, the agent fails to expand its hypothesis family when a new world requires a relation not in the available grammar. A system that cannot autonomously grow its hypothesis language is severely limited in open-ended environments.

  2. The self-explanation is heavily author-assisted and lacks genuine autonomy. The paper claims to study how an agent explains its own computations. However, the update procedures, operator languages, candidate generation rules, and budgets are predominantly supplied by the authors. The agent does not autonomously redesign these components. Therefore, the claim of operational self-explanation is merely a conditional reconstruction property of a human-designed symbolic program, rather than an emergent capability of the agent itself. The contribution is too narrow and philosophical for ICLR.

Questions for authors

First, I want to explicitly acknowledge the authors' deep thinking and refreshing honesty in reporting negative results. However, the following questions are critical:

  1. Given that the revision mechanism consistently loses to freezing or complete search in net cost across all twelve streams, can the authors identify any plausible future distribution or scenario where the massive overhead of this architecture would actually pay off?

  2. The paper admits the agent fails to expand its hypothesis space when the true function is omitted. Without author-provided meta-rules, how could this architecture ever distinguish between missing evidence and inadequate hypothesis language?

  3. Since all core components (languages, update rules) are author-supplied, in what sense is the system self-explanatory rather than just a traceable symbolic program?

Reviewer_eZDaOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

The paper proposes a Typed Latent-State Architecture in which experience can modify structured internal objects such as interfaces, hypotheses, attribution records, and decision records, and these revised structures are subsequently used by future computations. Through a series of controlled intervention experiments, the authors study whether these stored structures function as executable components rather than passive records by comparing conditions with and without revision, attribution use, or historical information. The results show that revisions and stored structures can influence subsequent behavior and improve prediction accuracy in some settings, while also highlighting limitations such as higher computational cost, reliance on predefined representations, and the inability to autonomously expand the hypothesis language. Overall, the paper investigates whether experience-driven modifications to executable internal structures can causally affect future agent behavior and presents evidence supporting this claim within the evaluated domains.

Critical strengths

The paper investigates an interesting and clearly defined question: whether experience can revise executable internal structures that later affect an agent's computation. The experimental design relies on controlled interventions rather than purely observational evidence, providing direct tests of the proposed mechanisms. I also appreciate the authors' careful discussion of limitations and negative results, including cases where simpler methods explain the observed behavior and where revision does not translate into improved cost-adjusted performance. These aspects make the paper scientifically transparent and easy to interpret.

Critical weaknesses
  1. The evaluation is limited to small synthetic domains based on Boolean functions, modular relations, and diagnostic tasks. Additional experiments on more complex settings would help establish whether the proposed architecture scales beyond the studied environments.

  2. Many key components, including the operator language, constructors, budgets, and update procedures, are designer-specified. It remains unclear how sensitive the reported results are to these design choices and how much of the framework can be learned automatically.

  3. The architecture can revise structures within its existing representation language, but it does not autonomously expand the hypothesis language or create new representational primitives. This may limit adaptation when the correct explanation lies outside the available hypothesis family.

  4. The paper evaluates several mechanisms through matched interventions, but it remains difficult to determine which components of the typed-state architecture are most responsible for the reported gains. Additional component-level ablations would strengthen the methodological justification for the full design.

  5. While revision improves accuracy relative to the frozen predecessor in many streams, it yields lower cost-adjusted return than the reported baselines across all experience streams. Additional analysis of when revision provides a net practical benefit would strengthen the paper.

  6. The evaluation does not include a matched comparison against modern continual-learning, memory-augmented, or neural agent architectures. Such comparisons would help clarify the advantages and limitations of the proposed framework relative to contemporary approaches.

Questions for authors

Check my comments in the Weaknesses

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.