Pith. sign in

REVIEW 4 major objections 4 minor 25 references

World-model persistence failures are, for a tested class, serving-layer state discard rather than missing model capability.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

T0 review · deepseek-v4-flash

2026-08-01 07:40 UTC pith:WMZEBUBP

load-bearing objection A solid serving-layer runtime with a real eviction result, wrapped in an attribution claim the experiments do not support. the 4 major comments →

arxiv 2607.21686 v1 pith:WMZEBUBP submitted 2026-07-23 cs.AI

Persistent Computational State: A Session-Centric Runtime for Generative World Models

Zhen Lin This is my paper
classification cs.AI
keywords Persistent Computational Stateworld modelssession-centric servingstate persistenceruntime state discardgenerative video modelsmemory evictionreturn consistency
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper disputes the attribution that recent benchmarks make when video world models fail to return a scene to its prior configuration after a camera excursion: that the model lacks memory and needs a new training objective. It argues that for an important class of models the failure is produced by the serving layer, which reclaims runtime state at request boundaries on the assumption that state is recomputable—an assumption that is false for world models carrying a non-recomputable random-number stream or memory bank. The central demonstration is a restore: saving only the observation and generator RNG state the runtime already holds, driving the model through a genuine excursion, and restoring yields a continuation byte-identical to one that never left, while corrupting only the RNG degrades it. The paper defines Persistent Computational State as the minimal non-recomputable state that must survive across requests, shows it can be discovered by a measurement procedure rather than hand-engineered, and builds a session-centric runtime where checkpoint/restore costs about 0.012 ms against a 1.85-second generation step and memory eviction must be keyed to the return, not to recency.

Core claim

On the paper's own terms, the discovery is that the benchmark-measured persistence failure of generative world models is, for the model classes tested, a serving-layer state-discard problem rather than a model capability gap. The argument is constructive: a Markovian observation-conditioned diffusion model, a non-Markovian model with an explicit memory bank, and an autoregressive model with a windowed addressable key-value context are each driven through a leave–return excursion, and restoring the runtime-held state—an observation plus RNG state, a memory bank plus pose and RNG, or a windowed KV context—reproduces the never-left continuation byte-identically on all three, including across a

What carries the argument

Persistent Computational State (PCS) is the central object: the minimal non-recomputable subset of runtime state whose restoration makes the continuation indistinguishable from never having left, defined formally as the smallest S with D(continue(restore(S)), oracle) ≤ ε. It carries the argument by partitioning full runtime state into PCS plus derivable state, where derivable means recomputable by re-running—the crucial fact being that sampling RNG streams, memory banks, and recurrent activations are not derivable, so request-centric 'recompute caching' is not inefficient but incorrect. A fingerprinting procedure discovers PCS per model by ablating each addressable buffer over a leave-and-re

Load-bearing premise

The claim collapses if the benchmark-measured failures occur under a serving setup that already keeps the session alive across departure and return—so nothing was discarded—because then the demonstrated restore is an external-memory splice rather than the recovery of state the runtime threw away.

What would settle it

Instrument the original benchmark harnesses or their serving topology to record whether a departure–return trajectory is one continuous rollout or spans request boundaries that reclaim generator state; also run the paper's snapshot protocol on a hidden-target scenario where a target leaves the view and must return consistent with unobserved evolution. If a single-session rollout already fails, or if saving observation+RNG does not restore the hidden target, the persistence failure is not entirely server discard.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • For Markovian observation-conditioned world models, a runtime that saves the last observation and the generator's RNG state at request boundaries reproduces a departed-and-returned scene byte-identically, with no retraining or new memory module.
  • Checkpoint and restore cost roughly 0.012 ms against a 1.85 s generation step, so persistent state management is about 0.00035% of wall time—effectively free.
  • Externalizing PCS to host memory keeps device memory constant in the number of resident sessions (measured to 1,024), versus a device-bound runtime that would run out of memory near 108 sessions on the same hardware.
  • When host memory binds, eviction must be relevance-keyed to the return—the anchor-side frames—not recency; in the paper's measurements relevance holds 16 of 16 worlds where recency holds 6, and in a planner trace recency orphans the search tree while relevance loses none.
  • A session outlives the process that created it: restoring PCS from disk in a fresh interpreter yields byte-identical continuation across a process boundary on all three model classes.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • Extension: if the serving-layer diagnosis holds, benchmark prescriptions for new memory modules and training objectives should be re-scoped; for models that expose a snapshot port, the default recommendation should be a session-centric serving contract, and evaluation harnesses should report whether trajectory requests share a session.
  • Extension: the derivability partition suggests a general serving principle for stochastic generators—anything a runtime can recompute is cache, anything it cannot is state, and the two need different eviction and durability policies; this may transfer to other stochastic serviced models beyond video.
  • Extension: the paper deliberately excludes hidden events, so a natural decomposition is that PCS fixes recovery of the observed world while a separate hidden-state estimator fixes continued unobserved evolution; combining them predicts that benchmark hidden-target scores improve only when the second component is present.
  • Extension: the relevance-over-recency eviction result can be tested as a caching policy in embodied planning systems where returning to a goal or home configuration is the anchor; the prediction is that recency-based caches systematically discard the states a backtracking planner needs, independent of retention budget.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit.

Referee Report

4 major / 4 minor

Summary. The paper argues that the persistence failures of video world models measured in MBench and WRBench are, for an important class of models, caused by request-centric serving discarding recoverable runtime state rather than by a model capability gap. It defines Persistent Computational State (PCS) as the minimal non-recomputable state that must survive request boundaries, gives a fingerprinting procedure to discover PCS by measurement, builds a session-centric runtime over it, and reports experiments on three architecturally different models (Cosmos3, WorldMem, Matrix-Game 2.0). The core experimental results are that checkpoint/restore of PCS yields byte-identical or latent-exact continuation versus a never-left oracle, corrupting only the RNG degrades the continuation, durability holds across a process boundary, checkpoint/restore costs ∼0.012 ms versus a 1.85 s generation step, device memory stays constant to 1,024 resident sessions, and relevance-keyed eviction beats recency-keyed eviction under memory pressure.

Significance. If the central claims hold, this is a valuable systems contribution. It identifies a concrete serving-layer failure mode for generative world models, gives a measurable operational definition of world state, and shows that one model-agnostic fingerprinting procedure recovers architecture-specific state sets. The paper is particularly strong in its honest reporting: the RNG-corruption control establishes that the snapshot is load-bearing, cross-process durability is tested with a real process death, the return-time scoring correction is motivated by an explicit failure mode, and the negative scheduling results bound the runtime's claims. The reproducible experiments and explicit limitations are also to the paper's credit. The main concern is not the internal validity of the measured restores but the breadth of the attribution claim: the paper does not establish that the benchmark harnesses actually discard state at request boundaries, so the headline 'the capability was never missing' is not fully supported by the evidence as presented.

major comments (4)
  1. [§1.2, §7.1, §7.2] The paper's central attribution claim — that the benchmark-measured persistence failure is a runtime state-discard problem rather than a model capability gap — is not supported by the experiments as reported. The authors do not inspect or cite the serving topology of MBench/WRBench. Their own protocol in §7.1 explicitly issues anchor/excursion/return as three requests per session, creating the request boundary that the session-centric runtime then repairs. If a benchmark runs departure-return as one continuous generation call, no runtime state is reclaimed mid-trajectory, and the demonstrated bit-exact restore is an external-memory splice. Furthermore, §1.4 concedes that the runtime does not simulate hidden events, so WRBench's 'what-memory records hidden change' failure cannot be a serving artifact. The authors should either demonstrate that the benchmark harnesses contain at least one
  2. [Definition 1 / §6] The formal core of the paper is not checkable because the return-consistency metric D is never defined. Definition 1 defines PCS via D(continue(restore(S)), oracle) ≤ ε, and the fingerprinting procedure in §4 depends on D and ε, but Section 6 gives only a claim ('a restore or fork is correct iff the continuation preserves the world'), a threshold ('return-consistency > floor'), and tables of numeric values. There is no formula, algorithm, or operational description of D. As written, neither Definition 1 nor the fingerprinting procedure can be reproduced or verified. The authors need to specify D, the probe distribution, and how ε is chosen.
  3. [§3, §4 (Fingerprint)] The claimed 'minimality' property of PCS is asserted but not established. The Procedure Fingerprint tests individual necessity by removing one component at a time, then uses a greedy sufficiency fallback. This does not certify that no proper subset of the returned set satisfies D ≤ ε. In particular, if two components are only jointly necessary, the greedy fallback may return both, but no check rules out a redundant member. For the three concrete models, an explicit subset ablation may suffice, but the procedure as stated cannot support the general 'arg min |S|' definition or the text's 'no proper subset suffices' claim.
  4. [§7.3, Table 2] There is a factor-of-roughly-26 inconsistency in the reported per-session host memory cost, which is load-bearing for the 'host-bound rather than device-bound' scaling claim. Table 2 shows peak host memory of 0.964 MB at S=1, 1.927 MB at S=2, and 15.416 MB at S=16, i.e., approximately 0.96 MB per WorldMem session. The text in §7.3 states 'Host cost is 0.0364 MB per session,' and the 1,024-session sweep reports 0.0373 MB per resident session. The S=256 mock sweep gives 247 MB, again ≈0.96 MB per session. These numbers need to be reconciled, and the configuration that produces each constant must be stated; otherwise the host-memory ceiling and the 2,300× session-count factor are not reproducible.
minor comments (4)
  1. [Throughout] Typographical issues: 'W e' appears at the start of the abstract and again in §1.1, and several table captions use 'T able' with a spurious space. These should be cleaned up.
  2. [§7.11] The 'No positional-injection result' paragraph is long and mixes a declared invalid experiment with a new reachability measurement. Consider splitting it: state the invalid experiment in one sentence, and move the Matrix-Game 2.0 reachability/excursion measurement to a separate, clearly labeled result.
  3. [§7.7] The narrative about the 'pcs-aware' policy is clear in the end, but the mapping from the original four policy names to the CheckpointPolicy×EvictionPolicy×SchedulePolicy triples is described only in prose. A small table or explicit mapping would help readers interpret earlier tables (e.g., Tables 5 and 6).
  4. [Section 4 / Figure 2] Figure 2's caption says 'state model obtained by measurement, per model' — this is grammatically awkward and slightly confusing. Consider 'the state is obtained by measurement, per model'.

Circularity Check

0 steps flagged

No significant circularity: core restore results are empirical and externally anchored; the benchmark-attribution gap is an external-validity threat, not a definitional reduction.

full rationale

The paper's central derivation chain is: (1) define PCS as the minimal subset S of runtime state satisfying D(continue(restore(S)), oracle) ≤ ε (Definition 1); (2) discover S by the Fingerprint ablation procedure; (3) verify bit-exact restore against never-left continuations. None of these steps reduces to its inputs. The restore is measured against external anchors (DINOv2 similarity 1.0, pixel error 0.0, torch.equal on latents, cross-process byte identity), and the RNG-corruption control (DINOv2 drops to 0.979/0.970; latent exactness to 3%) demonstrates the snapshot is load-bearing rather than ignored. The PCS definition is operational, not circular: it specifies a target set, and the fingerprint is a search over that definition, not a fitted parameter renamed as a prediction. The paper explicitly disclaims the circular version of its argument in §1.2 ('an argument of the form ... is circular; a bit-exact restore is not') and lists scope limitations (procedure not theorem, three model families, metric-dependence, model-bounded persistence) in §10. The strongest challenge is external validity, not circularity: the paper's own §7.1 protocol 'issued as three requests per session' creates a request boundary, and the paper does not establish that MBench/WRBench harnesses actually discard recoverable state at such boundaries. If those benchmarks run continuous single-session rollouts, nothing was discarded and the bit-exact restore is an external-memory splice. That is a substantive evidential gap about the target benchmarks, but it does not make the paper's own restore results equivalent to their inputs by construction. There are no load-bearing self-citations (references are external; no author-overlap uniqueness theorem is invoked), no ansatz smuggled by citation, and no empirical pattern merely renamed. Hence no significant circularity.

Axiom & Free-Parameter Ledger

5 free parameters · 5 axioms · 3 invented entities

The central experiment depends on few fitted constants; the main free choices are the tolerance ε, the unspecified conformance metric D, the probe distribution, and the 12% retention floor. The headline determinism result is enabled by the standard property that a deterministic generator reproduces its output from identical inputs and RNG — an axiom, not a discovery. The interpretation of the benchmarks as serving-layer failures is an assumed mapping from benchmark protocol to request-boundary discard that the paper does not verify. Conceptual inventions (PCS, non-recomputable kernel, session contract) carry operational handles and are externally checkable via byte-exact restore, so independent_evidence is True for the restore claim itself.

free parameters (5)
  • tolerance ε = ε=0 for headline; unstated for fingerprint (D > ε)
    Appears in Definition 1 (PCS) and Fingerprint step 1. The bit-exact headline sets ε=0; the necessity threshold used in the ablation that classifies buffers as must-snapshot is never given a value, so the discovered PCS is threshold-dependent.
  • retention fraction = 12%
    Section 7.5/§5: 'the retention level the standalone eviction study measured.' Held fixed across all eviction sweeps and the predictive-eviction analysis; it sets the floor that bounds how much eviction can save and therefore shapes the headline relevance-vs-recency and predictive-eviction results.
  • conformance metric D and its floor = not specified
    Section 6: 'return-consistency > floor' with no formula for C(L). D appears in the PCS definition (§3), in the fingerprint (necessity iff D>ε, §4), and as the acceptance criterion for every restore (§6) — every headline number in §7.5–7.9 is scored with it, and it is not checkable from the text.
  • fingerprint probe distribution = not specified
    Section 4: the leave-and-return probe is a distribution the authors choose; Limitation 1 concedes probe-independence is open, so the discovered PCS (obs+RNG / bank+pose+RNG / KV+pos+RNG) is relative to this probe.
  • workload arrival/think-time parameters = Poisson arrivals, think times, leg lengths 4/8/8
    Section 7.8: trace pressure follows from arrival rate and think time; an arrival-order replication covers variability, but the constructed-load results (§7.5) are generated by a workload chosen to make pressure bind.
axioms (5)
  • standard math Deterministic generator: identical (input, RNG, weights) ⇒ identical continuation
    Load-bearing for the bit-exact restore in §7.2; it is the property that makes 'restore obs+RNG ⇒ never-left continuation' hold for Cosmos3 and 'restore bank+RNG' hold for WorldMem. The paper treats this as a discovery, but it is the definition of determinism.
  • ad hoc to paper The benchmarks' failure occurs under a serving path that discards recoverable state
    §2's request-centric account is assumed to describe the failure MBench/WRBench measured; the paper does not run the benchmark harnesses or verify that a request boundary exists in their protocols. This is the weakest load-bearing premise (see weakest_assumption).
  • domain assumption Sampling RNG is part of world identity — a return is 'the same world' only if the RNG stream matches
    §1.3 classifies the RNG stream as a non-recomputable kernel. The choice to demand byte-identical reproduction (ε=0), including noise, rather than semantic equivalence to the world left, is a policy decision the paper makes (§1.4: narrower computational sense of persistence).
  • domain assumption A buffer is PCS iff restore reads it (state-vs-witness test)
    §3: the mechanical test classifying the observation as PCS for Cosmos3 but witness for WorldMem is assumed as the operational boundary, with the RNG-corruption control as a partial check.
  • domain assumption Re-supplying the saved anchor frame/bank at the return step is a legitimate world-model operation
    §7.2's protocol injects the saved observation/bank at the return step. This presupposes the serving layer may insert state the model did not itself carry through the excursion — the very behavior that would make a benchmark's departure-return test trivially pass by reset.
invented entities (3)
  • Persistent Computational State (PCS) independent evidence
    purpose: The minimal non-recomputable subset of runtime state that must survive request boundaries for semantic continuation; the object the session runtime checkpoints, restores, and forks.
    Operational handle exists: the fingerprinting procedure (§4) and the byte-exact restore results (§7.2) are falsifiable — a model whose PCS were different would fail the stated ablations.
  • Non-recomputable kernel independent evidence
    purpose: The part of runtime state (RNG stream, memory bank, recurrent activations) not reconstructible from inputs, which makes recompute-caching incorrect for world models.
    The RNG-corruption control (DINOv2 0.979/0.970, 3% latent-exact) gives a measurable handle; the category itself is a framing device over known state-reconstruction concepts (environment-state vs observation in RL).
  • Session with four invariants (round-trip, durability, fork-independence, snapshot-completeness) independent evidence
    purpose: First-class unit of state ownership across requests, replacing request-scoped allocation.
    Each invariant is tested: round-trip and durability are byte-checked, fork by the 48-fork planner trace, completeness by |checkpoint|=|PCS| measurements.

pith-pipeline@v1.3.0-alltime-deepseek · 5903 in / 6265 out tokens · 366863 ms · 2026-08-01T07:40:54.956370+00:00 · methodology

0 comments
read the original abstract

Generative world models are increasingly driven as simulators: a planner forks a state, rolls out futures, backtracks, and returns to a visited viewpoint. Recent benchmarks establish that current video world models fail this usage, and attribute it to the model, prescribing new architectures and training objectives. We show this attribution is incomplete, and for an important class of models simply wrong. Snapshotting the state the runtime already holds -- an observation plus RNG state, a memory bank, or a windowed KV context, by architecture -- and restoring it after a genuine excursion reproduces the never-left continuation byte-identically on all three; corrupting only the RNG degrades it. The capability was never missing: request-centric serving discarded it, inheriting from language-model serving the assumption that runtime state is recomputable -- but world-model state carries a non-recomputable kernel. We define Persistent Computational State (PCS), the minimal non-recomputable state that must survive across requests, show it can be discovered by measurement, and build a session-centric runtime over it. Checkpoint and restore cost 0.012 ms against a 1.85 s generation step; resident sessions become host- rather than device-bounded (measured to 1,024); and world memory must be evicted by relevance to the return, not recency -- the inverse of LLM practice.

Figures

Figures reproduced from arXiv: 2607.21686 by Zhen Lin.

Figure 1
Figure 1. Figure 1: Request-centric vs. session-centric. Left: request → generate → end; state is dis￾carded at the boundary and the trajectory breaks on return. Right: session → checkpoint → fork → restore; state is owned across requests and the trajectory survives. on H′ t , so ot+1 departs from the true trajectory, and the departure compounds with horizon. Per￾sistence is impossible by construction. Not because the model i… view at source ↗
Figure 2
Figure 2. Figure 2: PCS discovery by measurement. The full runtime state H is passed through Fingerprint (ablation over the probe); each component is classified must-snapshot (∈ PCS) or recomputable (drop). The returned set is the runtime’s snapshot plan — obtained per model, by measurement, not asserted. and {KV context, position indices, RNG} (≈1.67 GB, large but windowed — fixed by the local-attention span) — sets that sha… view at source ↗
Figure 3
Figure 3. Figure 3: Runtime architecture. Planner / Agent / World Model above; the Session Runtime (session table, PCS checkpoint manager, retriever, conformance) is this paper’s layer; the GPU runtime (paged KV, copy-on-write fork, CUDA, storage) is community mechanism, consumed as given. Byte work is delegated downward. and the same notion drives eviction: keep the state that still contributes to a return, drop the rest. Fo… view at source ↗
Figure 4
Figure 4. Figure 4: Conformance. Leave → Return → Restore(PCS) → continue, then return-consistency C(L) against a floor ⇒ pass / fail. Semantic acceptance: was the world preserved? Bit-exactness cannot express this. • Lossy but correct. Re-grounding a rollout that cannot return bit-exactly — after a long excursion, say — is still correct if the world is preserved. A bit-exact criterion would wrongly reject it. • Byte-successf… view at source ↗
Figure 5
Figure 5. Figure 5: Sessions per GPU, with vs. without PCS. Blue is measured (device memory constant in S); orange is derived from two measured constants (device-bound, growing with S). Externalizing state is what makes suspension possible; the gap is ≈2,300× in resident sessions [PITH_FULL_IMAGE:figures/full_fig_p014_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Eviction cost curve. Panel A: return-consistency vs. host budget ( [PITH_FULL_IMAGE:figures/full_fig_p016_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Oversubscription, mock sweep. As peak concurrent sessions on one time-multiplexed GPU rise, the session-centric runtime’s host memory grows steeply (it keeps every session’s world) while the request-centric server’s grows an order of magnitude slower (it keeps only the last frame) — ≈11× at 48 sessions. Return-consistency does not separate (right): request-centric is adequate on this recency-dominated mode… view at source ↗
Figure 8
Figure 8. Figure 8: A taxonomy by derivability. Is the state recomputable? Recomputable state (KV cache, prefix cache / RadixAttention, LLM serving) may be discarded and rebuilt. Non-recomputable state (PCS, this paper’s session runtime, generative world models) must be persisted. Checkpoint/snapshot and Redis store bytes without the derivability distinction — they pay |H|, not |PCS|. Externalized memory where language suffic… view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

25 extracted references · 18 linked inside Pith

  1. [1]

    MBench: A Comprehensive Benchmark on Memory Capability for Video World Models

    Shengjun Zhang et al. MBench: A Comprehensive Benchmark on Memory Capability for Video World Models. arXiv:2606.00793, 2026

    Pith/arXiv arXiv 2026

  2. [2]

    arXiv:2606.20545, 2026

    Current World Models Lack a Persistent State Core (WRBench). arXiv:2606.20545, 2026

    Pith/arXiv arXiv 2026

  3. [3]

    MemoBench: Benchmarking World Modeling in Dynamically Changing Environments

    Haoyu Chen et al. MemoBench: Benchmarking World Modeling in Dynamically Changing Environments. arXiv:2606.27537, 2026

    Pith/arXiv arXiv 2026

  4. [4]

    The Trinity of Consistency as a Defining Principle for General World Models (CoW-Bench)

    Jingxuan Wei et al. The Trinity of Consistency as a Defining Principle for General World Models (CoW-Bench). arXiv:2602.23152, 2026

    arXiv 2026

  5. [5]

    A Definition and Roadmap for World Models

    Xinyuan Chen et al. A Definition and Roadmap for World Models. arXiv:2607.06401, 2026

    Pith/arXiv arXiv 2026

  6. [6]

    WorldMem: Long-term Consistent World Simulation with Memory

    Zeqi Xiao et al. WorldMem: Long-term Consistent World Simulation with Memory. arXiv:2504.12369, 2025

    arXiv 2025

  7. [7]

    Cosmos World Foundation Model Platform for Physical AI

    NVIDIA. Cosmos World Foundation Model Platform for Physical AI. arXiv:2501.03575, 2025

    Pith/arXiv arXiv 2025

  8. [8]

    Matrix-Game 2.0: An Open-Source, Real-Time, and Streaming Interactive World Model

    Skywork AI. Matrix-Game 2.0: An Open-Source, Real-Time, and Streaming Interactive World Model. arXiv:2508.13009, 2025

    Pith/arXiv arXiv 2025

  9. [9]

    Genie: Generative Interactive Environments

    Jake Bruce et al. Genie: Generative Interactive Environments. In ICML, 2024. arXiv:2402.15391

    Pith/arXiv arXiv 2024

  10. [10]

    GAIA-1: A Generative World Model for Autonomous Driving

    Anthony Hu et al. GAIA-1: A Generative World Model for Autonomous Driving. arXiv:2309.17080, 2023

    Pith/arXiv arXiv 2023

  11. [11]

    Mastering Diverse Domains through World Models (DreamerV3)

    Danijar Hafner et al. Mastering Diverse Domains through World Models (DreamerV3). arXiv:2301.04104, 2023

    Pith/arXiv arXiv 2023

  12. [12]

    Learning Latent Dynamics for Planning from Pixels (PlaNet)

    Danijar Hafner et al. Learning Latent Dynamics for Planning from Pixels (PlaNet). In ICML,

  13. [13]

    Addressable Memory for Closed-Loop Video World Models (WorldTrace)

    Xindi Wu, Sven Elflein, James Lucas, Olga Russakovsky, Laura Leal-Taix´ e, Despoina Paschali- dou, Jonathan Lorraine, and Aljoˇ sa Oˇ sep. Addressable Memory for Closed-Loop Video World Models (WorldTrace). In CVPR Workshop on World Models, 2026.https://cvpr26wmas. github.io/papers/wu26addressable.pdf

    2026

  14. [14]

    DINOv2: Learning Robust Visual Features without Supervision

    Maxime Oquab et al. DINOv2: Learning Robust Visual Features without Supervision. arXiv:2304.07193, 2023

    Pith/arXiv arXiv 2023

  15. [15]

    Efficient Memory Management for Large Language Model Serving with PagedAttention

    Woosuk Kwon et al. Efficient Memory Management for Large Language Model Serving with PagedAttention. In SOSP, 2023. arXiv:2309.06180

    Pith/arXiv arXiv 2023

  16. [16]

    Orca: A Distributed Serving System for Transformer-Based Generative Models

    Gyeong-In Yu et al. Orca: A Distributed Serving System for Transformer-Based Generative Models. In OSDI, 2022

    2022

  17. [17]

    Taming Throughput-Latency Tradeoff in LLM Inference with Sarathi- Serve

    Amey Agrawal et al. Taming Throughput-Latency Tradeoff in LLM Inference with Sarathi- Serve. In OSDI, 2024. arXiv:2403.02310

    Pith/arXiv arXiv 2024

  18. [18]

    DistServe: Disaggregating Prefill and Decoding for Goodput-optimized Large Language Model Serving

    Yinmin Zhong et al. DistServe: Disaggregating Prefill and Decoding for Goodput-optimized Large Language Model Serving. In OSDI, 2024. arXiv:2401.09670

    Pith/arXiv arXiv 2024

  19. [19]

    TensorRT-LLM.https://github.com/NVIDIA/TensorRT-LLM

    NVIDIA. TensorRT-LLM.https://github.com/NVIDIA/TensorRT-LLM

  20. [20]

    SGLang: Efficient Execution of Structured Language Model Programs (RadixAttention)

    Lianmin Zheng et al. SGLang: Efficient Execution of Structured Language Model Programs (RadixAttention). arXiv:2312.07104, 2023

    Pith/arXiv arXiv 2023

  21. [21]

    CacheGen: KV Cache Compression and Streaming for Fast Large Language Model Serving

    Yuhan Liu et al. CacheGen: KV Cache Compression and Streaming for Fast Large Language Model Serving. In SIGCOMM, 2024. arXiv:2310.07240

    Pith/arXiv arXiv 2024

  22. [22]

    CacheBlend: Fast Large Language Model Serving for RAG with Cached Knowledge Fusion

    Jiayi Yao et al. CacheBlend: Fast Large Language Model Serving for RAG with Cached Knowledge Fusion. In EuroSys, 2025. arXiv:2405.16444

    Pith/arXiv arXiv 2025

  23. [23]

    LayerKV: Optimizing Large Language Model Serving with Layer-wise KV Cache Management

    Yi Xiong et al. LayerKV: Optimizing Large Language Model Serving with Layer-wise KV Cache Management. arXiv:2410.00428, 2024

    Pith/arXiv arXiv 2024

  24. [24]

    CRIU: Checkpoint/Restore In Userspace.https://criu.org. 29

  25. [2019]

    arXiv:1811.04551. 28

    Pith/arXiv arXiv