Beyond Next-Token Prediction: A Standards-Aligned Survey of Autoregressive LLM Failure Modes, Deployment Patterns, and the Potential Role of World Models

Abstract

This paper is a focused, standards-aligned survey of where autoregressive (AR) large language models (LLMs) tend to break down when deployed inside industrial informatics workflows that must satisfy long-horizon objectives, hard constraints, traceability, and functional-safety obligations (e.g., IEC 61508/ISO 26262/ISO 21448). Rather than claiming new algorithms or experiments, we synthesize and organize prior work into (i) a control-oriented taxonomy of four AR failure modes that recur in practice (compounding error, myopic objectives, data brittleness/hallucinations, and scaling/latency inefficiencies), (ii) a catalog of standards-compatible deployment patterns that mitigate these issues (human-gated LLM-in-the-loop, retrieval + verification pipelines, planner-of-record architectures, and runtime assurance envelopes), and (iii) an operational decision framework (criteria table with observable proxies, a stepwise decision procedure, and worked examples) for deciding when token-centric mitigations are sufficient versus when state/world-model components become warranted. Joint Embedding Predictive Architectures (JEPA) and Hierarchical JEPA (H-JEPA) JEPA are proposed as representative state-predictive architectures, with discussion explicitly bounded by currently available empirical evidence; we explicitly note that the published evidence base is currently concentrated on vision/multimodal benchmarks and that industrial control validation remains limited. To make evidence boundaries transparent, we introduce (a) a survey method (scope, inclusion/exclusion criteria, and data-extraction fields), (b) a comparison matrix across representative prior systems, and (c) an evidence map that links each deployment pattern to peer-reviewed empirical findings and system reports.

1. Introduction

Industrial informatics is increasingly adopting foundation-model pipelines for operator support, documentation, troubleshooting, code/configuration assistance, and decision support [1,2,3,4,5]. In these settings, the engineering question is not whether AR LLMs are impressive at text tasks, but whether token-centric inference can be safely embedded into systems whose requirements are expressed over trajectories, constraints, and safety cases (e.g., IEC 61508/ISO 26262/ISO 21448 [6,7,8]). Practical deployments therefore face a recurring mismatch: AR decoding optimizes locally plausible continuations, while industrial objectives require constraint satisfaction, traceability, and predictable behavior under uncertainty.

Compute-optimal analyses and deployment experience further motivate architecture-aware design choices: many quality gains increasingly depend on careful allocation of tokens/data and on system-level scaffolding (retrieval, verifiers, planners, monitors) rather than on brute-force scaling alone. Consequently, the core question becomes how to separate “language competence” from “decision authority,” so that safety-relevant commitments are governed by verifiable modules (planners, monitors, safety filters) while LLMs remain high-leverage interfaces and assistants. Verification and runtime assurance components serve as intermediate consistency filters, but ultimate decision authority remains anchored in deterministic planners, controllers, or formally verifiable modules, ensuring bounded system behavior even in the presence of upstream inference errors.

Current autoregressive (AR) language models achieve strong performance on many discrete, text-based tasks [9,10,11]. However, when the problem requires acting over long horizons under dynamics, hard constraints, and safety obligations—as in robotics and industrial control—practical system designs rarely rely on unconstrained token generation as the decision authority. Instead, recent robotics and autonomy work typically uses the LLM as a front-end that translates natural-language intent into candidate goals, constraints, or high-level plans, while feasibility and safety are enforced by a verifiable back-end (e.g., model predictive control, constraint solvers, and autonomy stacks) and, where needed, runtime assurance mechanisms that can override unsafe proposals [12,13,14,15,16,17,18,19]. This separation of language competence from decision authority directly addresses the mismatch between next-token likelihood optimization and trajectory-level objectives under constraints, and it aligns with functional-safety expectations that require explicit safety arguments, traceability, and bounded behavior (IEC 61508, ISO 26262, ISO 21448) [6,7,8]. Accordingly, the focus of this review is not to discard AR models, but to systematize evidence-backed scaffolding and assurance patterns, and to clarify when state/world-model components may be warranted as complementary modules (see

Table 1. Representative quantitative performance characteristics of standards-aligned deployment patterns.

Pattern	Primary Mitigation Target	Typical Latency Overhead	Safety Assurance Level
Pattern A: Human-gated deployment	Incorrect or unsafe recommendations	Human response time (seconds to minutes)	Very high (human supervision required)
Pattern B: Retriever + verifier pipeline	Hallucinations and factual errors	Approximately 10–500 ms, depending on retrieval and verification complexity	High (verification before operator presentation)
Pattern C: Planner-of-record architecture	Constraint violations and infeasible actions	Planner-dependent, typically ~1 ms to 1 s depending on optimization problem size	Very high (certified planner enforces constraints)
Pattern D: Runtime assurance envelope	Unsafe control actions and constraint violations	Negligible relative to control loop execution time	Guaranteed constraint enforcement via certified safety filter

and the problem examples in Section 1).

The greatest difficulty in training robust neural networks is the processing of training data. There are three principal modes of training a model: reinforcement learning, supervised learning, and self-supervised learning.

Reinforcement learning [20] is essentially training a model through trial and error. It trains the model by running test scenarios and rewarding it for creating outputs that are seen as beneficial and punishing it for the production of negative outputs. Through many trials, the model adjusts itself to these rewards, acting in the manner that proves most profitable. The difficulty with such a model is that it must fall many times before learning to walk. Inductive learning alone does not supply the model with principles that govern its actions.

Supervised learning requires the model to train on large amounts of information. It is similar to learning by flashcards. The model takes the input and adjusts its parameters to better fit the output given by the data labeling. While this works well, the production of such data is both expensive and difficult. The model can learn, but the material must be prepared for it to understand. This makes it difficult to train a general model, as without the labeled data, the model quickly loses its ability once it begins to deal with unfamiliar concepts [21,22].

The use of self-supervised learning (SSL) allows for a much less expensive training model as it does not require large amounts of case instances or labeled data. The essential difference between SSL and supervised learning is that SSL does not require labeled data. Rather, it takes in data and masks a portion of it. This becomes the equivalent of the back side of the flash card. The model then predicts what the hidden part of the message is and then adjusts its parameters to better align with the real value. This method allows the model to train on raw data, greatly increasing the availability of training resources and decreasing the cost per data sample. Further, the model is able to gain more input from data. Reinforcement learning requires many trials to confirm an action is good or bad and many more to determine the correct way to achieve this action. Supervised learning can get one piece of information from each piece of data. SSL can mask more of the training data and, through that, gain denser results from the equivalent single input for supervised learning.

With the use of self-supervised learning came the flourishing of modern large language models (LLMs). This method allowed the models to train on a much larger set of sample data, gaining more data from each sample. Most LLMs run on an auto-regressive (AR) architecture, which, while quite functional, has several fatal flaws.

Indeed, contemporary LLMs are often misunderstood as being trained through reinforcement learning. In reality, their core training relies on supervised next-token prediction, a self-supervised formulation of maximum likelihood estimation (MLE) over large unlabeled corpora, while reinforcement-style preference optimization—e.g., reinforcement learning from human feedback (RLHF) or direct preference optimization (DPO)—is applied only in post-training alignment. This clarification is essential: the architectural and behavioral limits of AR models stem from their token-local objective, not from reinforcement dynamics.

AR training confers broad linguistic competence and in-context generalization, yet it imposes fundamental control limitations. By optimizing the likelihood of the next token rather than task-level success, AR decoders are prone to exposure bias (compounding errors over long horizons), myopic reasoning (absence of look-ahead or constraint satisfaction), and brittleness to data noise that manifests as hallucinations and representational bias. Despite these weaknesses, AR architectures dominate foundation-model practice because they are scalable, prompt-steerable, and easily aligned. Their continuing success reflects engineering pragmatism rather than theoretical adequacy.

From an industrial-informatics standpoint, these characteristics raise an operational challenge: the resulting sub-rational AI systems can generate locally plausible outputs without reasoning about goals, constraints, or verifiable world states. Recent work has further identified limitations in multimodal large language models with respect to spatial grounding and diagram-dependent reasoning, despite improvements enabled by multimodal conditioning. Empirical studies show that multimodal AR models may correctly recognize individual visual elements while misinterpreting spatial relationships or structural dependencies, reflecting the token-predictive nature of their inference objective [13,14,15,16]. These limitations are particularly relevant in industrial informatics applications involving engineering schematics and system diagrams, where correctness depends on precise state and structural consistency. The central question is therefore not whether to discard AR models but how to bound their behavior and integrate them into bounded-rational AI frameworks—systems that (i) reason under explicit constraints, (ii) ground claims in verifiable evidence, and (iii) support both internal and external checking.

We propose definitions, evidence, and actionable patterns to do so.

Definition 1 (Sub-rational AI). 

An AI system is sub-rational if its inference procedure prioritizes locally plausible predictions (e.g., token-by-token generation) without consistent mechanisms to (a) look ahead under constraints, (b) check intermediate results, and (c) align with a domain model that admits verification.

Consequently, the following definition of bounded-rational AI can be given. We use bounded rationality in Simon’s sense [23]: rational behavior under constraints of information, time, and computational capacity, often resulting in satisficing rather than optimization. This definition also matches that of limited rationality provided by Russell and Norvig [24].

Definition 2 (Bounded-Rational AI). 

An AI system is bounded-rational if its inference procedure goes beyond locally plausible predictions (as in Definition 1) by systematically introducing bounded mechanisms for global consistency and verifiability, while still operating under partial information and finite computation. In particular, a bounded-rational AI system consistently employs mechanisms to: (a) look ahead under constraints, using limited-horizon planning/search and/or a planner-of-record (e.g., optimization/MPC) to evaluate the consequences of candidate outputs/actions subject to explicit constraints; (b) verify intermediate results, using deterministic checks (tests, constraint solvers, executable validation, rule engines) before committing to externally visible outputs or actions; and (c) ground decisions in a verifiable domain model, by mapping prompts and outputs onto representations that admit auditing (e.g., controlled knowledge bases, typed schemas, state variables, formal constraints, or certified controllers/monitors).

This definition is procedural and system-level: it does not claim decision-theoretic optimality or full expected-utility maximization; rather, it characterizes architectures that are more rational than sub-rational systems because they make look-ahead, verification, and model-grounding explicit and repeatable.

To clarify the operational meaning of Definition 2, each of these mechanisms is already reflected in emerging industrial AI deployments. Mechanism (a), look-ahead under constraints, is exemplified in industrial automation and robotics pipelines where language models translate operator instructions into candidate goals or constraints, while a model predictive controller (MPC) or optimization-based planner evaluates future trajectories subject to safety, feasibility, and operational limits. The planner-of-record ensures that only constraint-compliant plans are executed. Mechanism (b), verification of intermediate results, is widely used in retrieval-augmented generation (RAG) systems for technical documentation and engineering support, where generated outputs are validated against structured schemas, versioned knowledge bases, or deterministic consistency checks prior to presentation or execution. This ensures traceability and prevents propagation of unsupported claims. Mechanism (c), grounding in verifiable domain models, is standard practice in safety-critical domains such as automotive and energy systems, where perception or language-derived outputs are mapped onto structured state representations governed by physical models, constraint solvers, or safety-certified controllers. These architectures ensure that system decisions remain auditable and consistent with domain constraints, even when upstream components rely on probabilistic inference.

In the short term, the path forward lies in hybridization rather than replacement. AR models should retain their strengths—language understanding, summarization, coding, and pattern recognition—while being embedded within toolchains that provide retrieval, planning, verification, and runtime assurance. This layered approach aligns with established functional-safety standards (i.e., IEC 61508, ISO 26262, ISO 21448 [6,7,8]) and separates language competence from decision authority, ensuring that planners, verifiers, and monitors govern actuation and policy enforcement.

Yet, the motivation for this survey arises from the persistent gap between the token-level inductive bias of AR LLMs and the system-level obligations of industrial AI: long-horizon reasoning under constraints, grounding in certified knowledge, and accountability through verifiable control. While numerous reviews examine prompting, scaling, or alignment, few integrate these issues into a standards-aligned engineering perspective or explore Joint Embedding Predictive Architectures (JEPA) as a complementary state-level paradigm.

Concerns about AI replacing human workforces or triggering tail-risk failures are widely discussed. Yet, in operational settings, the immediate hazard is sub-rational AI: systems that fluently predict the next token or action without a principled representation of task goals, constraints, or verification of intermediate steps. For industrial applications of AI, whether in manufacturing, energy, or mobility, the pertinent question is how to harness LLMs’ strengths while bounding their weaknesses under established safety and quality regimes.

We therefore review two convergent routes toward it:

• The hybridization of AR cores with retrieval, tools, planners, and verifiers;
• Latent-state prediction through JEPA and its hierarchical extension (H-JEPA), which pursue foresight, grounding, and control without committing to token-by-token prediction.

In summary, bounded-rational AI is not achieved by regulation alone but by architectures that look ahead, ground their claims, and can be checked by humans, verifiers, and formal monitors alike.

This article is a focused, standards-aligned review and perspective that synthesizes evidence and engineering patterns (not a new benchmark paper). We frame the analysis around three open research questions (RQ):

• RQ1 (diagnostic): Which AR LLM failure modes are deployment blockers for industrial informatics tasks that require long-horizon reasoning under constraints and safety obligations?
• RQ2 (prescriptive): Which standards-compatible system patterns mitigate those blockers today, and what is the evidence boundary of each mitigation (what it fixes vs. what it cannot guarantee)?
• RQ3 (comparative): Under what task/constraint conditions do state/world-model components offer a better fit than token-centric mitigations—when compared against the realistic baseline of AR + retrieval/verifiers + runtime assurance?

To make these research questions actionable, the paper delivers: (i) a control-oriented taxonomy of AR failure modes, (ii) a standards-aligned catalog of deployable patterns (A–D) that bind AR behavior, and (iii) decision criteria and integration interfaces for adding state/world-model components (with JEPA/H-JEPA discussed as representative candidates rather than predetermined solutions).

To avoid overgeneralization and to make the evidentiary basis explicit,

Table A1. Claims-to-evidence map.

Major Claim (What We Say)	Scope	Evidence Type	Key References	What Is NOT Claimed (Explicit Boundary)
AR LLM training optimizes token-local likelihood and does not directly encode trajectory-level constraints or safety objectives.	Text-only + embodied/control	Theory (objective mismatch)	[1,3,31]	We do not claim AR is unusable under constraints; only that its native objective does not guarantee constraint satisfaction or safety.
Pure AR decoding can accumulate errors over long horizons (compounding error), especially in sequential decision/plan generation.	Sequential generation; planning-style rollouts	Theory + empirical precedents	[25,26]	We do not claim AR always fails; outcomes depend on task structure, prompting, and verification/scaffolding.
AR outputs can be brittle: plausible text may be unsupported by evidence (“hallucination”), which is unacceptable for safety-relevant assertions.	Text-only decision support + safety reporting	Empirical evaluation/model assessment	[30]	We do not claim hallucinations are inevitable; we claim that without grounding/verification, correctness is not guaranteed.
Retrieval-augmented generation (RAG) improves grounding/traceability by tying outputs to a corpus, but does not provide correctness guarantees by itself.	Text-only (documentation, reporting)	Empirical + survey	[32,34]	We do not claim RAG ensures truth or policy compliance; it reduces unsupported claims but still needs verification/monitoring.
Tool use and agentic scaffolding can improve task completion by calling external tools and making intermediate steps inspectable.	Text workflows + automation	Empirical + systems patterns	[33,35,58,59]	We do not treat generated reasoning traces as proofs; tool outputs and actions still require validation and safety gating.
Deliberation prompting (CoT/ToT/PoT) improves problem solving by structuring intermediate computations, but it remains non-verifiable unless coupled to checks.	Text-only reasoning tasks	Empirical methods	[13,27,29]	We do not claim deliberation guarantees correctness; it is a heuristic unless grounded in verifiers/tests.
LLMs can interface with embodied control via programmatic policies/MPC-style wrappers, but “decision authority” should remain in verifiable modules.	Embodied/control	Empirical robotics + architecture pattern	[18,19,36]	We do not claim LLMs should directly output low-level control; rather, they can parameterize goals/constraints while controllers enforce safety.
For safety/constraint-centric tasks, the planner-of-record pattern (optimizer/controller as authority, LLM as interface) is preferable to LLM-as-planner.	Control/robotics/industrial automation	Standards + design rationale	[19,37,38,39]	We do not claim LLM planners are never useful; we claim safety-relevant commitments should be validated/overruled by verifiable components.
Runtime assurance/monitors can enforce constraints and bound behavior even when upstream components are uncertain or learning-based.	Safety-critical CPS/multi-agent CPS	Standards + engineering evidence	[19,37,38,39]	We do not claim runtime assurance eliminates risk; guarantees hold only for specified invariants under stated assumptions.
Real-world RL and embodied autonomy highlight brittleness, distribution shift, and evaluation gaps; these risks generalize to LLM-driven autonomy unless explicitly mitigated.	Embodied/control and deployment evaluation	Survey/analysis	[20,21,22]	We do not claim LLMs and RL are equivalent; we use RL/CV deployment lessons as cautionary evidence about evaluation and shift.
Compute/cost–performance tradeoffs motivate system-level approaches (data/compute allocation + scaffolding) beyond brute-force scaling.	Deployment economics (text systems)	Scaling-law/analysis	[31]	We do not claim costs always rise monotonically; we claim cost/performance must be treated explicitly and architecture choices matter.
Calibration matters when models are used for decision support; confidence estimates are often miscalibrated and require correction/monitoring.	Text-only decision support + risk estimation	Empirical evaluation	[45]	We do not claim calibration alone yields safety; it supports risk-aware gating but must be integrated with monitors and procedures.
World-model components align better with trajectory prediction than token-only generation; they provide a natural interface to planning/MPC but still require safety envelopes.	Embodied/control + long-horizon tasks	Conceptual + prior world-model literature	[40,48]	We do not claim world models automatically yield safety or correctness; they are compatible with planning but still need verification and runtime assurance.

in the Appendix A maps each major claim in this review to (i) its intended scope (text-only vs. embodied/control), (ii) the type of support used (survey, benchmark, theory, or standards guidance), (iii) the key references, and (iv) explicit “not claimed” boundaries. This table is meant to help the reader evaluate the paper as an evidence-oriented review and to distinguish established findings from design rationale and forward-looking research directions.

1.1. Motivation and Survey Contributions Relative to Existing Literature

This manuscript is intentionally positioned as a survey (not as a novelty paper). Our goal is to reduce ambiguity for practitioners and researchers working at the intersection of GenAI and industrial informatics, where requirements are expressed over trajectories, constraints, traceability, and safety cases. Its motivation is the persistent gap between (i) the token-level inductive bias of autoregressive (AR) LLMs and (ii) the system-level obligations of industrial informatics, where long-horizon reasoning under constraints, traceability to certified knowledge, and bounded decision authority are often required by established safety and quality regimes (e.g., IEC 61508/ISO 26262/ISO 21448). While many prior reviews cover prompting, scaling, or alignment in isolation, the literature remains fragmented with respect to (i) how AR failure modes map to system-level deployment blockers in industrial workflows, (ii) which mitigation patterns are compatible with functional-safety lifecycles, and (iii) what evidence exists (and does not exist) for each pattern.

Accordingly, the paper delivers three actionable review artifacts:

• Control-oriented synthesis of AR deployment blockers. We organize and interpret well-documented AR failure modes through the lens of industrial deployment (e.g., long-horizon error accumulation, objective myopia, brittleness/hallucination risk, and scaling/cost constraints). We do not claim these failure modes are new; the value lies in mapping them to industrial obligations and to concrete mitigation levers.
• Standards-compatible system pattern catalog for AR-centric deployments. We synthesize a compact set of architectural patterns (e.g., human gating, retrieval + verification, planner-of-record, runtime assurance envelopes) that are consistent with the separation between language competence and safety-relevant decision authority. These patterns are derived from established practices; the paper’s contribution is their unifying “assurance” framing, interface contracts, and evidence boundaries.
• Operational guidance for when state/world-model components are warranted. We provide decision guidance for choosing between token-centric mitigations and the introduction of state-predictive components, always relative to the realistic baseline of AR + retrieval/verifiers + runtime assurance. JEPA/H-JEPA are discussed as representative candidates for the world-model route, with explicit limitations, evidence boundaries, and open challenges—without claiming current industrial validation.

In terms of evidence and citation policy, because this paper aims to support deployable design decisions in industrial informatics, we follow a strict evidence hierarchy. Core technical claims are supported primarily by peer-reviewed journal/conference papers and relevant standards and literature. Preprints are cited only when no peer-reviewed version is available and are explicitly labeled as such; they are used mainly to frame emerging directions rather than to substantiate high-stakes claims. Practitioner blog posts and engineering notes are included only as implementation context (e.g., to illustrate orchestration idioms) and are not used as scientific evidence for safety, reliability, or performance claims.

For each deployment pattern and mitigation discussed in this paper, we distinguish (i) established evidence (peer-reviewed studies and/or formal assurance frameworks) from (ii) engineering practice (documented systems reports, tooling documentation, and operational guidance) and from (iii) forward-looking hypotheses. To make this separation explicit, we provide an evidence map that links each pattern to its strongest supporting sources and clarifies what is empirically validated versus what remains prospective.

1.2. Concrete Problem Examples in Industrial Informatics

The mismatch between token-centric generation and safety/trajectory-centric requirements appears in recurring workflows, for example: (i) translating operator intent into formal objectives/constraints for an MPC “planner-of-record”; (ii) generating or modifying PLC/SCADA configuration that must satisfy invariants and authorization policies; (iii) recommending maintenance actions under uncertain diagnostics where unsafe steps must be filtered; (iv) producing safety-relevant reports whose claims must be traceable to versioned evidence. In all cases, the key engineering requirement is that any action with safety impact is validated by verifiable logic (constraints, monitors, certified controllers) rather than by the plausibility of a generated continuation.

1.3. Literature Selection and Scope

In this survey, we target industrial informatics deployments where foundation models are used for operator support, engineering assistance, or decision support in workflows that are constrained by safety, traceability, or lifecycle requirements.

As concerns the literature selection, we adopted a structured, cross-disciplinary scoping methodology inspired by PRISMA-ScR principles to ensure transparency and reproducibility of coverage across natural language processing, machine learning, control and verification, and industrial safety standards. We queried Scopus, IEEE Xplore, and Google Scholar for the period January 2017–September 2025, capturing the Transformer era onward. Seminal pre-2017 sources (e.g., foundational texts; energy-based models) were included selectively to ground definitions and methods. The chosen inclusion criteria considered:

• peer-reviewed articles or widely cited preprints on:

  ○

  AR LLM training/decoding, failure modes, and inference-time reasoning;

  ○

  retrieval/tool-use orchestration and multi-agent patterns;

  ○

  verification, runtime assurance, planning for AI systems;

  ○

  JEPA/world-model methods (including hierarchical variants);

  ○

  industrial standards and guidance (IEC 61508, ISO 26262, ISO 21448).

• empirical evaluations, surveys, or position papers with explicit methodology or taxonomies relevant to look-ahead, grounding, or checking.

Instead, the adopted exclusion criteria ruled out:

• opinion pieces without technical substance or evaluative method;
• duplicates, non-English texts, and venue-uncertain blog posts unless they are primary sources for open-sourced frameworks referenced broadly;
• works focused exclusively on topics orthogonal to the survey scope (e.g., pure data-center hardware scaling without implications for grounding/assurance).

The screening workflow consisted in a two-stage process: (1) title/abstract screening for scope fit; (2) full-text review for methodology, technical depth, and relevance to at least one of the survey’s pillars (look-ahead, grounding, checking). As a guidepost for readers, we report the flow as: initial hits ~850, deduplicated 612, screened-in for full text 196, retained in corpus 59.

Moreover, we considered as in-scope all relevant works on AR LLMs (training/decoding/failures), inference-time reasoning (CoT/ToT/ReAct/PoT), retrieval/tool use and multi-agent orchestration, verification and runtime assurance, MPC/planning, JEPA/EBM and hierarchical extensions, and industrial standards. Conversely, we deemed out-of-scope any purely neuroscientific models without engineering implications, general AI ethics/regulation discussions not tied to technical assurance, hardware architecture surveys with no explicit systems-level impact on grounding or control.

We note that where we cite pre-Transformer work (e.g., on exposure bias and scheduled sampling), this is done to acknowledge the origin of concepts that remain relevant for modern AR LLMs; more recent evaluations are cited alongside these seminal papers in Section 3.

For emerging techniques that are currently available only as arXiv preprints (e.g., Tree-of-Thoughts, Language Model Predictive Control), we cite these works explicitly as preprints and use them solely to illustrate ongoing research directions; wherever possible, we pair them with peer-reviewed surveys or evaluations that support our main claims.

The article should therefore be regarded as a focused, standards-aligned survey and perspective, rather than an exhaustive review of all GenAI work.

1.4. Structure of the Paper

The paper is organized as follows. Section 2 addresses the first contribution by analysing where AR LLMs fail from a control perspective and by summarizing mitigation patterns that are compatible with standards-aligned engineering. Section 3 addresses the second and third contributions: it introduces JEPA/H-JEPA as state-predictive world models, discusses their implications for grounding and verification, and positions them as complementary components within the same industrial-safety framework. Concluding remarks in Section 4 synthesize both strands into design patterns and a research roadmap for bounded-rational AI in industrial informatics.

2. Where AR Models Fail in Practice

This Section focuses on our first contribution: a control-oriented analysis of AR failure modes and the corresponding mitigation patterns. Indeed, although AR LLMs dominate the current landscape, they inherit systemic weaknesses tied to their training paradigm:

• Compounding error. Sequential token prediction accumulates mistakes; early errors corrupt downstream generations (exposure bias), especially over long contexts or multi-step plans. Sequence-level or rollout-aware training partially mitigates this (e.g., Scheduled Sampling [25], MIXER, Professor Forcing [26]), but none eliminates the fundamental mismatch between training and inference dynamics. Recent evaluations of large Transformer LLMs confirm that error accumulation over long contexts remains a practical concern, especially for multi-step reasoning and planning tasks [27,28].
• Myopic objectives. Maximum-likelihood estimation (MLE) optimizes next-token likelihood, not task-level success under constraints. As a result, AR decoders lack explicit mechanisms for global search, planning, and constraint satisfaction. Inference-time controllers, e.g., Chain-of-Thought (CoT), Self-Consistency, Tree-of-Thoughts (ToT), externalize intermediate reasoning or branch over candidate trajectories and select among them, offering empirical gains but operating outside the trained objective. Hybrids such as ReAct interleave reasoning traces with tool calls (e.g., retrieval, APIs) to correct or verify intermediate steps. These strategies attenuate but do not remove the objective mismatch [29].
• Brittleness to data quality. Web-scale pretraining mixes heterogeneous, noisy, and value-laden data. In deployment this manifests as hallucinations (fluent but non-factual content) and fairness/representational harms. Broad evaluations document persistent reliability gaps across tasks and metrics; multiple surveys synthesize hallucination taxonomies and mitigation limits, including those of retrieval-augmented systems. While RAG reduces factuality errors by conditioning on retrieved evidence, it introduces a new attack surface (e.g., prompt-injection/poisoned retrieval) and systems complexity [30].
• Scaling inefficiencies. Empirical scaling laws show smooth loss improvements with model size, data, and compute, but compute-optimal analyses (such as those offered by Chinchilla) argue many large models are under-trained on tokens, so further quality gains demand substantial additional data and careful FLOPs allocation, raising costs for domain-specific accuracy targets. Recent work also nuances scaling by highlighting the roles of data quality and allocation, suggesting practical diminishing returns without commensurate data or objective redesign [31].

Despite these limits, AR LLMs remain the modal choice for foundation-model deployment because they are (i) broadly capable after large-scale pretraining, (ii) prompt-steerable with minimal task-specific heads, and (iii) amenable to lightweight post-training (instruction tuning, RLHF/DPO). GPT-3′s few-/zero-shot behavior catalyzed adoption; as already discussed above, today’s systems routinely pair AR cores with application-layer scaffolding (retrieval, tools, verifiers) to address long-horizon reliability and knowledge freshness [29].

2.1. Reframing AR Shortcomings with Targeted Mitigations

Getting around AR shortcomings is possible with targeted mitigations: namely, deliberation and search to address the limit of compund error, task-level optimization to address theproblem of myopic objectives, ground and evaluation to address the issues of data brittleness and hallucinations and compute-optimal training and specialization to address the issue of scaling costs.

2.1.1. Compounding Error

To mitigate error accumulation across decision steps, models should incorporate explicit deliberation and structured search. Chain-of-Thought and Tree-of-Thought procedures with verifier-guided backtracking enable hypothesis revision before commitment. When external evidence is required, ReAct-style tool invocation should precede finalization, allowing the system to query sources, gather signals, and update its intermediate state accordingly [29].

2.1.2. Myopic Objectives

Maximizing next-token likelihood is insufficient for task success. Token-level MLE ought to be complemented with sequence-level or preference-based objectives (instruction tuning, RLHF/DPO) to align outputs with end performance criteria. In control applications, decision authority should be decoupled: planners and simulators enforce dynamics and constraints, while the model proposes candidates subjected to those constraints [27].

2.1.3. Data Brittleness and Hallucinations

To reduce sensitivity to distribution shift and factual hallucination, systems should integrate retrieval-augmented generation (RAG/Self-RAG) and continuously monitor outcomes with multi-metric dashboards in the HELM tradition, including fairness and robustness audits. These mechanisms provide traceability and measurable reliability under varying conditions [32].

A specific and pervasive manifestation of data brittleness is label noise, where training or retrieval corpora contain incorrect, inconsistent, or outdated annotations. In industrial deployments, knowledge bases used for fine-tuning or retrieval may reflect evolving standards, documentation errors, or incomplete operational records. When language models are conditioned on such data, they may produce outputs that are internally consistent but factually incorrect relative to ground truth, creating an illusion of reliability. Robust learning frameworks developed in adjacent fields explicitly address this challenge by identifying and down-weighting unreliable training samples. For example, progressive sample selection methods such as PSSCL (Progressive Sample Selection with Contrastive Learning, [28]) iteratively refine training sets to improve robustness under noisy supervision. Similar principles can be applied to retrieval pipelines via confidence scoring, document versioning, and provenance tracking to ensure that grounded generation reflects trusted, high-integrity sources.

2.1.4. Scaling Costs

Given rising training and inference costs, practitioners should favor compute-optimal data/token scaling and domain-specialized smaller models equipped with verifiers and application-layer tools, rather than monolithic general-purpose systems. Chinchilla-style guidance indicates superior cost–performance trade-offs under such regimes [30,31].

2.2. Toward Bounded-Rational AI: Methods That Look Ahead, Ground, and Check

Modern AR language models deliver broad competence but remain sub-rational for many real-world tasks: they predict locally plausible tokens without explicit mechanisms for global search, grounding, or safety assurance. Building more rational AI therefore requires augmenting the AR core with methods that

(i)

look ahead, explicitly exploring and scoring alternative reasoning paths;

(ii)

ground model outputs in verifiable, up-to-date knowledge sources; and

(iii)

check proposed actions against constraints, uncertainty, and safety envelopes.

We proceed with surveying these families, namely, deliberate reasoning and tool use (CoT, Self-Consistency, ToT, ReAct, Program-of-Thoughts), retrieval-based grounding (RAG/Self-RAG), and model-/world-based controllers for domains with dynamics and hard constraints—together with uncertainty calibration, abstention, and formal/runtime verification.

2.2.1. Deliberate Reasoning and Tool Use

Deliberate reasoning techniques aim to make the model’s internal decision process more explicit and structured, thereby mitigating the intrinsic myopia of token-level MLE. Chain-of-Thought (CoT) prompting encourages the model to produce step-by-step rationales rather than directly emitting a final answer. Building on this idea, Self-Consistency samples multiple CoT trajectories and aggregates their outcomes, which reduces sensitivity to any single erroneous reasoning path and improves robustness. Tree-of-Thoughts (ToT) generalizes CoT from a single linear chain into an explicit search over a tree of intermediate “thought” states, equipped with scoring and pruning mechanisms that enable systematic exploration and backtracking over partial solutions. Collectively, these approaches externalize part of the search process that is not directly optimized by the MLE objective, thereby improving performance on long-horizon, combinatorial, or multi-step reasoning tasks [29].

Reason + Act (ReAct) style loops further extend deliberate reasoning by interleaving natural-language reasoning traces with explicit actions such as document retrieval, API calls, or environment interactions. Instead of hallucinating missing facts, the model is guided to identify information gaps, invoke appropriate tools to gather evidence, and then integrate the retrieved signals back into its ongoing reasoning process. Empirical evaluations indicate that such Reason + Act schemes reduce factual errors on knowledge-intensive tasks and improve success rates on interactive and embodied benchmarks, where correct behavior depends critically on up-to-date or environment-specific information [33].

Program-of-Thoughts (PoT) methods address the limitations of purely linguistic reasoning for tasks that require precise arithmetic or logical computation. In PoT, the model is prompted to generate executable code (e.g., Python snippets) that encodes its reasoning steps, which are then executed by an external interpreter to obtain the final result. This design explicitly separates the high-level formulation of the solution, handled by the language model, from low-level numerical computation, delegated to a verifiable runtime. As a consequence, PoT approaches consistently outperform vanilla CoT prompting on numerical, logical, and financial question answering tasks, where even small arithmetic inaccuracies can invalidate the entire answer [13].

2.2.2. Grounding and Knowledge Access

Retrieval-augmented generation (RAG) architectures address the limitations of purely parametric models by explicitly conditioning language model predictions on external evidence. In a typical RAG pipeline, the system first retrieves a set of relevant documents or passages from a non-parametric memory (e.g., a vector database or search index), and then conditions the generative model on both the user query and the retrieved context. This mechanism simultaneously reduces hallucinations—since answers are constrained by explicit evidence—and provides provenance, as the system can surface the supporting sources alongside its outputs. In effect, RAG combines the strengths of parametric knowledge (generalization, abstraction) with those of non-parametric storage (updatability, traceability) [34].

Self-RAG extends this paradigm by making retrieval itself an object of learning and control for the language model. Instead of retrieving on every query in a fixed manner, the model is trained to decide when retrieval is necessary, which documents to query or trust, and how to critique and revise its own drafts in light of retrieved evidence. This leads to a closed-loop interaction where the model can iteratively (i) propose an answer, (ii) identify gaps or inconsistencies, (iii) trigger targeted retrieval, and (iv) refine its response based on the new evidence. Empirical studies show that such self-reflective retrieval policies further reduce hallucinations and improve factual grounding compared to static RAG pipelines [35].

2.2.3. Multimodal LLM Grounding and Spatial Reasoning Limitations

Recent multimodal large language models (MLLMs) extend autoregressive architectures by incorporating visual encoders, enabling joint processing of textual and visual inputs such as engineering diagrams, inspection images, and multimodal documentation. These systems have demonstrated strong performance across perception and interpretation tasks, including document analysis, visual question answering, and multimodal retrieval.

Several recent works have specifically focused on improving visual grounding capabilities in MLLMs. Visual Position Prompting introduces explicit spatial coordinate conditioning to improve localization accuracy and spatial reasoning consistency [14]. Similarly, VRP-SAM extends segmentation-based grounding by incorporating visual reference prompts, enabling improved object-level alignment between visual inputs and semantic representations [15]. Other approaches, such as Primitive Vision, improve diagram understanding by decomposing visual scenes into structured primitive components, facilitating more accurate reasoning over diagrammatic relationships [16].

Despite these advances, empirical evaluations highlight persistent limitations in spatial reasoning and diagram-dependent inference. In particular, recent studies such as Math Blind [17] demonstrate that multimodal language models can correctly recognize individual visual elements while misinterpreting spatial relationships, geometric constraints, or structural dependencies between components. These errors arise from the autoregressive formulation, in which models optimize token-level prediction conditioned on multimodal embeddings rather than explicitly modeling system state and state evolution.

From an industrial informatics perspective, these limitations are particularly relevant in workflows involving engineering schematics, control system diagrams, or physical process representations, where correct interpretation depends on precise spatial and structural relationships. In such settings, reliability is achieved primarily through system-level mitigation mechanisms, including retrieval grounding, planner-of-record architectures, and runtime assurance filters, rather than through multimodal autoregressive modeling alone.

These observations have motivated investigation of alternative architectural formulations, including state-predictive world models such as JEPAs, which learn latent representations of system states and their evolution. While empirical validation of such architectures in industrial control contexts remains limited, their formulation aligns conceptually with state-based representations used in planning and control systems. Accordingly, multimodal autoregressive models and state-predictive architectures should be understood as complementary components within broader system architectures that incorporate verification, planning, and runtime assurance mechanisms.

2.2.4. Model-Based and World-Model Perspectives of Industrial Relevance

In industrial domains characterized by explicit dynamics, safety constraints, and long-term objectives (such as robotics, process control, and autonomous systems) purely token-local continuation is generally inadequate. In these settings, high-stakes decisions must satisfy hard physical and operational constraints over extended horizons [18]. Consequently, deployed architectures increasingly adopt a hybrid design in which a large language model serves as a front-end for task specification, high-level reasoning, and human interaction, while a separate, verifiable back-end is responsible for planning and control.

The back-end typically consists of established model-based components: constraint solvers, physics simulators, and model predictive controllers (MPC) [19,36]. The language model may translate user intents, natural-language instructions, or unstructured specifications into formal objectives, constraints, or candidate plans. However, feasibility, safety, and optimality checks are delegated to the back-end “planner-of-record,” which can leverage decades of work in constrained optimization, robustness, and stability analysis. This separation of concerns preserves the flexibility and usability of LLMs at the interface, while anchoring critical decisions in well-understood model-based control theory and tools [37,38,39].

2.2.5. Calibration and Abstention

Reliable deployment of language models and learning-based controllers requires not only accurate predictions but also calibrated estimates of uncertainty. Techniques such as temperature scaling and related post hoc calibration methods can adjust predicted confidence scores to better reflect empirical error rates. On top of calibration, selective prediction or reject-option mechanisms allow the system to abstain from making a prediction or taking an autonomous action when confidence is low or when available evidence is weak. Recent work in natural language processing also adapts conformal prediction to construct prediction sets for LLM outputs, providing finite-sample guarantees on coverage under mild assumptions. In safety- or mission-critical applications, these mechanisms are typically combined with human-in-the-loop review, such that uncertain or high-impact decisions are escalated for expert validation before execution [40,41].

2.2.6. Runtime Assurance and Safety Filters

Beyond confidence estimation, runtime assurance architectures provide a principled way to bound the risk of learned or advanced controllers. A canonical pattern, exemplified by the Simplex architecture, runs a high-performance (but potentially unverified) controller in parallel with a conservative, formally verified baseline controller. A monitoring module evaluates the evolving system state and, if safety constraints are at risk of being violated, switches control authority to the baseline controller, thereby enforcing hard safety guarantees. Complementary mechanisms include control barrier functions (CBFs), which implement online safety filters by solving constrained quadratic programs (QPs) that minimally modify the proposed control input to maintain invariance of a safe set. In addition, neural network verification tools (e.g., SMT- and MILP-based verifiers such as Reluplex) can certify local properties of small safety-critical components, such as perception modules or decision policies over restricted operating envelopes. Together, these techniques—runtime assurance architectures, CBF-based filtering, and neural verification—form a layered defense that constrains the behavior of learning-enabled systems within provable safety envelopes [42].

2.3. Engineering for Industrial Informatics: Standards-Aligned Design

In safety-critical industrial domains, AI-enabled components must be engineered within established functional-safety lifecycles rather than as ad hoc additions. IEC 61508 provides the cross-industry reference framework for functional safety of electrical/electronic/programmable electronic (E/E/PE) systems, defining safety integrity levels (SILs) and prescribing a risk-based lifecycle that spans hazard and risk analysis, specification, design and implementation, verification and validation, and operation and maintenance [37]. AI subsystems that influence plant behavior are therefore required to be integrated into this lifecycle, with appropriate monitoring, fault detection, and mitigation measures to ensure that overall system risk remains within the tolerable thresholds defined by the targeted SIL.

ISO 26262 specifies the adaptation of IEC 61508 to road vehicles and is now the de facto standard for safety-related E/E systems in automotive contexts. It introduces the automotive safety integrity levels (ASILs) and formalizes a safety lifecycle tailored to the development of controllers, sensors, and software for advanced driver-assistance systems (ADAS) and autonomous-driving functions. In practice, AI-based perception and decision modules in automotive pipelines are allocated ASILs, subject to structured hazard analysis and risk assessment, and must be supported by safety mechanisms such as redundancy, monitoring, and graceful degradation [38].

ISO 21448, known as the Safety of the Intended Functionality (SOTIF), complements ISO 26262 by addressing hazards that arise not from component failure but from functional insufficiency or reasonably foreseeable misuse of the system. This dimension is particularly relevant for machine learning, whose performance may degrade under distribution shift or unmodeled operating conditions. SOTIF-oriented processes require systematic analysis of unknown unsafe scenarios, expansion of the operational design domain (ODD) via testing and simulation, and design revisions that reduce the likelihood of unsafe outcomes—even when all components are nominally fault-free [39]. For AI-enabled industrial informatics, the combined application of IEC 61508, ISO 26262, and ISO 21448 provides a baseline for arguing safety in the presence of learned models and data-driven behavior.

The convergence of functional-safety requirements and AI capabilities has led to a set of recurring architectural patterns for deploying large language models (LLMs) and related components in industrial informatics. These patterns aim to preserve the usability and flexibility of LLMs while maintaining verifiable, standards-aligned control over safety-relevant decisions.

• Pattern A—LLM-in-the-Loop, Human-on-the-Loop (see Figure A1 in the Appendix A):
  In this configuration, LLMs are employed for tasks such as report generation, anomaly triage, procedural guidance, and code or configuration assistance. All safety-critical actuation is strictly gated behind deterministic controllers and runtime monitors that enforce invariants and SIL/ASIL requirements. The LLM may propose actions, diagnoses, or parameter changes, but these proposals are subjected to verification by rule-based logic, safety kernels, or certified controllers before being applied to the plant. This pattern is closely aligned with Simplex-style and runtime-assurance (RA) architectures, where an unverified advanced controller can be overridden by a verified baseline when safety constraints are at risk of being violated [19].
• Pattern B—LLM + Retriever + Verifier (see Figure A2 in the Appendix A):
  Here, the LLM operates in conjunction with a retrieval module and verification layer. A RAG component supplies the model with curated, versioned technical documentation, procedures, and standards-compliant artefacts. A verifier—implemented via rule-based checkers, specialized classifiers, or secondary models—validates citations, cross-checks claims against retrieved evidence, and flags unverifiable or unsupported statements prior to presentation to the operator. In industrial settings, this pattern supports traceable, auditable decision support, reducing hallucinations and facilitating compliance with documentation and knowledge-management requirements [32]. The verifier does not assume decision authority, but instead enforces interface-level consistency and grounding constraints, while downstream planners, controllers, or safety filters remain responsible for enforcing safety-critical guarantees.
• Pattern C—Planner-of-Record, LLM as Interface (see Figure A3 in the Appendix A):
  In this pattern, model predictive control (MPC) or optimization-based planning remains the “planner-of-record” for any plant-side decisions. The LLM serves as an interface layer: it translates natural-language operator intents into formal objectives and constraints, enumerates feasible options, explains trade-offs, and assists with configuration and tuning. However, it does not directly commit actions to the plant. Instead, any candidate plan proposed via the interface is submitted to the planner-of-record, which checks feasibility, safety, and optimality with respect to the system model and constraints. Only plans that satisfy these checks are executed. This separation of concerns preserves human-centric interaction and flexibility while anchoring closed-loop behavior in verifiable control-theoretic foundations [17,18].
• Pattern D—Runtime Assurance Envelope (see Figure A4 in the Appendix A):
  In the runtime-assurance envelope pattern, any control signal or reference trajectory suggested by an ML component is passed through a safety filter, such as one based on control barrier functions (CBFs). The filter enforces forward invariance of a certified safe set and overrides or modifies ML outputs when they would lead the system outside this set. A verified baseline controller is available as a fallback, ensuring that, upon violation detection or loss of confidence in the learned component, the system reverts to a safe mode. This pattern is particularly suitable when ML is used to improve performance (e.g., efficiency, comfort, or throughput) but must not compromise safety under any operating condition [19]. This layered architecture ensures that even if upstream components, including retrieval or verification modules, fail to detect an error, runtime assurance mechanisms enforce invariant safety constraints independently of probabilistic inference.

In particular, with respect to Pattern A, while human-gated architectures improve safety, excessive reliance on operator intervention can introduce cognitive overload and operational risk. Sustainable human–machine integration therefore requires interface designs that minimize cognitive burden through selective escalation, confidence-based triaging, and explainable outputs. Rather than requiring human validation for all decisions, bounded-rational systems prioritize human review only when uncertainty exceeds calibrated thresholds or when safety-critical actions are involved. This selective review paradigm preserves operator situational awareness while maintaining system scalability and safety.

Moreover, while Pattern B significantly improves grounding and traceability, it also introduces a new architectural component whose reliability and failure modes must be explicitly considered. In particular, the verifier defines a critical trust boundary between probabilistic generation and downstream system behavior. Its role is not to guarantee universal correctness—which is generally intractable for open-domain inference—but to enforce domain-specific consistency, provenance, and constraint compliance prior to downstream use. This separation aligns with functional-safety principles, whereby generative components assist interpretation, while verifiable modules govern reliability and traceability. Verification components may be implemented either as rule-based systems or as specialized learned models, each presenting distinct trade-offs. Rule-based verifiers provide deterministic guarantees relative to explicitly encoded constraints (e.g., schema validation, citation checks, and consistency rules), ensuring full transparency and auditability. However, their completeness is limited by the scope of encoded rules, requiring structured schema design and version-controlled maintenance. Learned verifiers, such as entailment classifiers or grounding models, can detect semantic inconsistencies beyond static rules but introduce probabilistic uncertainty and potential sensitivity to distribution shift. In practice, their narrower scope, conservative calibration, and rejection thresholds improve robustness while enabling escalation of uncertain cases. Most importantly, the verifier does not constitute a single point of failure in standards-aligned architectures. Decision authority remains anchored in downstream deterministic components, such as planners-of-record, constraint solvers, or runtime assurance filters, which enforce safety and feasibility independently of generative outputs. The verifier therefore acts as an intermediate risk-reduction layer, reducing hallucination exposure and improving traceability without introducing unbounded reliance on any single probabilistic component [37].

Collectively, Patterns A–D illustrate a design space in which LLMs and other AI components are embedded as advisory, interpretive, or optimizing layers around standards-compliant, model-based cores, rather than as unchecked end-to-end controllers. This architectural separation ensures that learned components, including latent state predictors and projection mappings, operate under the supervision of certified planners, constraint solvers, and runtime assurance mechanisms, consistent with functional safety requirements defined in IEC 61508 and ISO 26262.

As discussed above, AR decoders currently dominate discrete language tasks but exhibit limitations in settings that require long-horizon reasoning and closed-loop control. By construction, maximum-likelihood training focuses on locally myopic next-token prediction rather than explicit task-level or trajectory-level success. As a relevant alternative, for industrial applications where consistency under dynamics and long-term safety are central, this mismatch motivates the exploration of world-model formulations that prioritize state-level prediction instead of token-local continuation.

The Joint Embedding Predictive Architecture (JEPA) [43] addresses this gap by framing prediction in a latent representation space. Given a context representation, the model learns to predict a compatible future-state representation, rather than enumerating explicit next tokens. Because the outputs reside in a latent space, a separate decoder is required to produce human-interpretable renderings such as text, images, or trajectories. Training is often cast in the form of an energy-based model (EBM), in which the system assigns low energy to compatible (context, target) pairs and higher energy to incompatible ones. Regularized EBM training shapes a well-structured energy landscape and mitigates degenerate solutions with flat or uninformative minima. Conceptually, JEPA is designed to capture “big picture” compatibility between states, providing a mechanism for foresight and global consistency without committing to each microscopic token-level detail.

A natural extension is the Hierarchical JEPA (H-JEPA), in which multiple predictive modules are organized across abstraction levels. Higher layers produce coarse plans, constraints, or abstract predictions, while lower layers refine these into detailed trajectories, control commands, or symbolic outputs subject to the higher-level constraints. Such hierarchical structures are appealing for robotics, process control, and industrial informatics, where coarse feasibility and safety constraints must be enforced prior to fine-grained actuation.

Despite their promise, JEPA and H-JEPA introduce several open research challenges. First, compositional training procedures are required to ensure that gradients propagating across levels do not collapse lower-level structure or undermine specialization. Second, new methods for attribution and interpretability are needed to make latent decisions understandable and auditable in safety-critical contexts. Third, task-dependent constraint design remains an open question: constraints must be tight and formally grounded for control-oriented applications, yet may be looser and more heuristic for generative media or documentation tasks.

In this survey, JEPA-style models are discussed as a representative family of world-model approaches that learn predictive representations via self-supervised objectives. At present, the strongest published evidence for I-JEPA/MC-JEPA is concentrated on vision and multimodal representation benchmarks and ablation studies; to our knowledge, peer-reviewed demonstrations in safety-critical industrial control deployments remain limited. Accordingly, we do not claim JEPA/H-JEPA as a validated solution path for industrial control. Instead, we treat JEPA/H-JEPA as a research direction that is conceptually aligned with state/trajectory reasoning, and we use it to clarify what properties a world model would need to interface cleanly with planners-of-record, verifiers, and runtime assurance mechanisms.

In the near term, the most pragmatic path for industrial informatics is still likely to combine AR-based language competence with the standards-aligned patterns described above—planners-of-record, retrievers, verifiers, and runtime-assurance envelopes—thereby leveraging the strengths of current LLM technology while maintaining the safety and reliability required by IEC and ISO frameworks.

To position emerging state-predictive architectures within the broader deployment landscape, the following subsection provides a comparative overview of multimodal AR models and latent state-predictive world models, with explicit attention to evidentiary maturity and industrial deployment status.

2.4. Quantitative Performance Characteristics of Deployment Patterns

The deployment patterns described above are supported by empirical evidence from robotics, industrial automation, and retrieval-augmented inference systems. While performance characteristics vary depending on implementation and system complexity, prior literature provides representative quantitative ranges illustrating their operational properties.

Retrieval-augmented generation (Pattern B) has been shown to reduce hallucination rates and factual errors relative to purely parametric autoregressive models. Empirical studies report reductions in factual error rates on the order of 30–60%, depending on retrieval quality and domain specificity [32]. The latency overhead introduced by retrieval and verification stages typically ranges from approximately 10 ms to several hundred milliseconds in optimized deployments, which is acceptable for operator-support and supervisory decision workflows.

Planner-of-record architectures (Pattern C), in which language models generate candidate objectives or constraints while certified planners enforce feasibility and safety, introduce minimal computational overhead relative to planner execution time. Model predictive control and optimization-based planners typically operate on time scales ranging from milliseconds to seconds depending on system complexity, while providing deterministic constraint enforcement and formally verifiable safety guarantees.

Runtime assurance architectures (Pattern D), including Simplex supervisory control and control barrier function filters, operate at control loop frequencies and introduce negligible additional latency relative to plant dynamics. Experimental evaluations in robotics and automotive control systems demonstrate that such mechanisms can guarantee constraint satisfaction while allowing learning-based components to improve nominal performance [44].

Human-gated deployment patterns (Pattern A) introduce latency determined primarily by human response time rather than algorithmic overhead. However, they provide the highest level of safety assurance by ensuring that learned components operate strictly in advisory roles.

Table 1 summarizes representative performance characteristics derived from published studies and industrial system reports.

These results indicate that deployment patterns mitigate AR model limitations primarily through architectural separation between learned inference and certified decision authority, rather than through modifications to autoregressive models themselves.

2.5. Comparison Between Multimodal LLMs and State-Predictive World Models

Recent multimodal large language models (MLLMs) extend AR architectures by incorporating visual encoders, enabling joint processing of textual and visual inputs such as engineering diagrams, inspection images, and multimodal documentation. These systems have demonstrated strong empirical performance in perception and interpretation tasks, including document analysis, visual question answering, and multimodal retrieval. In industrial informatics workflows, such capabilities support operator assistance, diagnostics, and documentation-related tasks, particularly when combined with retrieval and verification mechanisms as described in Section 2.2 and Section 2.3.

However, MLLMs remain fundamentally token-predictive models. Their inference objective is defined at the level of next-token likelihood rather than explicit modeling of system states or physical constraints. As a result, while multimodal conditioning improves semantic grounding relative to text-only models, these architectures do not provide inherent guarantees of state consistency, constraint satisfaction, or compatibility with system dynamics. In practice, reliability in safety-relevant workflows is achieved through system-level mitigations, including planner-of-record architectures, runtime assurance filters, and deterministic verification components, rather than through model architecture alone.

State-predictive world models, including JEPA, represent an alternative formulation in which models learn latent representations of observations and predict compatibility between present and future states. This formulation aligns conceptually with state-based representations used in control systems and planning. However, it is important to emphasize that empirical validation of JEPA-style architectures remains primarily limited to representation learning and multimodal prediction benchmarks. To our knowledge, peer-reviewed demonstrations of JEPA-based architectures deployed within safety-critical industrial control pipelines are currently limited.

Accordingly, within the context of current industrial practice, MLLMs combined with retrieval, planning, and runtime assurance mechanisms constitute the dominant deployment paradigm. State-predictive world models should therefore be regarded, at present, as an emerging research direction that addresses known architectural limitations of token-predictive models, rather than as an empirically established replacement. Their potential relevance to industrial informatics lies primarily in their compatibility with state-based planning and verification frameworks, subject to further empirical validation and integration with certified system architectures.

3. Towards the JEPA Architecture

Having identified the limits of AR-based systems and their mitigations, we now turn to a forward-looking analysis of JEPA and H-JEPA as complementary emerging state-predictive architectures that address limitations of AR models at the representation level. However, current empirical validation is primarily limited to representation learning benchmarks, and industrial control deployment remains an open research area.

Namely, throughout this section we discuss JEPA and its hierarchical variants as promising state-predictive world-model architectures, not as production-ready replacements for autoregressive LLMs in industrial pipelines. Our statements about their capabilities are grounded in the empirical results reported in the original I-JEPA and related works (e.g., improvements in representation quality, sample efficiency, and robustness on vision benchmarks), rather than in new experiments conducted for this article. Importantly, JEPA has not yet been validated on the full spectrum of safety-critical tasks considered in Section 3.2 and Section 3.3. Claims that JEPA can mitigate specific AR failure modes should therefore be interpreted as forward-looking hypotheses and design intuitions supported by early prototypes, not yet as conclusive industrial evidence.

The inherent flaw of AR models is their inability to reground themselves once they have begun processing information. While this is not a problem when it comes to the analysis of data, when it becomes necessary to produce additional states, text generation, image generation, and control systems, the model strays from good predictions quickly. Essentially, because these models are built on probability structures, the further out one gets, the less likely the prediction is to be correct. It might be easy enough to finish someone’s sentence, but it is a very different task to finish an entire task or mission. The probabilistic models choose what is the next probable output, which is, by its nature, uncertain. This uncertainty leads to future states appearing more and more blurry and unclear. Developing a model capable of managing complex systems requires a fundamentally new architecture. This architecture must be grounded in real principles, able to correct itself if it begins to err, and have a degree of understanding of cause and effect [43].

The first of these needs can be solved by the incorporation of world models [45] into the architecture of the system. World models are those that have the parameters adjusted to best reflect an accurate model of the world. This is still done through training on data, not through the hard-coding of the laws of physics into the model, so it is not as though the model knows how the world works. Yet, the implementation of world models does carry with it an increased stability of the model, wherein it adjusts its outputs to fit with what is most likely to happen given what it knows about the world. This makes it ideal for dealing with models that need to predict the next state in a realistic environment.

This inclusion of principles is much closer to how people come to learn [46]. This incorporation of state-based regularities more closely resembles how humans learn. By training on latent state transitions rather than surface-level correlations, world models become more robust to violations of physical principles. Such models emphasize causal structure whereas standard AR models primarily capture statistical patterns among observable effects. This shift does not require a new neural architecture, but it redirects training toward modeling relationships between states rather than predicting tokens.

Joint embedding predictive architecture (JEPA) [43] is a novel model of predictive analysis that analyzes states rather than tokens. JEPA predicts the “big picture” rather than each part of the picture. This is the fundamental difference in JEPA and AR methods that is, predictive modeling of latent states rather than tokens. A latent state, in short, is the general idea of whatever is being modeled. In image generation of a dog running in the park, for example, a JEPA model would predict a future state that fits with the given state of the dog running in the park. The model encodes the essential details from the given state into a vector space and then adds any state changes, such as the dog is running, so it ought to be in a new position. A decoder is used to change these vectors into an image that contains the essential information from the first state, modified by any functions. JEPA models operate on latent state representations rather than token sequences. This formulation may provide advantages in tasks involving state prediction, subject to empirical validation in specific deployment contexts. Humans reason about the future through sets of concepts, not through a collection of detailed assumptions. JEPA sees states, not individual tokens or packages of data, which is a much better approximation of how humans perceive data. Although JEPA is closer to human thinking, it cannot perform syllogistic logic and is still a predictive model. JEPA predicts latent vectors that encode abstract information regarding the state rather than the production of tokens which exist in their polished form. A decoder is necessary to translate this high-dimensional vector into a format interpretable by humans.

In Figure 1 we report a schematic representation of the JEPA architecture. Namely, the encoder $\mathit{E}\mathit{n}\mathit{c}\left(\mathit{x}\right)$ extracts a representation ${\mathit{s}}_{\mathit{x}}$ of the observed past and present, while $\mathit{E}\mathit{n}\mathit{c}\left(\mathit{y}\right)$ encodes the future into ${\mathit{s}}_{\mathit{y}}$. A latent variable $\mathit{z}$ and an optional action $\mathit{a}$ condition the predictor $\mathit{P}\mathit{r}\mathit{e}\mathit{d}({\mathit{s}}_{\mathit{x}},\mathit{a},\mathit{z})$, which estimates a representation ${\widehat{\mathit{s}}}_{\mathit{y}}$ of the future. The prediction cost $\mathit{D}\left({\widehat{\mathit{s}}}_{\mathit{y}}\right)$ measures the discrepancy between true and predicted representations, while the surrogate cost $\mathit{C}\left({\widehat{\mathit{s}}}_{\mathit{y}}\right)$ regularizes the latent space. The model thus learns to predict future representations from past and present observations. Since the model does not produce data comparable to the input, it cannot train through the direct comparison of the masked input to the output. Rather, JEPA uses an energy-based model (EBM) to optimize its parameters for the ideal latent space generation [47,48].

EBMs are systems that value given states with an energy level. This is a pure scalar with high values for unlikely scenarios and low values for likely ones. This is different from probability methods, as, when systems are dealing with problems in increasing dimensions, probabilities become less and less certain. EBMs do not need to know the details since they simply give a scalar value to an input-output pair.

An EBM model is actually quite similar to a probabilistic model except that it produces a value of how difficult it would be for the second state to follow from the first, instead of a set of outputs and their probability. That is, in training, while the probabilistic model adjusts its parameters to choose the most likely outcome, an EBM adjusts itself to find the lowest energy state. While in low-dimensional problems text generation is very similar to probabilistic models, as the complexity increases, it can provide a clear scalar value for the compatibility of each input-output pair. The probabilistic model will still try and predict every aspect of the high-dimensional problem, which leads instead to ‘fuzzy’ predictions. Probabilistic models must commit to detailed predictions even under uncertainty, producing blurred or inconsistent outputs. EBMs instead score the compatibility of latent states and do not require specifying uncertain low-level details.

Within the scope of EBMs, there are a few different ways to train the model. If the possible energy states are viewed like a landscape, the valleys represent the low points and the hills the high energy points. This “landscape” can be created by either pushing real samples down and pushing fake samples, high-energy pairs, up. The model recommended in [48] is known as regularized EBM training, wherein real samples are pushed down, and, through that, the landscape is created. This training model is called regularized because it limits, or regulates, the low energy space, which prevents the model from pushing everything to a zero energy plane. If the model can create such a plane, all of the possible outputs become equally likely, destroying any functionality of the model.

Existing JEPA variants have demonstrated favorable representation learning properties in experimental benchmarks. However, validation in safety-critical industrial informatics deployments remains limited and there is further research being done to greatly increase the scope of these models [49]. Currently, the difficulty lies in that, depending on the scope of a project, it will need more or fewer degrees of world model constraints given to it. If the goal is to control a robotic arm, there are restrictions in the model’s construction. If the goal is to generate an image of a video, there is a much lower degree of constraint needed. This again is similar to how people consider problems. There is a general net of common sense which pervades any prediction, while there is a more specialised set of expectations that arise, the more specialized the task one is undertaking. This insight led to the theoretical work on hierarchical JEPA (H-JEPA) architecture [43].

The goal of H-JEPA is to train a JEPA model with multiple layers. The highest layer will deal with the problem on the most abstract level, giving an outline of a low-energy solution to the problem. Subordinate layers will then begin to flesh out the details of the output, each one adding finer constraints on the problem, which the subsequent layers use in their prediction. This would allow a model to give context to the more precise details of whatever problem it is solving. With the greater detail, they become more defined, thus the output can have clarity even in precise states further away from the original input data. This formulation suggests potential advantages in modeling structured state evolution. However, empirical validation of such improvements in industrial control contexts remains an open research question.

As was said, this model currently exists only in theory. To produce such a model, it would be necessary to find a way in which the gradient energy landscapes of each smaller JEPA model fit into the larger model’s landscape. This is very difficult to do without washing out the energy fields of the lower model by the guiding principal fields. This leads to one of the core difficulties when working with JEPA architectures. Whereas AR models are probabilistic and, as such, you can trace the influences the data had on the output token, JEPA predicts states from an input, and it is very difficult to see what parts of the input had the most weight on the output. Because of this, creating an H-JEPA model is a little like trying to hit a target in the dark. Each model works, but it is hard to tell why it works. This leads to the great difficulty of constructing a machine out of a set of black box components. As with all things, the problem scales with size; the greater and more complex the problems, the more layers the H-JEPA needs and the more difficult the model becomes to make.

Although current AR models are quite powerful and very capable when it comes to discrete prediction, a new architecture will likely be needed with a greater focus on relating things to concepts. In any regard, if the goal is to create Artificial General Intelligence (AGI), the architecture must permit intelligence. Current AR models are incapable of understanding their position and taking the next best step without a clear understanding of where that step will lead them. Compared to human action, that is exactly reversed. People think of what they want and then come up with the steps that will get them to that end goal. H-JEPA represents a research direction toward improved state-predictive modeling. Through the world model philosophy, the models are restricted from straying into states that are impossible given reality. Self-supervised learning allows a model to train deeply on unlabeled data. Finally, latent states and EBMs in the JEPA model allow it to proceed more conceptually rather than predictively.

These properties illustrate the conceptual motivation for state-predictive architectures. Yet, most importantly, we stress that JEPA and its hierarchical extensions should be regarded as emerging research architectures rather than established industrial deployment solutions. While empirical results demonstrate improvements in representation learning and predictive consistency in multimodal benchmarks, peer-reviewed validation in safety-critical industrial informatics systems remains limited. Accordingly, JEPA is discussed in this survey as a representative state-predictive architecture that illustrates potential future design directions, rather than as a validated replacement for AR systems.

3.1. Certifiability and Verification of Latent Projection Mappings

State-predictive architectures such as JEPA rely on latent representations that must be mapped to interpretable system variables in order to interface with industrial control systems. These mappings are typically implemented using projection heads or decoder modules that transform latent embeddings into structured outputs, such as predicted system states or candidate control references.

From a functional safety perspective, such projection mappings must be treated as learned components whose outputs cannot be assumed to satisfy safety constraints without independent verification. Unlike analytical control laws, learned projection functions do not provide intrinsic guarantees of correctness or robustness across all operating conditions.

Accordingly, industrial deployment architectures enforce architectural separation between learned predictive components and safety-critical decision authority. Projection heads provide candidate state estimates, while certified planners, constraint solvers, and runtime assurance mechanisms enforce safety invariants. This separation ensures that learned components cannot directly cause unsafe system behavior.

Safe integration of projection mappings can be supported through multiple complementary mechanisms. Runtime assurance architectures, including Simplex supervisory control and control barrier function filters, ensure that control actions remain within certified safe sets. Formal verification methods, such as SMT- and MILP-based neural network verification, can establish bounded correctness properties for constrained neural components. In addition, statistical monitoring and anomaly detection can identify unreliable outputs and trigger fallback to certified baseline controllers.

Importantly, safety guarantees are provided at the system architecture level rather than by learned projection mappings themselves. This layered design principle aligns with established functional safety standards, including IEC 61508 and ISO 26262, which require that safety-critical behavior be governed by verifiable components. Accordingly, projection heads in JEPA-style architectures should be regarded as advisory state-estimation modules whose outputs are subject to downstream verification and constraint enforcement within standards-aligned control architectures.

3.2. An Overview of the JEPA Models

Advancements in AI have increasingly relied on changes to the training architecture’s attributes. Chief among these in modern times is the use of SSL. Unlike its predecessor SL, SSL does not require labeled data, granting the model access to dramatically more training data. Recent surveys and overviews document this shift across vision and language [50]. The greatest difficulty to be overcome in SSL training is preventing the collapse of the model, which can be accomplished through the implementation of regulation techniques. One of the first techniques was Variance-Invariance-Covariance (VICReg), which balances similarity and variance in training to allow for productive training while preventing collapse [51]. Joint-Embedding Predictive Architectures (JEPA) improved VICReg by freeing the model from reliance on augmented data. Additionally, JEPA creates latent embeddings rather than explicit outputs, allowing it to predict in broad strokes. JEPA has seen a few iterations analyzing images (I-JEPA) [52] and motion and content (MC-JEPA) [53]. MC-JEPA consists of two separate embedding spaces that work in conjunction with each other. The theoretical next improvement, hierarchical JEPA (H-JEPA), introduces multi-level abstraction. We therefore examine these architectures, their underlying principles, and their current evidentiary status relative to established industrial informatics architectures [43,54].

3.2.1. Limitations of SSL

As introduced before, SSL is not without its limitations. The lack of oversight needed in its training requires that the pretext task be carefully formed so that it does not cause discrepancies in the production of the masked training data. The second intrinsic limitation is that in becoming more generalized, SSL models lose task-specific optimizations. A similar limitation comes about from training on less clean data. If the data has a bias, that bias will be carried over into the model itself. If the model’s training is improperly set up, it is difficult to see where the error lies until the model is trained to a usable level. The lack of analyzability of the model’s training comes from the obscurity surrounding which portions of the data are seen as significant by the model. The larger the data set, the less these problems arise, but the cost in computing is significant despite the increase in training efficiency. There is one more critical flaw in SSL, which must be avoided: the possibility of collapse. If the model can perfectly optimize all its training samples, the model “learns” nothing from the data.

Figure 2 reports the limits of AR generative models. AR generative models produce one token at a time, conditioning each new prediction on a fixed-length past context. The encoder processes a prompt of previous tokens $\mathit{x}\left[\mathit{t}-\mathit{n}\right],\dots ,\mathit{x}\left[\mathit{t}\right]$, and the stochastic predictor outputs the next token sequentially $(\mathit{x}\left[\mathit{t}+\mathbf{1}\right],\mathit{x}\left[\mathit{t}+\mathbf{2}\right],\dots )$. This step-by-step generation limits long-range reasoning and holistic world modeling, as future predictions depend narrowly on short, localized temporal windows rather than on structured hierarchical representations.

3.2.2. VICREG

Variance-invariance-covariance regularization (VICReg) is a method to prevent collapse in training SSL models. Three components allow it to function:

• Variance—Encourages each dimension of the representation vector to maintain sufficient variability across samples, preventing trivial constant solutions.
• Invariance—Ensures that representations of augmented versions of the same input are close in embedding space, capturing shared semantic content.
• Covariance—Penalizes the model for correlations in different dimensions, encouraging the encoding of independent information in different dimensions.

These together prevent collapse while still leading to a system that does not rely on labeled data or large batches of data. Training on raw data greatly decreases the cost of training while preserving over 70% accuracy when testing for top-1 accuracy [55].

3.2.3. JEPA

JEPA architecture [43] is an advancement from VICReg. It provides an increase in functionality, but, more crucially, JEPA’s latent-state formulation is designed to support more structured prediction and planning. Yet, at present this should be viewed as an architectural promise rather than a fully validated reasoning capability. The principal difference between JEPA and VICReg is that, rather than training on mutated images, as is the case in VICReg, JEPA hides portions of the image and trains to predict that data. This takes a portion of the possibility of human error out of the equation. The removal of augmented training data not only creates a cleaner model but also allows the representational prediction to be based purely on real data. While older predictive models (autoregressive) still dominate in simpler use cases such as LLMs (GPT, Claude, LLaMA), in problems with higher-dimensional structured states, JEPA-style latent prediction has been argued to be a more natural fit than token-level AR factorization, and early experiments in vision domains indicate competitive or superior performance on representation quality and downstream tasks. However, these results are still limited in scope and do not yet constitute broad evidence in industrial control settings.

A machine running JEPA fundamentally differs from one processing material through a predictive model. JEPA produces latent semantic embeddings, which can be used downstream to produce an outcome. A predictive model directly creates the output token by token through an analysis of all the data present and makes a single concrete prediction regarding it.

In particular, Figure 3 provides a comparison between generative and joint embedding architectures. In a generative architecture, the encoder $Enc\left(x\right)$ maps the input $x$ into a latent representation $s_x$, which is used by a predictor $Pred(s_x,z)$ to generate a reconstruction $\tilde{y}$. The model is trained by minimizing a reconstruction loss $\mathcal{D}(s_y, {\tilde{s}}_y)$. Examples include Variational Autoencoders (VAE) and Masked Autoencoders (MAE).

Instead, in a Joint Embedding architecture, two encoders $Enc\left(x\right)$ and $Enc\left(y\right)$ project paired inputs into embeddings $s_x$ and $s_y$; a predictor aligns the embeddings by minimizing a similarity loss $\mathcal{D}(s_y, {\tilde{s}}_y)$. This paradigm is used in self-supervised models such as contrastive and I-JEPA frameworks.

3.2.4. I-JEPA

The beginning of JEPA was in image comprehension, namely known as I-JEPA. I-JEPA [52] has two parts to allow it to function in real-world tasks. The backbone is a JEPA module trained on unlabeled data, fully unsupervised. To convert the vectors produced by JEPA into a useful form, a downstream module adapts the embeddings into the desired output. If the model is meant to generate an image, JEPA constructs what the image should be abstractly, and a decoder takes that and makes it concrete in pixels. If an image is meant to be classified, a classifier module is used on top of the JEPA to place each image into its proper grouping. JEPA tells the classifier what each item is, but does not of its own accord direct them into their proper place. Given this additional module, even though the method is different from previously established models, I-JEPA was tested to have superior top-1 accuracy compared to older architectures.

Figure 4 provides an overview of the I-JEPA architecture. The model learns by predicting high-level representations of missing image regions rather than reconstructing pixels. A context encoder $f_{\theta }$ extracts embeddings from visible patches (context), which are then processed by a predictor $g_{\varphi }$ to estimate the embeddings of masked target regions. A target encoder $f_{\theta }$ independently encodes the true target patches. The training objective minimizes the $L_2$ distance between the predicted and target embeddings, encouraging semantic consistency across different image regions.

While I-JEPA is primarily a pre-training and representation-learning method, it enables or improves a variety of downstream tasks. Here are use-cases (some direct, some via extension) that have been reported or discussed:

• Image classification

After pre-training with I-JEPA, the learned encoder can be fine-tuned or linearly probed for image classification tasks (e.g., on ImageNet). Relevant use cases can be any visual-recognition pipeline where there is need for a backbone that has learned good semantics without heavy labels [52].

• Object counting/density estimation

The original I-JEPA paper [52] mentions downstream performance in object counting tasks. The corresponding use case is that of visual inspection, crowd-counting, inventory monitoring (for example in an insurtech or visual-damage context where the stakeholders might want to count objects/damages) [53].

• Depth prediction/geometry estimation

The authors of [47] report improvement (by a large margin) on depth prediction tasks compared to some prior methods. This proves helpful in robotics, autonomous driving, 3D perception, where good semantic plus geometric representations help.

• General representation backbone for downstream vision tasks

Because I-JEPA emphasizes learned semantics rather than pixel-reconstruction, its representations are useful for a broad set of vision tasks: segmentation, detection, transfer learning to new domains. While not all specific papers are cited here, the blog/discussion indicates this is a promise [48]. In the context of damage recognition in Insurtech, for instance, an I-JEPA-pretrained backbone could be used and then fine-tuned on a damage dataset for improved performance in terms of segmentation of damaged regions or classification of damage types.

• Transfer to other modalities/field extensions

Though not strictly in the image domain, the I-JEPA architecture has been extended to other domains:

○

A-JEPA for audio/speech classification [49];

○

HEP-JEPA for high-energy physics, which applies JEPA-style self-supervision to collider-jet data [56].

• Outlier detection/data-density estimation

Very recently it was shown in [55] that JEPA-style models implicitly learn something akin to the data density (allowing outlier detection) because the anti-collapse term can be used to compute sample likelihoods.

3.2.5. MC-JEPA

While I-JEPA is capable of robust interpretation of images, it is the addition of motion training that allowed the model to come into its own. The goal of MC-JEPA (motion and content JEPA) [53] is to create a model that understands both what a thing is and the possible future states it can take. This is accomplished by separating the embedding space for content processing from the embedding space for motion processing. These are fed in parallel into the predictor head. The use of multiple vector spaces allows the model to have robustness in both regards. Since an image in motion is necessarily changing, it is important that the notion of what something is and where it is be superimposed. Through the use of separate vector spaces, the two concepts do not affect each other, while the predictor is given a greater degree of precision in determining future states.

In Figure 5 we provide an overview of the MC-JEPA architecture. The model jointly learns content features and motion dynamics through self-supervised objectives. Multiple spatial views (View 1, View 2) are encoded to learn invariant content representations, while consecutive temporal frames (Frame t, Frame t + 1) are encoded to estimate optical flow and temporal consistency. This dual-stream structure enables disentanglement and joint learning of appearance and motion within a unified predictive framework.

MC-JEPA is particularly effective as:

• It embeds both motion and content into a unified representation, which gives richer information (often static models ignore how things move);
• It is self-supervised: it is possible to leverage unlabeled video/image data;
• It offers potentially better generalization: because the model learns dynamics, it might handle new/unseen changes or damage scenarios better.

3.2.6. H-JEPA

While MC-JEPA provides two inputs in parallel, the goal of the currently theoretical H-JEPA [57] is to have multiple vector spaces work in series. The principle behind this would be to allow the vector spaces to inform subsequent fields of notable portions of their prediction. A higher level predicts the general scope of the solution. This overview is passed down to the subsequent space, which fills in the details falling under the constraints of the higher-order prediction. This process continues until what began as a general abstract prediction is carefully refined into a rational output.

Figure 6 depicts an illustration of the Hierarchical Joint Embedding Predictive Architecture (H-JEPA). The model learns a multi-level predictive hierarchy where each encoder–predictor pair $(En{c}_i, Pre{d}_i)$ builds increasingly abstract representations $z_i$ and contextual predictions $C(s_i, a_i)$. At each level $k$, the predicted action defines an objective for the lower level $k-1$, enabling hierarchical planning and long-range reasoning. This approach captures structured world models and cost-minimizing planning dynamics that are currently absent from standard architectures such as AR-LLMs and multimodal learning systems.

An H-JEPA model would possess a greater apparent sense of intuition than other AI models. The layered processing would prevent it from slipping into nonsensical mistakes. Many AI models are partial to making these errors, losing sight of the forest for looking at the trees. The ideal would be if the layers were themselves guided by a processor that judges the greater need for either broad scope prediction or fine detail prediction. This model is much closer to a thinking AI. It falls short of AGI insofar as it is not self-training, able to learn from observing the world, and does not assign itself objectives. It would be a remarkable improvement towards thinking AI and would bring about the possibility of general AI without falling into more hallucinations, the more information it is given.

It is still a significant task to create a system that can deal with the synthesis of subordinate embedding spaces without collapsing. Additionally, there is a need for a training design that can meaningfully connect different levels of space. These issues are aside from the question of the training cost and the viability of scaling such a model. While there are still difficulties that need to be resolved, there is much hope that a working H-JEPA model will exist within the next five years. The future will show to what degree this model integrates with the industry of AI.

3.3. Evidentiary Maturity and Industrial Deployment Status

While JEPA and Hierarchical JEPA provide a conceptually appealing framework for state-predictive modeling, their empirical validation in industrial informatics remains at an early stage. Existing experimental evidence primarily demonstrates improved representation learning efficiency, robustness, and predictive consistency in multimodal and perception-oriented benchmarks. These results suggest potential applicability to state-based reasoning tasks but do not yet constitute validation in safety-critical industrial control environments.

By contrast, established industrial deployment architectures rely on planner-of-record control systems, deterministic optimization modules, and runtime assurance mechanisms, which have been extensively validated in robotics, automotive, and process control domains. In such systems, machine learning components operate within constrained roles, providing perception, interpretation, or advisory functionality, while certified control modules retain decision authority.

Integration of JEPA-style world models into such architectures would require additional validation, including demonstration of stability, robustness under distribution shift, compatibility with safety verification frameworks, and predictable behavior under operational constraints. These requirements reflect standard functional safety principles defined in IEC 61508, ISO 26262, and related standards.

Accordingly, JEPA and H-JEPA should be understood, at present, as promising research directions that address architectural limitations of token-predictive models, while their practical deployment in industrial informatics remains subject to further empirical validation and integration with established safety-critical system architectures.

3.4. Interpretability and Verification of Latent States

A central tension in deploying JEPA-style world models in safety-critical industrial informatics is the apparent “interpretability paradox.” JEPA moves prediction from token sequences to high-dimensional latent states $z$, which are optimized for predictive sufficiency and compactness rather than human readability. By contrast, industrial verification and certification under IEC 61508, ISO 26262 and related standards require transparency, traceability, and explicit arguments formulated in terms of physical variables, safety goals, and constraints.

In this paper, we do not propose to verify arbitrary low-energy latent vectors directly. Instead, we adopt an explicit separation of concerns, in which JEPA is used as a world-model substrate that feeds structured interfaces to classical safety mechanisms. Concretely, a JEPA-based safety-critical architecture is organized into three layers:

• Latent world model. The encoder–predictor stack maps observations and actions into a compact latent space and predicts future latent states,

$$z_t=\mathrm{E}\mathrm{n}\mathrm{c}\left(o_t\right),z_{t+1}=f_{\theta }(z_t,a_t),$$

where $o_t$ denotes raw observations (sensor data, images, logs) and $a_t$ denotes control or decision variables. The energy function $E_{\theta }\left(z_t,a_t,z_{t+1}\right)$ is minimized for “compatible” transitions according to the learned dynamics. At this level, the representation is opaque and is not used directly for safety arguments.

2.

Safety-relevant projections (“heads”). A family of engineered or learned projection modules maps latent states to a small set of interpretable variables that carry physical or logical meaning for the plant:

$$x_{t+1}^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}}=h_{\varphi }(z_{t+1}),$$

where $x_{t+1}^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}}$ may contain joint positions and velocities, inter-vehicle distances, temperatures, or Boolean indicators of safety-zone occupancy. In practice, different heads can be defined for different views of the same latent state (e.g., kinematic variables, environmental margins, risk scores). These heads are the only interface through which safety mechanisms “see” the JEPA world model.

3.

Verifiers and runtime monitors. Safety constraints, runtime checks, and formal guarantees are expressed exclusively in terms of $x^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}}$  (and, where applicable, the underlying plant state). A generic safety constraint has the form

$$g_i(x_{t+k}^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}})\le 0, i=1,\dots ,m,\hspace{0.25em} k\ge 0,$$

and is implemented by a runtime monitor, model-predictive controller, or safety filter. These components are analyzable using standard techniques from control, formal methods, and functional safety engineering. From the auditor’s perspective, the safety case is written against $x^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}}$ and $g_i(\cdot )$, not against raw latent vectors.

Within this three-layer view, a low-energy prediction in the JEPA sense indicates compatibility with the learned dynamics and data manifold, not safety. Energy minimization reduces prediction error and enforces coherence with past data; it does not by itself guarantee that the resulting state satisfies ISO 26262 or SOTIF constraints. Safety arises only when the latent state is projected through $h_{\varphi }$ into interpretable variables and checked against explicit constraints by verifiers and runtime monitors.

3.4.1. Example: Robotic Arm Velocity Constraint

The “interpretability paradox” becomes concrete in a simple robotic arm scenario. Consider a JEPA world model trained for a robotic manipulator operating in a shared workspace. At time $t$, the model encodes the current observation $o_t$ into a latent state $z_t$, receives a candidate control action $a_t$ from a planner, and predicts a future latent state

$$z_{t+1}=f_{\theta }(z_t,a_t)$$

with low energy $E_{\theta }(z_t,a_t,z_{t+1})$. This low energy indicates that the transition is plausible with respect to the learned dynamics, but says nothing yet about its safety.

To connect this prediction to a concrete safety requirement—e.g., such as a velocity limit on the joints—we introduce a dedicated projection head $h_v$ that maps the latent state to joint velocities:

$$v_{t+1}=h_v\left(z_{t+1}\right)\in {\mathbb{R}}^n,$$

where each component corresponds to a joint of the manipulator. The safety specification imposes a hard bound on these velocities, for instance

$$\parallel v_{t+1}{\parallel }_{\mathrm{\infty }}<2 \mathrm{m}/\mathrm{s}.$$

A runtime monitor evaluates this inequality before the command is dispatched to the actuators. If the constraint is violated, the monitor can clamp the command, request replanning, or trigger a safe stop, depending on the system’s safety concept. Crucially, the safety argument is articulated purely in terms of $v_{t+1}$, which is physically meaningful, and the explicit inequality above. The latent vector $z_{t+1}$ remains an internal representation that supports prediction and planning but is never used directly in the certification argument.

This example illustrates how a JEPA world model can provide strong planning capabilities in latent space while preserving transparency at the safety layer: auditors and runtime monitors only reason about interpretable quantities such as joint velocities and distances, not about the raw latent codes.

3.4.2. Planning Capability vs. Interpretability

The division between latent prediction and interpretable verification also clarifies the trade-off between planning capability and transparency.

JEPA’s latent space is optimized to support long-horizon, multi-modal prediction. It can represent uncertainty, context, and abstract features that are not easily encoded in flat, hand-designed state vectors. This is advantageous for planning under partial observability and complex dynamics.

At the same time, the presence of explicit projection heads and state constraints ensures that interpretability is preserved where it matters: the system’s obligations under industrial safety standards are specified and checked in terms of concrete physical quantities and logic-level predicates.

From an architectural standpoint, this leads to a decoupling of prediction and verification:

Prediction and representation learning occur in the latent space $\mathcal{Z}$, where the model is free to discover compact encodings and low-energy manifolds that simplify long-horizon reasoning.

Verification, assurance, and certification remain anchored in an interpretable state space ${\mathcal{X}}^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}}$, derived from $\mathcal{Z}$ through well-specified and testable mappings.

In this sense, JEPA-style world models do not replace the transparency requirements of industrial standards; rather, they support bounded-rational AI as a component within a larger, standards-aligned architecture. The bounded rationality claim in this work should therefore be read as follows: by shifting prediction from token-level continuation to structured latent states that are explicitly connected to verifiable safety variables, JEPA facilitates architectures where long-horizon reasoning and stringent safety verification can coexist.

3.5. Last-Mile Hallucinations and Decoder Dependency

The use of JEPA as a world-model architecture does not, by itself, eliminate the risk of hallucinations or artifacts in the final outputs. While JEPA moves prediction from token-level sequences to latent states $z$, any system that ultimately produces human-interpretable content (text, images, video) must still include a decoder mapping latent states back to observations. This decoder remains a generative component and can introduce inaccuracies or hallucinations even when the latent prediction itself is coherent and “rational.” In this subsection, we distinguish deployment regimes, analyze error propagation at the decoder stage, and clarify the scope of our grounding claims, particularly in the industrial control setting.

3.5.1. Observation-Centric vs. Control-Centric JEPA

It is useful to distinguish two high-level regimes in which JEPA-style models may be deployed:

• Observation-centric JEPA. The model is used primarily for generative media or natural-language tasks. The pipeline factorizes as

$$z_{t+1}\sim p_{\theta }(z_{t+1}\mid \mathrm{context}),o_{t+1}\sim p_{\psi }(o_{t+1}\mid z_{t+1}),$$

where $o_{t+1}$ denotes the observation (text, image, audio, etc.), $p_{\theta }$ is the JEPA predictor over latent states, and $p_{\psi }$ is a decoder. The decoder can be autoregressive, diffusion-based, or another conditional generator. In this regime, even if $p_{\theta }$ produces a “rational” latent plan, $p_{\psi }$ can still generate outputs that are partially inconsistent, off-distribution, or hallucinated.

• Control-centric JEPA. The model is used primarily as a world model for planning and control in a safety-critical loop. The pipeline is instead

$$z_{t+1}=f_{\theta }(z_t,a_t),x_{t+1}^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}}=h_{\varphi }(z_{t+1}),u_{t+1}=\pi (x_{0:T}^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}}),$$

where $a_t$ is a candidate action, $x_{t+1}^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}}$ is a vector of interpretable, safety-relevant variables (e.g., positions, velocities, distances, occupancy flags), and $\pi$ is a controller or planner (possibly MPC-based) operating on these variables. Here, the control loop does not rely on a free-form decoder that renders natural language or images for actuation. Instead, it uses structured variables and constraints.

Our strongest claims about improved “grounding” and compatibility with industrial safety standards are targeted at this control-centric regime, where actions are derived from interpretable state variables and verified by classical monitors, rather than being driven by the output of a generative decoder.

3.5.2. Decoder-Stage Error Propagation

In the observation-centric regime, the JEPA with decoder architecture can be written as

$$p(o_{t+1}\mid \mathrm{context})=\sum _{z_{t+1}}{p}_{\theta }(z_{t+1}\mid \mathrm{context})\hspace{0.17em}{p}_{\psi }(o_{t+1}\mid z_{t+1}).$$

Here, JEPA reshapes the distribution over latent futures $p_{\theta }(z_{t+1}\mid \mathrm{context})$, encouraging trajectories that are globally coherent and dynamically compatible. However, the “last mile” distribution $p_{\psi }(o_{t+1}\mid z_{t+1})$ still determines how these latent states are rendered as observable outputs.

Several implications follow:

• Localization of failure modes. JEPA makes it conceptually clearer where different types of errors originate. Incoherent long-horizon plans and physical implausibility stem from deficiencies in $p_{\theta }$, while surface-level hallucinations, stylistic artifacts, or mismatches between latent intent and rendered content stem from $p_{\psi }$.
• Decoder brittleness remains. Even if the latent prediction is “rational” in the sense of being low-energy and consistent with the learned world model, the decoder can still produce hallucinated text, spurious details in images, or incorrect low-level formatting in code. In this respect, the decoder shares many of the brittleness properties of autoregressive models.
• Mitigations at the decoder interface. The decoder stage must therefore be subject to its own safeguards: strong supervised training, constrained or structured decoders (e.g., grammar-constrained code generation), cross-checks between decoded content and latent predictions, and runtime filters or verifiers on decoded outputs. These mechanisms are analogous to the RAG, tool-use, and runtime assurance patterns we advocate for autoregressive models in Section 3.

Consequently, JEPA does not remove the need to manage hallucinations at the “last mile;” instead, it introduces a clear architectural separation between planning/world modeling and surface realization, which can help isolate and monitor decoder-induced errors more systematically.

3.5.3. Grounding Claims in Industrial Control Scenarios

Given this separation, our claims about JEPA being advantageous for “grounding” must be interpreted carefully:

• In media-generative, observation-centric applications, a JEPA with decoder system still inherits much of the brittleness of generative decoders. Grounding here depends on additional mechanisms—retrieval over trusted corpora, structured tool calls, output verifiers—applied at the decoder output, just as in AR-based systems. JEPA’s contribution is mainly to provide a more coherent latent planning substrate, not to guarantee that decoded content is always faithful.
• In industrial control and robotics, which are the primary focus of this paper, the architecture is designed so that the control loop does not depend on a free-form decoder. Instead, the JEPA world model feeds safety-relevant heads $x^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}}=h_{\varphi }\left(z\right)$ that are subject to explicit constraints and runtime assurance mechanisms. In this control-centric regime, hallucinations in human-facing renderings (e.g., visualizations or textual explanations) do not directly affect the plant; they are decoupled from the safety-critical decision path.

In other words, JEPA’s contribution to grounding in our setting is not that it eliminates hallucinations everywhere, but that it allows the safety-critical path to operate entirely on interpretable state variables, while relegating generative decoding to non-critical interfaces such as reporting, visualization, or operator support. Where JEPA is combined with a decoder in the control loop, that decoder must be treated, tested, and constrained like any other generative component, with its own verification and runtime safeguards.

Under this interpretation, JEPA-style world models support bounded-rational AI by enabling architectures in which:

• Long-horizon reasoning and uncertainty are handled in a compact latent space;
• Safety-critical decisions are based on transparent projected variables subject to explicit constraints;
• Decoder-induced hallucinations are confined to non-critical channels or are actively mitigated using mechanisms parallel to those required for autoregressive models.

This framing aligns JEPA with industrial safety requirements without over-claiming on the elimination of hallucinations in the generative part of the pipeline.

It has been hypothesized that state-predictive world models could reduce reliance on unconstrained free-form generation for representing system evolution; however, this hypothesis requires dedicated closed-loop evaluation and assurance evidence before being used as a deployment justification.

All in all, a state-predictive component can reduce the system’s reliance on free-form token generation when downstream decisions depend on physical dynamics, but it does not by itself guarantee factual correctness, safety, or truthfulness. Grounding and correctness still require explicit evidence channels (retrieval, sensors, logs), verifiers, and monitors. We therefore position JEPA/H-JEPA as potentially useful for state/trajectory prediction within assured architectures (Patterns C/D), not as a stand-alone mechanism for grounding or hallucination elimination.

3.6. Low-Energy States vs. Safe States

The use of Energy-Based Models (EBMs) in JEPA introduces an important conceptual distinction between compatibility and safety that must not be conflated. The energy function $E_{\theta }(z_t,a_t,z_{t+1})$ is trained so that plausible transitions under the learned dynamics and data distribution have low energy, while implausible transitions have high energy. Formally, the world model is optimized to minimize a prediction-oriented loss (or energy) of the form

$$\underset{\theta }{\mathrm{m}\mathrm{i}\mathrm{n}} \mathbb{E}[{\mathcal{l}}_{\mathrm{pred}}(z_t,a_t,z_{t+1})],$$

where ${\mathcal{l}}_{\mathrm{pred}}$ penalizes incompatibility between predicted and observed latent trajectories. This objective reflects predictive accuracy and data-driven plausibility, not compliance with external safety standards.

In contrast, safety is defined with respect to explicit constraints on interpretable variables, such as those mandated by IEC 61508, ISO 26262, or ISO 21448. If $x_{t+1}^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}}=h_{\varphi }\left(z_{t+1}\right)$ denotes a vector of safety-relevant quantities (e.g., joint positions and velocities, inter-vehicle gaps, safety-zone occupancy), then safety constraints are expressed as

$$g_i(x_{t+k}^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}})\le 0, i=1,\dots ,m,\hspace{0.25em} k\ge 0,$$

and are enforced by planners, controllers, or runtime monitors operating on $x^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}}$, not on raw latent states. Under this perspective, a state in which a robot collides with a wall may be entirely compatible with the physics of the world model (and thus assigned low energy) while being strictly unsafe because it violates one or more constraints $g_i$.

Hard constraints can interact with the energy landscape in several ways, without changing this fundamental separation. In constraint-aware training, known unsafe transitions (obtained, for example, from simulation or hazard analysis) can be explicitly assigned higher energy via additional penalty terms, encouraging the model to avoid unsafe regions during planning:

$$\underset{\theta }{\mathrm{m}\mathrm{i}\mathrm{n}}\mathbb{E}[{\mathcal{l}}_{\mathrm{pred}}]+ \lambda \hspace{0.17em}\mathbb{E}[{\mathbf{1}}_{\left\{g\right(x^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}})>0\}}\cdot {\mathcal{l}}_{\mathrm{unsafe}}].$$

In constrained planning, JEPA serves as a dynamics model inside an MPC or planner solving

$$\underset{a_{0:T}}{\mathrm{m}\mathrm{i}\mathrm{n}}\sum _{t=0}^{T-1}{\mathcal{l}}_{\mathrm{pred}}(z_t,a_t,z_{t+1})\mathrm{s}.\mathrm{t}.{ g}_i(x_{t+k}^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}})\le 0,$$

with $z_{t+1}=f_{\theta }(z_t,a_t)$ and $x_{t+1}^{\mathrm{s}\mathrm{a}\mathrm{f}\mathrm{e}\mathrm{t}\mathrm{y}}=h_{\varphi }(z_{t+1})$. Here, safety guarantees arise from the explicit constraints in the planner, while the energy term focuses on prediction quality. Finally, hybrid schemes can augment the energy with a safety potential, e.g., $E_{\mathrm{total}}=E_{\mathrm{model}}+\alpha \hspace{0.17em}{E}_{\mathrm{safety}}$, where $E_{\mathrm{safety}}$ grows near constraint boundaries (e.g., via barrier functions). In all cases, JEPA provides a coherent world-model substrate, whereas satisfaction of formal safety requirements is ensured by explicit constraints and monitoring mechanisms layered on top of, or embedded into, the energy landscape.

3.7. Safety and Reliability Considerations for JEPA-Style World Models

The JEPA family of models is attractive for industrial informatics because it shifts prediction from token-level continuations to latent state representations, potentially enabling more structured reasoning and long-horizon foresight [43]. However, when such models are deployed in safety- or mission-critical applications, their benefits must be assessed against explicit safety and reliability requirements, in alignment with functional-safety standards such as IEC 61508, ISO 26262, and ISO 21448 (SOTIF) [42,45,46]. Importantly, these standards do not certify a particular AI architecture; instead, they prescribe a functional-safety lifecycle and requirements on system behavior, evidence, and development process. In this context, a JEPA world model should be treated as a software element embedded in a safety-related E/E/PE system, not as a stand-alone safety function. This section clarifies (i) the near-term, standards-aligned role of JEPA/H-JEPA as a world-model component, (ii) the key safety challenges it introduces (interpretability, coverage, and assurance), and (iii) how this compares to an autoregressive (AR) model combined with a runtime assurance envelope (Pattern D).

From a safety-engineering standpoint, JEPA/H-JEPA world models offer several potential advantages over purely autoregressive decoders. First, state-space prediction can be coupled more naturally with model-based controllers and planners that already operate on trajectories and constraints: high-level constraints may be enforced at upper layers of a hierarchical JEPA and refined at lower layers. Second, energy/compatibility scores can serve as additional signals for anomaly detection or out-of-distribution behavior: unusually high energy values may flag states or transitions that violate learned regularities, providing inputs to runtime monitors or supervisory checks [43]. Third, by explicitly modeling dynamics rather than static correlations, JEPA/H-JEPA aligns with the needs of predictive control, where anticipating system evolution under different actions is central to safe operation.

At the same time, JEPA-style world models introduce safety challenges that must be addressed explicitly before they can be trusted in industrial contexts. A first issue is opacity of the latent space: the internal representations are high-dimensional and not directly interpretable by human auditors. While AR models often expose human-readable artifacts (text, code, structured messages), JEPA states and energy landscapes are not intrinsically transparent, complicating traceability, failure-mode analysis, and explainability. This strengthens the need for projection mechanisms, attribution, and interpretability techniques that relate latent trajectories to observable system behavior and safety requirements, as already highlighted at the end of Section 3 [25,39]. A second issue concerns coverage and robustness of learned dynamics: since JEPA/H-JEPA learns from data rather than explicit physical models, prediction reliability depends on the representativeness of the training distribution. Incomplete coverage of rare but hazardous conditions can yield over-optimistic forecasts precisely where safety margins are tight. Consequently, standards-aligned deployments require scenario-based testing, stress testing, and adversarial evaluation, including synthetic/simulated data targeting corner cases identified during hazard analysis [42,45,46]. Third, there is the problem of formal verification and runtime assurance. Even if a world model performs well on validation scenarios, functional safety typically requires assurance that the overall system remains within defined safe sets across its operational envelope. Accordingly, JEPA outputs should be mediated by certified controllers, planners-of-record, or runtime assurance envelopes (Section 3.2): JEPA should inform prediction, cost shaping, or scenario rollouts, but should not directly drive actuation without checks against physical constraints and safety invariants [19].

3.7.1. IEC 61508 and ISO 26262: JEPA as a World-Model Component

Within IEC 61508, a JEPA-based world model can support multiple phases of the safety lifecycle while remaining a supporting software component rather than the safety function itself. During hazard and risk analysis, a JEPA world model of plant and environment can generate long-horizon trajectories under diverse operating conditions and candidate control policies, enabling scenario-driven hazard identification that goes beyond simple worst-case assumptions by exploring how environment and plant evolve in response to actions. During design and implementation, JEPA is integrated as a non-deterministic module with clearly defined interfaces: the latent-state predictor $f_{\theta }$ and safety-relevant projections $h_{\varphi }$ are coupled with (i) a planner/controller operating on interpretable safety variables $x^{\mathrm{safety}}=h_{\varphi }\left(z\right)$, and (ii) system-level safety mechanisms (constraints, monitors, safe-state logic). The safety functions mandated by IEC 61508—e.g., limiting speed, enforcing separation distance, triggering safe stop—are implemented by explicit constraints and control logic on $x^{\mathrm{safety}}$, not by the JEPA energy function.

Verification and validation then target both (i) world-model performance (prediction error, robustness, ODD coverage) and (ii) safety logic correctness acting on the projected variables $x^{\mathrm{safety}}$. Because JEPA predicts in a state-like space, test cases and coverage metrics can be expressed in physical quantities (positions, velocities, distances, temperatures), which is aligned with established ISO 26262 practices for control software verification.

In ISO 26262, JEPA naturally fits as a supporting element in HARA and ASIL determination and in model-based controller design and verification. By simulating trajectories under different environmental conditions and failure modes, JEPA can help identify hazardous scenarios and refine ASIL assignments via quantitative exploration rather than purely symbolic reasoning. For controller synthesis, JEPA can provide a learned dynamics model for an MPC/planner-of-record that enforces ASIL-derived constraints on $x^{\mathrm{safety}}$. In this architecture, JEPA improves plant/environment model fidelity, but compliance still rests on the transparency and verifiability of the planner/controller, constraints, monitors, and evidence produced along the safety lifecycle.

Overall, under IEC 61508 and ISO 26262, JEPA is best positioned as a world-level prediction component that enhances hazard analysis and controller design, while the safety case is made on the explicit constraints and logic applied to interpretable variables derived from JEPA—not on the learned energy landscape itself.

3.7.2. ISO 21448 (SOTIF): Feature-Level Prediction, ODD Coverage, and Unknown Unsafe Scenarios

ISO 21448 (SOTIF) emphasizes the Safety of the Intended Functionality, particularly in the presence of performance limitations, unknown unsafe scenarios, and ODD boundaries. JEPA’s feature-level, state-space orientation is especially relevant here. JEPA predicts the evolution of environment and plant states (e.g., positions, velocities, visibility, occupancy, sensor-level features) rather than sequences of tokens, and these variables are close to those used to specify ODD conditions and SOTIF-relevant scenarios. By sampling latent trajectories and projecting them to $x^{\mathrm{safety}}$, engineers can explore corner cases and rare combinations of conditions (e.g., unusual traffic configurations, adverse weather, sensor occlusions), identify regions of the ODD where the intended function is weak or underspecified, and relate unsafe behaviors back to regions of state space and training distribution. This can strengthen SOTIF activities such as scenario definition, coverage analysis, and targeted testing. Nonetheless, SOTIF compliance still depends on explicit processes—scenario engineering, coverage metrics, validation, and monitoring—rather than on the mere inclusion of a world model; JEPA should therefore be viewed as a substrate that supports SOTIF, not as a mechanism that “solves” it.

3.7.3. When Token-Centric Mitigations Suffice vs. When to Add State/World-Model Components

In this survey we do not introduce new experiments; instead, we make the decision guidance evidence-oriented by (i) defining observable proxies for key criteria, (ii) prescribing a stepwise decision procedure, and (iii) grounding each step in the literature via the evidence map (

Table A2. Operational decision framework (RQ3): criteria, observable proxies, recommended pattern(s), and what to measure.

Criterion (RQ3)	Observable Proxies (What You Can Actually Check)	Primary Risk If Ignored	Recommended Pattern(s)	What to Measure or Report (Survey Guidance)
C1. Safety impact of outputs	Output triggers actuation, configuration changes, alarms, safety-relevant recommendations	Unsafe action/commitment	C + D (planner-of-record + runtime assurance). If purely text artifact with sign-off: A/B	Constraint violations, near-miss overrides, time-to-intervention, audit logs completeness
C2. Hard constraints vs soft preferences	Explicit constraints (speed/force/temperature bounds, SOP rules, access control)	Violations of non-negotiable limits	C (constraints enforced by solver/MPC) + optionally D	Rate of constraint infeasibility, overrides, feasibility margin, safety envelope breaches
C3. Horizon length/multi-step dependence	Tasks require long sequences (plans, procedures), long rollouts, multi-stage workflows	Compounding errors (F1), drift	B (iterative verification), C (planning), optionally D	Stepwise success rate, error accumulation vs steps, recovery rate, rollback frequency
C4. Dependence on up-to-date/private knowledge	Correctness depends on policies, manuals, latest incidents, internal KB	Hallucination/stale knowledge (F3)	B (RAG + verifiers). If safety-critical: combine with A/C/D	Citation coverage, retrieval hit rate, groundedness score, unsupported-claim rate
C5. Need for traceability and auditability	Outputs must be explainable, attributable, reproducible; compliance audits required	Non-auditable decisions	B (citations + verification logs) + A (human sign-off)	Traceability completeness, reproducibility under controlled seeds, decision logs, provenance
C6. Latency/throughput constraints	Real-time or near-real-time deadlines; cost constraints	Pattern too slow to deploy; scaling inefficiency (F4)	Prefer C/D for actuation; B with bounded retrieval; avoid heavy multi-agent loops unless justified	End-to-end latency, P95/P99, tool-call budget, compute cost, fallbacks
C7. Availability of verifiers/test oracles	You can check outputs via rules, simulators, tests, DB queries, constraint solvers	“No oracle” → unchecked hallucination	If strong oracles exist: B; if strong physical constraints exist: C; if neither: A only	Pass/fail rates, verifier coverage, false accept/false reject, adversarial robustness
C8. Data/ODD shift exposure	Frequent OOD conditions, changing environment, new failure modes	Brittleness, unsafe confidence	B with monitors + D for safety; consider C with conservative models	OOD detection rate, calibration error, drift metrics, safe fallback activations
C9. Authority separation feasibility	Can you isolate the LLM to “proposal/interface” role?	LLM becomes de facto controller	Enforce C (planner-of-record) or A (human) + explicit “LLM cannot actuate”	Permission boundaries, policy enforcement tests, penetration testing of tool calls
C10. State/trajectory prediction is central	Task depends on predicting physical evolution, dynamics, trajectories	Token-centric limits dominate; myopic objectives (F2)	C/D baseline first; world model only as advisory component under C/D	Closed-loop outcomes under scenario coverage; model error vs horizon; safety metrics
C11. Need for closed-loop guarantees	Formal guarantees required or expected by safety case	Cannot justify system behavior	D (runtime assurance) + certified controller; C where feasible	Formal invariants, monitor correctness arguments, verified fallback properties
C12. Maturity of world-model evidence (JEPA/H-JEPA)	Peer-reviewed evidence in the relevant domain (not only vision); control benchmarks; validated integration	Over-claiming; non-credible path	Treat JEPA/H-JEPA as research direction unless control evidence exists; keep C/D as basis	Explicit “evidence boundary”; compare vs. AR + RAG + verifiers + RTA baseline

in the Appendix A) and comparison matrix (

Table A3. Comparison matrix of representative prior systems (evidence from previous work).

Work/Approach (Representative)	Core Mechanism	Typical Evaluation Setting (as Reported in Literature)	Main Outcomes Reported (Typical)	AR Failure Modes Mainly Addressed	Pattern Mapping (A–D)	Evidence Boundary (How to Phrase in Survey)
Chain-of-Thought prompting	Intermediate reasoning traces	Reasoning/QA benchmarks	Better multi-step accuracy vs direct prompting	F1 (partially), F2 (partially)	A/B (weak)	Heuristic improvement; traces ≠ verification/guarantees
Tree-of-Thoughts/search over thoughts	Search/backtracking over candidate reasoning paths	Planning/reasoning tasks	Gains on complex tasks, cost increases	F1 (partially), F2 (partially)	A/B (weak–mid)	Self-evaluation is not an oracle; latency/cost trade-off
Program-of-Thoughts/tool-execution	Delegate computation to code/tool	Numeric reasoning, programming benchmarks	Improved correctness when tool is correct	F1 (partially), F3 (partially)	B	Requires strong tool correctness + schema validation; not safety proof
RAG (retrieval-augmented generation)	Retrieve evidence at inference time	Doc QA/knowledge-intensive tasks	Improved factuality/traceability vs parametric-only	F3 (main), cutoff issues	B	Retrieval can fail/poison; still needs verification and access control
ReAct-style tool use	Interleave reasoning + tool calls	QA/interactive tasks	Fewer unsupported claims, better task completion	F3 (main), F1 (partially)	B	Tool outputs require validation; “acting” must be permissioned
Toolformer-style learned tool use	Learn when to call tools	Tool-use benchmarks	More systematic tool calling	F3 (partially)	B	Still not a safety argument; must be bounded by policy/monitors
Self-reflection/Reflexion	Critique + episodic memory	Interactive tasks	Improves over iterations	F1 (partially)	A/B	Improvement not guaranteed; memory can encode wrong heuristics
Multi-agent orchestration (planner/solver/verifier roles)	Role separation + conversational control flow	Agentic task suites; system demos	Better robustness on complex tasks	F1/F3 (partially)	A/B	Framework evidence ≠ certified method; verifier quality is key
LLM as interface to robotics/autonomy stacks	LLM parses intent; autonomy stack executes	Robotics systems/demos/bench tasks	Feasibility improves when controller holds authority	F2 (main), F1 (partially)	C	Evidence depends on task + controller; not “LLM control”
LLM + MPC/optimizer (planner-of-record)	LLM proposes goals/costs; MPC solves	Robotics/control case studies	Constraint satisfaction and feasibility via MPC	F2 (main), F1 (partially)	C	Guarantees depend on model/ODD; LLM must not bypass solver
Runtime assurance/Simplex-style	Monitor + override to safe controller	CPS runtime assurance literature	Safety invariants enforced via monitor/fallback	“Consequence” of F1–F3 bounded	D	Guarantees only for specified invariants & monitor correctness
JEPA/I-JEPA (representation learning)	Predictive latent representations	Primarily vision/multimodal benchmarks	Better representations; downstream vision gains	Potentially relevant to F2 in principle	Adjunct to C/D	Evidence is NOT industrial control by default; treat as prospective
H-JEPA (hierarchical world-model concept)	Multi-timescale latent prediction	Largely conceptual/theoretical positioning	Conceptual promise for long-horizon planning	Hypothesized relevance to F1/F2	Adjunct to C/D	Must be presented as research agenda; no deployment recommendation

in the Appendix A).

In particular, Table A2 provides criteria that can be assessed from requirements, logs, and validation artifacts. Each criterion corresponds to a known source of AR failure (Section 3) and to a mitigation pattern (Section 4).

The relevant decision procedure can therefore be organized as follows.

Step 1—Identify the decision authority. If any downstream actuation or safety-relevant commitment is involved, enforce a planner-of-record and/or runtime assurance so that the LLM cannot directly commit unsafe actions (Patterns C/D). If the LLM only drafts text artifacts (documentation, reports) and an approval loop exists, proceed to Step 2.

Step 2—Assess constraint criticality and horizon. If constraints are hard (violations unacceptable) and horizon is long (multi-step plans, trajectories), token-only generation should not be the sole reasoning substrate. Use Pattern C (planner-of-record) and treat the LLM as a front-end that proposes goals/constraints; proceed to Step 3.

Step 3—Evaluate grounding requirements. If correctness depends on up-to-date or certified knowledge, implement retrieval + verification (Pattern B) with citation/traceability requirements, and measure residual hallucination/unsupported-claim rates. If residual risk remains high or the task is inherently state-centric (e.g., predicting physical trajectories), proceed to Step 4.

Step 4—Decide whether a state/world-model component is warranted. A world model is warranted when (i) the task is primarily state/trajectory predictive, (ii) decisions depend on latent physical dynamics not well represented in text artifacts, and (iii) there exists an evaluation plan for state prediction quality and constraint satisfaction (simulation, scenario coverage, OOD tests). In such cases, the world model must still be embedded in Patterns C/D and treated as advisory unless it can be justified in the safety case.

We report below, for the sake of clarity, two worked examples with respect to which we followed the above-mentioned approach.

Example 1—Safety report generation (text-centric workflow). An industrial organization must produce a safety incident report (or risk assessment memo) after an event (e.g., near-miss, quality deviation, maintenance anomaly). The report must be readable, consistent with internal procedures, and auditable.

The requirements to be enforced are the following.

• Traceability: every factual claim (dates, components, measurements, root-cause statements) must be attributable to internal sources (logs, maintenance tickets, SOPs, sensor traces).
• No unsafe recommendations: the system must not propose actions that violate SOPs or safety policies (e.g., bypassing interlocks, disabling alarms).
• Human sign-off: final content is legally/operationally accountable, therefore a qualified engineer must approve it.
• Latency: near-real-time is not needed; minutes are acceptable.

To satisfy these requirements, the recommended architecture consists of Pattern B (RAG + verifiers) + Pattern A (human-gated release).

We can consider an input bundle: namely, the operator provides incident ID, time window, involved assets, and optionally a brief narrative. Through the RAG, the system retrieves relevant evidence from controlled repositories: SOPs, maintenance logs, sensor events, change tickets, previous similar incidents. Then, the generation with citations is performed: the LLM drafts the report sections (timeline, contributing factors, corrective actions) with citations to retrieved sources. Eventually, before presenting the draft, a verification layer runs deterministic checks such as:

• policy checks (“do not recommend disabling X”);
• schema checks (required fields present);
• citation coverage checks (every factual claim must have a supporting source);
• consistency checks (timestamps, asset IDs, units).

The safety engineer plays the role of the human gate by reviewing, editing, and approving or rejecting. If rejected, the system can revise under the same constraints and evidence.

In this case, no world model is required. This is a text-centric task: the core risk is unsupported claims (hallucinations) and lack of traceability, not predicting future system trajectories. The strongest and most common mitigation in prior work for documentation workflows is grounding + verification (Pattern B) plus accountable release (Pattern A). A JEPA/H-JEPA-like world model would not add much unless the report requires predictive simulation (which would then move us toward Pattern C).

Example 2—Constraint-centric control parameterization (state-centric). An operator wants to adjust production behavior (e.g., setpoints, trajectory targets, scheduling priorities) in a cyber-physical system (robot cell, process plant, energy system). The task is not to write text, but to choose actions that affect physical evolution.

The requirements to be enforced are the following.

• Hard safety constraints: strict bounds on speed/force/temperature/pressure; interlocks must never be bypassed.
• Dynamic feasibility: actions must be feasible given system dynamics (actuator limits, stability constraints).
• Long-horizon behavior: local “good-looking” steps can cause later violations (e.g., overheating, collisions, energy peaks).
• Auditability: it must be possible to explain why the chosen actions satisfy constraints.

To satisfy these requirements, the recommended architecture consists of Pattern C (planner/controller-of-record) + Pattern D (runtime assurance envelope). To start with, the operator specifies intent like “reduce cycle time by 5% while keeping peak temperature below threshold” or “increase throughput but do not exceed torque limits.” Thus, the LLM works as interface (not authority): namely, the LLM translates intent into formal goals/constraints (cost terms, bounds, safety rules) and proposes candidate parameterizations (e.g., setpoints, weights, priorities). Then, the planner/controller-of-record (Pattern C) works as a deterministic optimizer or MPC or scheduler, with the aim of computing the actual control actions or schedules. In particular, feasibility and constraint satisfaction are evaluated explicitly (infeasible requests are rejected with a structured explanation). Afterwards, runtime assurance (Pattern D) is performed: a monitor checks invariants online; if predicted violation occurs or uncertainty rises, the system switches/overrides to a certified safe controller or safe mode. For high-risk adjustments, we can also add Pattern A as an additional gate (human approval) before deployment of new parameters.

A state/world model can be considered only as an advisory component when:

• system dynamics is complex or partially observed;
• prediction under uncertainty is a bottleneck for planning;
• there is a credible evaluation plan (scenario coverage, OOD stress tests, uncertainty calibration).

We recall that the public evidence base for JEPA/H-JEPA is currently concentrated in vision/multimodal benchmarks and is not established as an industrial control solution path. Therefore, in a standards-aligned deployment the world model (JEPA or otherwise) must remain subordinate to the planner-of-record and runtime assurance mechanisms (Patterns C/D). It cannot be the sole decision authority unless supported by extensive closed-loop validation and assurance evidence.

3.8. Open Challenges and Research Roadmap

In summary, JEPA and H-JEPA provide a promising conceptual framework for state-predictive modeling. However, their current maturity level corresponds to research and prototype validation rather than industrial deployment readiness. Near-term industrial architectures will likely continue to rely primarily on hybrid systems combining AR language interfaces with verified planners, retrieval mechanisms, and runtime assurance components.

Despite its conceptual appeal, for H-JEPA to progress from a largely theoretical construct to a mature technology for safety-critical deployment, several technical challenges that still remain open should be properly addressed. First, posterior collapse and hierarchical degeneracy are a serious concern: higher-level abstractions can dominate the learning signal so that lower-level modules become under-utilized or effectively ignored, undermining the intended multi-level structure. Second, training coupled energy landscapes across levels is non-trivial: if high-level energies are not designed and tuned carefully, they may wash out fine-grained detail, create pathological optimization landscapes, or lead to brittle behaviour when constraints are propagated downward. Third, credit assignment across abstraction layers and time scales is difficult: gradients must propagate through multiple temporal and hierarchical levels, which can cause vanishing, misaligned updates, or unstable training dynamics. Finally, there is a lack of systematic evaluation methodologies to demonstrate that hierarchical structure actually improves robustness, interpretability, or safety in industrial settings, beyond anecdotal examples. For these reasons, we explicitly frame H-JEPA in this survey as a research roadmap: a promising direction for structuring long-horizon world models and multi-level constraints, but not a guaranteed solution nor a mechanism that can presently be relied upon to satisfy IEC/ISO functional-safety requirements. Any safety-critical adoption of H-JEPA would require substantial additional theoretical work, empirical validation, and standard-oriented assurance evidence.

4. Conclusions

This article argues that current autoregressive (AR) large language models, while transformative for natural language processing, are not by themselves sufficient to meet the stringent requirements of industrial informatics, where systems must respect physical dynamics, hard safety constraints, and long-term objectives. We have introduced the notion of bounded-rational AI, in which language competence and decision authority are explicitly separated, and in which generative models are embedded into architectures that respect engineering and safety principles.

The work offers the following main contributions, which we summarize here to clarify its core value and innovative aspects.

• Conceptualization of bounded-rational AI for industrial informatics. We formalize the idea that AR LLMs should not act as monolithic end-to-end controllers, but instead as front-end components that translate human intent, unstructured requirements, and domain knowledge into machine-interpretable goals and constraints. Decision-making authority is delegated to verifiable back-end modules (planners, controllers, safety filters) that operate under explicit models of dynamics and risk. This bounded-rational AI perspective provides a unifying lens to interpret many emerging “LLM-in-the-loop” designs.
• A structured taxonomy of AR failure modes and mitigation patterns. We systematize four key limitations of AR LLMs that are especially critical in industrial settings: compounding error, myopic objectives, data brittleness and hallucinations, and scaling costs. For each failure mode, we survey and organize the corresponding mitigation strategies—such as CoT/ToT and search-based reasoning, ReAct-style tool use, RAG/Self-RAG, instruction-tuning and preference optimization, and compute-optimal scaling—emphasizing how they can be engineered into robust “reasoning pipelines” rather than used ad hoc. This taxonomy is intended as a practical checklist for system designers.
• Standards-aligned architecture patterns for deploying GenAI in safety-critical domains. Building on IEC 61508, ISO 26262, and ISO 21448, we propose concrete architectural patterns in which generative models are coupled with planners-of-record, runtime-assurance envelopes, and safety filters. We distinguish between roles such as “LLM-in-the-loop, human-on-the-loop,” “LLM as specification front-end,” and “LLM-assisted engineering toolchain,” and we map each to specific interface contracts and assurance arguments. This bridges the gap between high-level GenAI capabilities and the more conservative, lifecycle-oriented view required by functional-safety standards.
• A forward-looking role for JEPA/H-JEPA-style world models in bounded-rational AI. We position JEPA and H-JEPA as promising candidates for state-predictive world models that can complement AR decoders in industrial applications. By operating on latent states and compatibility scores rather than token sequences, these models are better aligned with control, planning, and prediction over long horizons. At the same time, we provide a critical discussion of their current limitations in terms of safety, interpretability, and verification, arguing that in the near term they should be integrated as advisory world-model components inside standards-aligned architectures, rather than as stand-alone decision-makers.

Beyond summarizing the current landscape, the survey also outlines a research agenda for bounded-rational AI in industrial informatics. Key directions include: (i) developing principled interfaces between LLMs, world models, and certified controllers; (ii) designing evaluation protocols that jointly consider language competence, state prediction quality, and safety guarantees; (iii) advancing interpretability methods for latent world models to make them compatible with audit and certification processes; and (iv) exploring compute-optimal, domain-specialized models that can be realistically deployed under industrial constraints on latency, cost, and data governance.

While state-predictive models have yet to be validated at commercial scale and remain primarily active research, their design objectives explicitly target the requirements of systems that must behave predictably under uncertainty. In safety- and mission-critical deployments, JEPA/H-JEPA components must therefore be integrated into the same IEC/ISO safety lifecycle as AR-based modules, subject to hazard analysis, scenario-based testing, runtime monitoring, and, where possible, formal verification, rather than being used as unchecked end-to-end controllers. In particular, we emphasize that JEPA-based bounded-rational AI does not imply verifying raw latent vectors. Instead, JEPA provides a world-model substrate whose predictions are projected into interpretable state variables, upon which existing safety standards and verification techniques can be applied.

It is also important to note that low-energy, “compatible” states in the JEPA world model are not synonymous with safe states: JEPA provides a coherent, predictive substrate, while satisfaction of IEC 61508, ISO 26262 and ISO 21448 safety requirements ultimately relies on explicit constraints, monitors, and planners operating on interpretable safety variables derived from the latent representation.

In conclusion, our message is neither that AR LLMs are inherently unsuitable for industrial use, nor that JEPA-style world models are a fully mature alternative. Rather, we discuss a systems-engineering view in which generative models, whether autoregressive or JEPA-based, are treated as components within a broader, standards-compliant architecture. When this view is adopted, the transformative capabilities of modern GenAI can be harnessed to augment human engineers, enhance monitoring and diagnostics, and support higher-level reasoning, while critical decisions remain anchored in verifiable models, planners, and safety mechanisms.

Beyond technical feasibility, deployment of bounded-rational AI architectures introduces economic and organizational considerations. Hybrid systems involving retrieval pipelines, verification modules, planners, and runtime assurance components require interdisciplinary expertise spanning machine learning, software engineering, domain operations, and safety engineering. Development and validation costs may exceed those of standalone models, particularly when safety certification processes are required under IEC 61508 or ISO 26262 lifecycles. However, these costs are offset by improved reliability, auditability, and risk reduction, which are essential for industrial adoption. Successful deployment therefore depends not only on algorithmic performance but also on organizational integration, lifecycle management, and governance processes aligned with safety and quality standards.