Papers
Topics
Authors
Recent
Search
2000 character limit reached

Reinforcement Learning Foundation Models Should Already Be A Thing

Published 17 Jun 2026 in cs.LG and cs.AI | (2606.18812v2)

Abstract: Foundation models for language and vision are powered by internet-scale data, while structured domains such as tabular prediction are powered by synthetic data. This substitute shifts the challenge from collection to prior design. Such priors already exist for many structured tasks: TabPFN and its successors solve tabular classification with a transformer pretrained on a synthetic Bayesian prior. We make two points. \textbf{First}, reinforcement learning is the conspicuous gap: sampling a synthetic MDP is as feasible as sampling a synthetic tabular dataset, yet no in-context RL work treats prior design as a primary objective. \textbf{Second}, MDPs admit a fixed-size sufficient statistic, independent of the episodes observed and tabular in shape, which makes them directly amenable to the attention-based architectures used for tabular foundation models, with a policy head replacing the supervised target. Together these define the agenda for an RL foundation model. As a proof of concept, we train a Graph Attention Network entirely on synthetic MDPs and show that, with no task-specific tuning, it solves held-out tabular benchmarks in context, both online and offline: online, in far fewer episodes than UCB-VI and tabular Q-learning, and offline, competitively with VI-LCB.

Summary

  • The paper introduces a novel RL foundation model that leverages a tabular sufficient-statistic matrix as a universal MDP prior for efficient policy estimation.
  • It employs a Graph Attention Network with unrolled propagation layers to adaptively trade computation for improved policy inference on tabular benchmarks.
  • Empirical results show the model outperforms conventional RL algorithms in both online and offline settings, underscoring the role of synthetic prior design.

Reinforcement Learning Foundation Models: The Case for Immediate Adoption

Motivation and Context

The foundational model paradigm—pretraining over vast, diverse distributions to enable strong in-context generalization—has transformed language and vision domains. However, reinforcement learning (RL) has not yet fully leveraged the foundation model approach, particularly with respect to explicit synthetic prior design. While modern architectures for structured data, such as TabPFN, have demonstrated that expressive priors over Bayesian classifiers can yield competitive tabular models, the analogous development for RL remains largely absent. This paper addresses this gap by proposing and experimentally validating a straightforward yet potent approach to RL foundation models, emphasizing that prior design for Markov Decision Processes (MDPs) should become a central concern in the field.

Critique of the Current RL Meta-Learning Landscape

Contemporary in-context RL and meta-RL predominantly rely on trajectory data sampled from handpicked or procedurally generated environments. This results in models heavily tailored to narrow task suites, without consideration for an explicit prior over MDPs. The paper argues that this focus misaligns with the principle of foundation models, wherein the distributional prior is the critical enabler of generalization. Notably, prior Bayesian RL research (Strens 2000, Dearden et al. 1998) did emphasize structured priors over transitions and rewards, but this thread has not been systematically incorporated in recent deep meta-RL, Decision Transformers, or sequence-modeling strategies.

A strong criticism is also levied against sequence-based models, which encounter practical limitations: vanishing/exploding gradients in RNNs and substantial memory and compute scaling in transformer-based models, where attention complexity is quadratic in context length. The result is that key exploratory experience may be lost during truncation or compressed ineffectively. The authors note that while latent compression has shown promise in the tabular supervised domain, scaling trajectory-based methods to challenging RL setups remains unresolved.

Tabularization of MDP Sufficient Statistics

The paper's central insight is the identification of the fixed-size, tabular sufficient-statistic matrix ZZ for small finite MDPs. Each row corresponds to a state-action pair and encodes (1) empirical visit counts, (2) empirical mean rewards, and (3) empirical state transition probabilities. Notably, this matrix is invariant to the number of episodes observed and episode length, and for small MDPs, ZZ can serve as a universal, information-complete representation.

This reframing allows the use of attention-based, permutation-equivariant set architectures (such as those developed for tabular data) to process RL data, replacing the supervised head with a policy output. The authors choose a Graph Attention Network (GAT) that explicitly utilizes the empirical dynamics as attention biases, enabling rapid, structure-aware planning for small MDPs.

Model Architecture and Training Protocol

The model takes, for each state-action pair, log-visit count, normalized empirical reward, and empirical transition probabilities. This is processed by a GAT with KK weight-tied propagation layers, each implementing a form of message-passing akin to value iteration. Importantly, these layers can be unrolled to greater depths at test time, trading computation for improved policy estimation, without retraining.

The model is trained offline. For each batch, multiple MDPs are sampled from a broad synthetic prior: number of states, actions, transition sparsity, latent geometry, stochasticity, and reward sparsity are all randomized. For each MDP, the optimal policy is computed; then, noisy empirical statistics are produced via simulated exploration, and the model is supervised to predict the Boltzmann-optimal policy using these statistics. The training objective is per-state cross-entropy between the predicted and optimal policy.

Empirical Results

Key empirical findings:

  • On GridWorld and FrozenLake benchmarks, without any environment-specific tuning or data, the in-context RL foundation model rapidly achieves strong performance.
  • In online RL, the model converges to the optimal policy in substantially fewer episodes than both tabular Q-learning and UCB-VI, a model-based algorithm with upper confidence bounds.
  • In offline RL, when evaluated from fixed datasets collected with uniform random policies, the model is competitive with pessimistic value iteration (VI-LCB), achieving optimal or near-optimal policies with minimal data on deterministic benchmarks. On coverage-limited stochastic environments, the model’s reliance on the prior provides robustness where VI-LCB is brittle to data sparsity.

Limitations and Future Directions

The current prototype is limited to small tabular MDPs with discrete state and action spaces. While permutation equivariance confers invariance to arbitrary relabeling, it also removes any notion of state geometry, meaning the model cannot generalize across similar but unvisited states unless further state features are provided. This suggests that extensions integrating informative features or latent geometries into the prior and the input are a natural next step.

The tabular representation itself is not directly scalable to large or continuous state-action spaces. The authors propose future directions employing feature-indexed rows and continuous action heads (e.g., parameterizing policies with squashed Gaussians for continuous control tasks), but note that scale generalization will require more sophisticated priors and representations. Furthermore, extending beyond Markov environments is non-trivial, as partial observability invalidates the sufficiency of ZZ.

Amortizing computation is another open problem. While updating ZZ is efficient, current evaluation necessitates full recomputation for each step—incremental updates would further enhance online applicability.

Theoretical and Practical Implications

This work argues strongly that RL foundation models should be built now, not post hoc as a consequence of advances in separate research threads. The central claim is that foundation models in RL can and should be trained using synthetic but well-designed priors over MDPs, analogously to the supervised tabular domain, because the sufficiency and invariance of the MDP statistic ZZ endows them with broad generalization at moderate cost. This perspective fundamentally reframes the agenda for RL foundation models: the synthetic prior, not just architecture or data curation, is the primary axis for future progress.

If this approach is extended to large/continuous domains and robust feature priors are developed, it would enable RL agents to exhibit foundation-model-like properties—rapid adaptation across tasks, robustness to data sparsity, and efficient policy inference—long sought after in meta-RL and continual learning.

Conclusion

This paper provides a precise analysis and compelling prototype for RL foundation models based on synthetic MDP priors and permutation-equivariant attention architectures. It demonstrates state-of-the-art data efficiency on canonical tabular RL benchmarks, outperforming traditional algorithms with zero tuning. Theoretical considerations and empirical results underline the necessity of principled prior design in in-context RL, setting a clear agenda for future research: the systematic development and evaluation of synthetic-prior-fitted RL foundation models.

Paper to Video (Beta)

No one has generated a video about this paper yet.

Whiteboard

No one has generated a whiteboard explanation for this paper yet.

Explain it Like I'm 14

What is this paper about?

This paper argues that reinforcement learning (RL) should have its own “foundation models” already—big, general-purpose models that are pre-trained once and then quickly adapt to many new tasks. Language and vision have these models because they can train on tons of internet data. For RL, real data is harder to get, but the authors say we can generate lots of realistic practice problems (synthetic environments) and pretrain on those. They also show a simple proof-of-concept model that learns from such synthetic environments and works well on new, unseen tasks without extra tuning.

What questions are the authors trying to answer?

  • Can we build an RL foundation model by training on lots of randomly generated practice environments?
  • Is there a compact way to represent what an agent has learned so far so the model does not need to remember long, messy histories?
  • Will such a model perform well on new small RL tasks, both when learning by interacting (online) and when learning from a fixed dataset (offline)?

How did they do it? (Methods explained simply)

Think of an RL task like a maze game:

  • Places in the maze are “states.”
  • Moves you can make are “actions.”
  • The maze rules (what happens after each move) are “transitions.”
  • Points you get are “rewards.”

Most current RL-in-context methods feed the model a long “video” (a sequence of moves and outcomes) and ask it to figure out what to do next. That gets expensive because:

  • Long sequences are hard for some neural nets to remember well.
  • Transformers get slower and costlier as the history grows.

The authors suggest using a short “cheat-sheet” instead of a long video. For each state-action pair, keep only three simple summaries (called “sufficient statistics”):

  1. How many times we tried it (a visit count),
  2. The average reward we saw,
  3. Where it tended to lead (the estimated probabilities of the next states).

Stack these per state-action rows into a fixed-size table Z. This table:

  • Is small and simple (tabular),
  • Doesn’t grow with the number of episodes you’ve played,
  • Still captures the important information.

They then built a graph-based neural network (a Graph Attention Network, or GAT) that:

  • Reads this table,
  • Uses the estimated transition structure (who leads to whom) to “pass messages” along the graph of states—like planning a few steps ahead,
  • Outputs a policy: for each state, a smart probability distribution over actions.

Training setup:

  • They generate many random small environments (synthetic MDPs) with different sizes, shapes (grids, chains, random graphs), randomness levels, and reward patterns. This is their “prior,” meaning their built-in expectation for what future tasks might look like.
  • For each environment, they compute the best possible behavior (the optimal policy) using a classic algorithm (value iteration).
  • They simulate limited exploration to build the cheat-sheet table Z (so the model sees only what a real agent would have seen).
  • They train the GAT to predict the optimal policy from Z alone.

Two modes of use:

  • Online: The model plans, acts for an episode, updates the cheat-sheet, and replans—repeating this to improve.
  • Offline: The model gets a fixed dataset from some behavior (like random actions) and must recover a good policy from the cheat-sheet built out of that dataset.

A neat detail: the model’s “planning depth” (how many rounds it propagates information across the graph) can be changed at test time to trade speed for more careful planning, without retraining.

What did they find, and why does it matter?

Main results on small benchmark games (GridWorld and FrozenLake):

  • Online: The pre-trained model solved new tasks in far fewer episodes than standard RL algorithms like Q-learning and even UCB-VI (a strong model-based method). That means it learns faster from less experience.
  • Offline: Given only random-play data, it was competitive with a well-known offline RL method (VI-LCB). On easy, deterministic mazes, just a handful of episodes were enough. On the trickier, slippery FrozenLake, both methods needed more data, but the model still did well.

Why this matters:

  • It shows that a single model, pre-trained entirely on synthetic environments and not tuned for any one specific task, can quickly adapt to new RL problems.
  • It suggests a promising recipe for an RL foundation model: stop focusing on long histories and instead learn from the compact cheat-sheet (counts, average rewards, transition estimates) that truly summarizes what matters.
  • It shifts the field’s attention to designing good priors (good ways to generate practice environments), just like tabular foundation models did for traditional data tables.

What are the limitations and what’s next?

The authors are honest about what their proof-of-concept can and cannot do yet. Key limitations and future steps include:

  • Scale and features: Right now, it’s for small “tabular” problems with a finite set of states and actions. Adding meaningful state features (like coordinates or images) could help it generalize to bigger or continuous spaces.
  • Continuous actions: The current policy head is for a small set of discrete actions. For continuous control (like steering angles), the policy output needs to change.
  • Size generalization: Moving from small to much larger environments is hard; the model may need explicit training on a range of sizes or size-invariant representations.
  • Efficiency: They currently re-run planning once per episode. Smarter, incremental updates could make it faster in fully online use.
  • Partial observability: If the agent can’t fully see the true state, the cheat-sheet no longer captures everything, and sequence modeling may be needed again.
  • Prior quality: If the synthetic environments don’t match the real problems, the model can be misled. Designing better priors is crucial.

Bottom line

This paper makes a clear case: RL should have foundation models, and we already have the pieces to build them. By training on lots of synthetic, small environments and learning from a compact “cheat-sheet” of what’s been tried and observed, a single model can quickly adapt to new tasks, both online and offline. The early results are strong, and while scaling up and handling more complex settings will take more work, the path forward—focusing on good priors and compact representations—looks promising.

Knowledge Gaps

Knowledge gaps, limitations, and open questions

Below is a single, focused list of what remains missing, uncertain, or unexplored in the paper; each item is phrased to be concrete and actionable for future work.

  • Prior design for RL foundation models: how to specify, select, and validate a distribution over MDPs that matches real deployment regimes; lack of ablations on how prior choices (geometry types, connectivity sparsity, reward sparsity/signs, Dirichlet concentration) affect generalization and robustness.
  • Robustness to prior misspecification: no characterization of when the synthetic prior helps vs misleads, or diagnostics to detect and correct mismatch during deployment.
  • Training data generation mismatch: the training Z uses Poisson-sampled per-pair visit counts that sidestep real exploration dynamics; it is unknown how training on such artificially covered statistics translates to performance under realistic, path-dependent coverage.
  • Exploration-aware objectives: the model is trained to regress to the optimal policy offline; there is no exploration-aware training signal or analysis of how to induce good exploration strategies in online settings.
  • Scalability of the tabular sufficient statistic: the O(S2A)O(|S|^2|A|) storage and processing of Z (transition rows per (s,a)) is infeasible for large/continuous state spaces; concrete schemes for discretization, clustering, or alternative sufficient statistics are not developed or evaluated.
  • Continuous actions and large action spaces: only a masked softmax over discrete actions is supported; no implemented head or training protocol for continuous-control policies (e.g., squashed Gaussians), and no evaluation on tasks with larger or variable action sets beyond Amax=4.
  • Incorporating state (and action) features: the current design is permutation-equivariant and featureless, losing geometry and similarity structure; it remains open how to generate/ingest informative features, how to align feature distances with value/dynamics, and how this affects generalization to unseen states.
  • Size generalization: no solution is provided to transfer from training on small graphs (tens of states) to much larger MDPs (hundreds/thousands of states) with different degree distributions and spectral properties; need for scale-invariant or scale-aware representations and priors.
  • Planning depth sensitivity: performance degrades when the test-time propagation depth K deviates from the training value; how to train for K-robustness (e.g., curriculum or randomization over K), or adaptively choose depth based on task/horizon, is unaddressed.
  • Incremental replanning: the current evaluation re-encodes all of Z once per episode; it is unknown how to perform correct and efficient per-step incremental updates to amortize online computation without losing performance.
  • Partial observability (POMDPs): the approach hinges on the Markov property and sufficiency of Z; extensions to partial observability, latent-state inference, and the associated return to sequence modeling are unaddressed.
  • Coverage limitations in offline RL: the offline comparison uses uniform-random behavior; the method’s behavior with more realistic, biased behavior policies and heterogeneous datasets (e.g., narrow support, covariate shift) is unexplored.
  • Sensitivity to stochasticity and sparsity: only three tiny benchmarks are used; there is no systematic study across degrees of transition stochasticity, reward sparsity, and reward-scale variability to map failure modes and stability.
  • Reward-scale handling: the method normalizes by per-MDP max reward and uses a running maximum at eval; robustness to unknown or shifting reward scales, and alternatives (e.g., scale-invariant losses, adaptive normalization), are not evaluated.
  • Choice and strength of attention bias β: the planning layer adds β log P(·|s,a) as an attention bias; there is no ablation or principled tuning method for β, nor analysis of how unreliable empirical P (from few counts) affects message passing and policy quality.
  • Theoretical guarantees: no regret, sample-complexity, or Bayes-risk guarantees are provided for the proposed architecture and training pipeline under the stated prior; conditions under which the posterior-mean policy estimate is near-optimal are not analyzed.
  • Relation to algorithmic RL: while prior work shows transformers can implement near-optimal algorithms in context, there is no demonstration that the proposed GAT layer stack implements or approximates specific planners (e.g., value iteration) across the prior.
  • Baseline breadth and fairness: comparisons omit modern in-context RL/algorithm distillation baselines and other model-based planners; limited seeds and small tasks preclude strong conclusions about generality.
  • Pretraining compute and scaling: pretraining requires solving each synthetic MDP with value iteration; the computational and memory costs, and strategies to scale pretraining to larger MDPs or priors with richer structure, are not assessed.
  • Joint policy–value outputs: the architecture predicts only a policy; whether auxiliary value heads (state/action values) improve exploration, stability, or offline performance is untested.
  • Handling absorbing states and termination generically: while the offline baseline encodes termination explicitly, the model’s handling of absorbing states via Z is not analyzed; impact on planning and generalization across environments with different termination mechanics is unclear.
  • Prior selection for domains: no methodology is provided for mapping a target application (e.g., robotics, operations) to a concrete MDP prior (geometry, sparsity, stochasticity) that preserves performance and safety constraints.
  • Data and model scaling laws: there is no study of how performance scales with prior diversity, model size, training compute, or dataset coverage, which would guide the design of RL foundation models.

Practical Applications

Summary

The paper argues that reinforcement learning (RL) should adopt a foundation-model paradigm powered by synthetic priors over Markov Decision Processes (MDPs), analogous to TabPFN for tabular prediction. It introduces a proof-of-concept: a Graph Attention Network (GAT) trained entirely on synthetic tabular MDPs and fed a fixed-size sufficient statistic Z (visit counts, empirical rewards, empirical transition rows). Without task-specific tuning, the model recovers near-optimal policies in held-out small MDPs and outperforms baseline online and offline RL methods in sample efficiency. The approach eliminates trajectory-length dependence by compressing experience into tabular statistics and uses a weight-tied message-passing planner with adjustable planning depth.

Below are practical applications derived from these findings, organized by deployment horizon.

Immediate Applications

These can be deployed now in small, discrete, Markovian environments or as workflows/libraries for RL researchers and engineers.

  • Few-shot policy planning for small, discrete control systems
    • Sectors: robotics (warehouse grid robots; AGVs with discrete lanes), operations (elevator control, conveyor routing), telecom (discrete switch/routing policies), manufacturing (cell sequencing modes), games (grid/puzzle agents)
    • What to deploy: A lightweight “RL-PFN” planner that ingests (s, a, s’, r) counts and outputs a policy via the pretrained GAT; no per-environment retraining; adjustable planning depth K to trade off compute vs. lookahead
    • Tools/products/workflows:
    • Embedded planner SDK that runs on-device for discrete mode controllers
    • Gym/OpenRL wrapper that exposes Z-building (counts + empirical transition rows) and a policy() API
    • Assumptions/Dependencies:
    • Small, discrete MDPs with sufficient coverage; Markov property holds in the observed state
    • Prior must roughly match deployment regimes (sparsity, connectivity, reward scales)
    • Accurate count/transition estimation; limited or no partial observability
  • Offline policy recovery from sparse logs
    • Sectors: software (feature rollout policies), operations (call-center routing states/actions), games (NPC behavior from telemetry), logistics (simple routing grids)
    • What to deploy: A “policy-from-logs” tool that converts historical discrete interaction logs into Z and recovers a policy (competitive with VI-LCB) without training
    • Tools/products/workflows:
    • ETL pipeline that aggregates logs into Z (counts, mean rewards, transition matrices)
    • Batch scoring service to evaluate and update policies with governance checkpoints
    • Assumptions/Dependencies:
    • Coverage limitations: if goals/rare transitions are under-sampled, performance leans on the prior
    • Consistency between logged behavior and the current environment dynamics
  • RL prototyping and teaching with synthetic MDP priors
    • Sectors: academia, education (ML courses, RL bootcamps), R&D labs
    • What to deploy: A reproducible synthetic MDP generator + pretrained planner to teach exploration, planning, and prior design; removes long training runs and large trajectory buffers
    • Tools/products/workflows:
    • Course labs that swap baselines (UCB-VI, Q-learning) with the pretrained planner for head-to-head comparisons
    • Benchmark suites for small MDPs with tunable connectivity/reward sparsity
    • Assumptions/Dependencies:
    • Lab tasks should be tabular or discretized; synthetic prior parameters set to expose intended phenomena
  • Memory and storage reduction for RL logs in discrete tasks
    • Sectors: software, robotics, simulation platforms
    • What to deploy: Replace trajectory storage with sufficient-statistic Z snapshots for planning and auditability
    • Tools/products/workflows:
    • “Z-compressor” library that maintains counts and empirical transitions online; point-in-time checkpointing for audits/compliance
    • Assumptions/Dependencies:
    • Markovian tasks where Z is sufficient; compatibility with existing logging schemas
  • Rapid benchmarking of exploration strategies
    • Sectors: academia, ML tooling vendors, RL teams
    • What to deploy: Use the synthetic MDP prior as a configurable testbed for exploration algorithms (UCB-VI variants, Thompson sampling, heuristic exploration) with standardized Z-based evaluation
    • Tools/products/workflows:
    • Cloud service that spins up batches of MDPs with known optima; evaluates sample efficiency and prior sensitivity
    • Assumptions/Dependencies:
    • Benchmarks reflect deployment-relevant MDP connectivity and reward sparsity
  • On-device discrete agents for smart-home and small IoT controls
    • Sectors: consumer electronics (thermostats: modes like heat/cool/off; lighting scenes), building automation (HVAC states), appliances (program modes)
    • What to deploy: Pretrained GAT model cached on-device; Z updated per episode/interaction; periodic re-planning with small compute footprint
    • Tools/products/workflows:
    • Firmware module for discrete control policies; configurable K for devices with different compute budgets
    • Assumptions/Dependencies:
    • States/actions are small and enumerable; user/environment drift slow enough for periodic re-planning

Long-Term Applications

These require further research to handle continuous/large state spaces, partial observability, scale generalization, or safety/regulatory needs.

  • General-purpose RL foundation models (RLFMs) across diverse environments
    • Sectors: cross-industry (software automation, robotics, operations, logistics)
    • Concept: Scale the synthetic-prior approach with feature-indexed states, continuous-action heads (e.g., squashed Gaussian), and size-invariant representations to deliver “zero-shot” or “few-shot” RL across tasks
    • Tools/products/workflows:
    • “RL Foundation Model Hub” with modular priors (geometries, reward structures) and plug-in policy heads; APIs to ingest (s, a, s’, r, x_s) feature logs
    • Assumptions/Dependencies:
    • Robust prior design covering real-world dynamics; effective state feature engineering/learning; scalable message passing and compression
  • Robotics control with continuous states/actions and mode hierarchies
    • Sectors: robotics (mobile manipulation, warehouse fleets, drones)
    • Concept: Combine feature-based state embeddings with continuous-action policies; use the planner as a high-level discrete mode selector layered over continuous controllers
    • Tools/products/workflows:
    • Hybrid planner stack: discrete RL-PFN for task/mode sequencing, continuous SAC-like head for fine control
    • Assumptions/Dependencies:
    • High-fidelity features capturing geometry/kinematics; partial observability handling (filters/learned latent states); safety constraints
  • Healthcare decision support in protocolized settings
    • Sectors: healthcare (clinical pathways, triage, chronic disease management with discrete stages)
    • Concept: Use discrete-stage MDP abstractions to recommend actions with few patient interactions, bootstrapped from priors; offline-to-online update pipelines using EHR-derived sufficient statistics
    • Tools/products/workflows:
    • Clinician-in-the-loop planner; audit trails via Z snapshots; simulators for regulatory sandboxing
    • Assumptions/Dependencies:
    • Strong safety, interpretability, and validation; regulatory approvals; careful prior alignment to clinical evidence; handling partial observability and confounding
  • Energy and grid operations with discrete dispatch states
    • Sectors: energy (microgrid switching, DR event policies, storage mode scheduling)
    • Concept: Rapid policy adaptation from sparse operational logs; multi-timescale planning through depth-tunable message passing
    • Tools/products/workflows:
    • Control room decision aid integrating telemetry-to-Z pipelines and policy proposals with operator oversight
    • Assumptions/Dependencies:
    • Accurate state abstraction (Markovian approximations); reliability and fail-safe overrides; robustness to nonstationarity
  • Network and cloud resource management
    • Sectors: software/infra (autoscaling policies, cache replacement, traffic steering)
    • Concept: Use scalable priors and feature-indexed Z to generalize policies across services/data centers; amortized incremental updates to reduce online recompute
    • Tools/products/workflows:
    • Control plane plugin that ingests coarse-grained metrics, updates Z incrementally, and outputs policy changes under SLO constraints
    • Assumptions/Dependencies:
    • Effective discretization or learned abstractions; drift detection and rollback; POMDP extensions for partial observability
  • Finance and operations research under discrete action sets
    • Sectors: finance (credit line adjustments, discrete hedging), supply chain (inventory reorder bands, routing choices)
    • Concept: Offline policy recovery from historical logs with systematic priors; conservative deployment with uncertainty estimates from posterior-mean policies
    • Tools/products/workflows:
    • Risk-aware planner with bounds; scenario simulators seeded from synthetic priors; governance dashboards using Z-based evidence
    • Assumptions/Dependencies:
    • Handling confounding and feedback loops; regulatory compliance; robust priors for rare events
  • Agentic systems with modular planners inside LLM-based agents
    • Sectors: software, enterprise automation, assistants
    • Concept: Integrate an RL-PFN module as a memory-efficient planner within agent frameworks, using Z to compress long interaction histories; LLM handles language/tool use, RL module handles decision sequences
    • Tools/products/workflows:
    • Agent middleware that routes structured decision subproblems to the RL planner and keeps a compact Z memory store
    • Assumptions/Dependencies:
    • Reliable problem decomposition; state abstraction bridging natural language and MDP states; resource coordination between modules
  • Safety-first RL via prior design and uncertainty
    • Sectors: cross-industry safety-critical RL
    • Concept: Use Bayesian prior-fitting to calibrate conservative exploration/pessimism; develop auditable prior libraries and “safety knobs” (e.g., sharpen/flatten attention bias, penalty coefficients)
    • Tools/products/workflows:
    • Prior catalogs with documented coverage assumptions; test suites for prior misspecification robustness; explainability via Z
    • Assumptions/Dependencies:
    • Formal guarantees for partial observability and distribution shift; certification processes and standards

Cross-cutting dependencies and assumptions

  • Markov property and state abstraction: Current method assumes fully observed Markovian states; POMDPs need latent-state recovery or filters.
  • Scale and generalization: Transition from |S|≈O(10–50) to |S|≫100 requires size-aware priors, invariant representations, and efficient compression.
  • Continuous actions and high-dimensional states: Requires new policy heads and feature pipelines.
  • Prior coverage and misspecification: Benefits hinge on priors resembling deployment regimes; need diagnostics and adaptation strategies.
  • Data coverage: With poor exploration, performance leans on the prior; offline uses must assess coverage before deployment.
  • Compute and integration: Pretraining over synthetic MDPs and exact value-iteration targets are training-time costs; incremental online updates would further reduce deployment compute.

Glossary

  • AdamW: An optimizer that decouples weight decay from the gradient update step to improve generalization. "We optimize with AdamW under a linear warmup followed by cosine decay with gradient-norm clipping."
  • attention regularizer: A mechanism that biases attention weights toward known transition dynamics to stabilize planning. "its strength β acts as an attention regularizer that controls how tightly the attention is pinned to the empirical dynamics"
  • autoregressive rollout: An evaluation or data-generation procedure where each step conditions on previously generated data or model outputs. "Both evaluations share the same autoregressive rollout."
  • Bayes-optimal: Optimal with respect to an uncertainty model, maximizing expected performance under the posterior. "Both yield the Bayes-optimal E[T(.) | Z]."
  • Bayesian RL: A reinforcement learning framework that places priors over environments and updates beliefs via Bayes’ rule. "at the cen- ter of Bayesian RL, proposing Gaussian reward priors and Dirichlet transition priors as tractable choices."
  • Bellman expectation: The expected backup over next states under a transition model in dynamic programming. "so the message collapses to the Bellman expectation msa = Es !~ }(.|s.a) [ Vs' ],"
  • Boltzmann-optimal policy: A softmax policy over Q-values with temperature T that approaches the greedy policy as T→0. "Concretely the target is its Boltzmann-optimal policy TM1,7 = softmax(QM/T),"
  • Dirichlet: A probability distribution over categorical/simplex vectors, often used as a prior for transition probabilities. "Transition rows are Dirichlet over a size-O support drawn from N(s, a),"
  • discount factor (γ): A scalar in [0,1) that exponentially downweights future rewards. "the discount is fixed at y = 0.95."
  • end-to-end compression: Learning a compression module jointly with the model to reduce memory and compute while preserving performance. "Recent work on end-to-end compression for tabular foundation models (Zabërgja et al., 2026) shows that latent compression can reduce memory and inference costs by or- ders of magnitude,"
  • exploration temperature: The temperature parameter used in softmax action sampling to control exploration. "Exploration samples actions from softmax(ue/T) with temperature T;"
  • Graph Attention Network (GAT): A graph neural network that uses attention to weight messages from neighboring nodes. "A Graph Attention Network (GAT, Veličković et al. (2018)) takes [log(1 + N), î] as features"
  • Hoeffding bonus: An optimism bonus derived from Hoeffding’s inequality to encourage exploration under uncertainty. "UCB-VI plans on its empirical model plus a Hoeffding bonus with c = 1,"
  • in-context reinforcement learning: Performing RL-like adaptation by conditioning on context data within a single forward pass instead of updating parameters. "There is already solid theoretical support for the idea that in-context reinforcement learning is a viable and powerful method,"
  • KL divergence: A measure of discrepancy between two probability distributions. "The KL between ## and Te is logged as a diagnostic only."
  • latent geometry: A hidden coordinate space used to define structured connectivity or proximity among states. "Each MDP draws a latent geometry g € {chain, grid, mesh, random};"
  • LinUCB: A contextual bandit algorithm that applies upper confidence bounds in a linear feature space. "near-optimal online RL algorithms (UCB-VI, Thomp- son sampling, LinUCB)"
  • lower-confidence bound (LCB): A conservative estimate that subtracts a confidence term to guard against overestimation. "which performs pessimistic value iteration using lower-confidence-bound estimates."
  • Markov kernel: The conditional probability distribution over next states given the current state and action. "the Markov kernel P(. | s, a) gives weighted adjacency."
  • Markov property: The assumption that the next state depends only on the current state and action, not on the past. "For small finite MDPs, the Markov property completely eliminates the need for trajectory-length context."
  • message passing: A GNN operation where node/edge embeddings are updated by aggregating information from neighbors. "Each round of message passing propagates information about state-action pairs backward through the graph:"
  • permutation equivariance: A property where permuting input elements induces the same permutation on outputs. "Permutation equivariance over rows gives automatic invariance under relabelings of states and actions."
  • pessimistic value iteration: Value iteration that incorporates conservative penalties to avoid overestimating values from limited data. "the VI-LCB offline RL algorithm (Rashidinejad et al., 2021), which performs pessimistic value iteration using lower-confidence-bound estimates."
  • policy head: The output module that maps representations to action probabilities. "and exposes a policy head that outputs, for a given state s, an estimate Tmodel(s) of the probability vector TT*(s)."
  • posterior mean policy: The expectation of the policy under the posterior distribution, minimizing expected cross-entropy. "the population minimizer of (3) is the posterior mean policy Te (. | s; Z) = ET | Z],"
  • prior-fitted network (PFN): A model trained on tasks sampled from a hand-crafted prior to perform fast Bayesian inference in-context. "Prior-fitted network (PFN) train- ing (Müller et al., 2022) has since been argued to be the dominant paradigm for Bayesian inference"
  • self-absorbing state: An absorbing state that, once entered, transitions only to itself. "Both holes and the goal are self- absorbing states,"
  • set transformer: A transformer architecture designed for sets, respecting permutation invariance/equivariance. "This is the format consumed by a permutation- equivariant set-transformer of the TabPFN family."
  • soft actor-critic: A maximum-entropy RL algorithm using stochastic policies and entropy regularization. "which is the standard continuous-action policy parameterization popularized by soft actor-critic (Haarnoja et al., 2018)."
  • spectral gap: The difference between leading eigenvalues of a graph/Laplacian that influences mixing and convergence properties. "graphs with different degree distributions, diameters and spectral gaps,"
  • squashed Gaussian: A Gaussian distribution passed through a bounded nonlinearity (e.g., tanh) to produce bounded actions. "the head can instead emit the parameters of a squashed Gaussian, a Gaussian passed through a tanh to respect bounded action ranges,"
  • sufficient statistic: A summary of data that preserves all information needed for inference about a parameter/environment. "Z is a sufficient statistic only when the environment is Markov in the observed state."
  • Thompson sampling: A Bayesian exploration strategy that samples a hypothesis from the posterior and acts optimally under it. "near-optimal online RL algorithms (UCB-VI, Thomp- son sampling, LinUCB)"
  • UCB-VI: Upper Confidence Bound Value Iteration, a model-based RL algorithm using optimism under uncertainty. "UCB-VI plans on its empirical model plus a Hoeffding bonus with c = 1,"
  • value iteration (VI): A dynamic programming method to compute optimal values/policies by iteratively applying the Bellman optimality operator. "we run value iteration on the true dynamics (500 sweeps) to obtain the optimal action value Q* (s, a),"
  • weight-tied: Reusing the same parameters across multiple unrolled layers/iterations in a network. "These layers are weight-tied, so K is not baked into the parameters:"

Open Problems

We haven't generated a list of open problems mentioned in this paper yet.

Collections

Sign up for free to add this paper to one or more collections.

Tweets

Sign up for free to view the 1 tweet with 38 likes about this paper.