acceptodds
Under review as a conference paper at ICLR 2027

BoxWorld: Let World Engines Control and Video Generators Render

18 views

Abstract

We tackle the challenge of building real-time interactive video worlds with user-defined behaviors. Such worlds must track object states, apply interaction rules, and render the resulting consequences as users act. Yet existing end-to-end video world models typically learn interaction dynamics within the generator, making it difficult to specify object-level rules and reason about their consequences. In this work, we introduce BoxWorld, which separates interaction reasoning from generative rendering. Given user-specified rules, a coding agent creates a Box World Engine that determines interaction outcomes and exposes the resulting object states through a lightweight interface of layout boxes, persistent object attributes, and dynamic status variables. A Box-State Generative Renderer then renders this evolving state stream into video autoregressively, enabling online control over object motion, state switches, and conditional events. Rendering this state stream is non-trivial: the renderer must respond to object-level state updates in real time while remaining coherent with the generated history. To this end, we introduce a three-stage training strategy that learns object grounding from open-domain videos and state transitions from gameplay videos, both annotated automatically, and finally performs rollout distillation on self-generated histories. We further propose PairedStateBench, a paired benchmark for fine-grained interaction control. BoxWorld substantially outperforms end-to-end world models and remains competitive across multiple public benchmarks.

Primary area:
generative models
Keywords:
Video Generation, Interactive World Models, Controllable Video Generation, Real-time Video Generation

Reviews

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

The paper proposes a decoupling strategy to model the world state and the final video rendering. Specifically, a coding agent creates a world engine from user-defined rules. And a video diffusion model renders final videos given the bounding box video priors. To achieve this goal, the paper proposes an interface named "Object-Centric State Interface" to bridge the box world state and the final video rendering. The paper also introduces a data and training paradigm to transform an autoregressive video generation model into a box-state-aware video generation model while trying to maintain long-term and real-time generation, which are important in current video world models.

Critical strengths

(a) The decoupling strategy, where a coding agent explicitly records rules and parameters, and a video diffusion model renders final videos given bounding box video priors, is essential for world simulation that requires precise control, long-term consistency, and so on. The paper leverages the advantages of both tools, i.e., the coding agent is easy to maintain precise rules and parameters, while the video diffusion model is powerful in rendering high-quality videos.

(b) While transforming an autoregressive video generator into a box-state-aware video renderer, the paper also manages to maintain real-time interaction, which is important to current video world models. Besides, the final rendered videos cover a diverse range of environments, verifying the generalization ability of the proposed method.

Critical weaknesses

(a) It seems that the quantitative results are not comprehensive enough. The paper compares its own model with LingBot-World-v1, LingBot-World-v2, and LongLive. And LongLive also serves as the base model of BoxWorld. I understand that there are many concurrent world model works trying to solve similar problems. And comparing to all of them seems to be impossible. However, I think comparing to additional one or two representative works is still necessary, such as HY-World 1.5, Matrix-Game-3.0, YUME 1.5, and Astra.

(b) Current video world models are also required to generate multi-turn and long-term video results. And some representative models can achieve mintue-level generation. However, the screenshot sequences shown in the paper and the videos shown in the supplementary materials seem to be relatively short.

Questions for authors

(a) See Critical Weaknesses (b). Current autoregressive generation often suffers from error accumulation, which leads to visual quality degradation. I am concerned whether the method can truly generate multi-turn long videos while maintaining visual quality and consistency.

1 comment
AuthorsOpenReview ↗

Author Response

Thank you for your positive rating and recognizing that our decoupling framework is essential and effective! Below, we provide a point-by-point response to address your concerns. We welcome further discussion to enhance the clarity and effectiveness of our work.

W1: More representative world models in the quantitative comparison.

A1:

  • Per your suggestion, we added HY-World 1.5 and YUME 1.5 in both the standard and the oracle settings; the results are added to Tab. 1 and Fig. 4.
  • BoxWorld leads every baseline on all six metrics. The added models show the same pattern: YUME 1.5 renders the likely event regardless of the branch condition (14.3% Suppress), while HY-World 1.5 rarely renders it (3.3% Trigger).
MethodFPSTriggerSuppressPaired-CFState-FidOnTimeTask
LingBot-v10.0553.511.116.243.144.525.3
LingBot-v1 (Oracle)0.0545.525.416.242.327.718.4
LingBot-v213.321.363.510.846.114.311.5
LingBot-v2 (Oracle)13.319.069.816.257.117.511.5
HY-World 1.53.13.363.58.142.12.38.0
HY-World 1.5 (Oracle)3.14.063.510.841.92.310.3
YUME 1.58.328.814.313.530.418.711.5
YUME 1.5 (Oracle)8.330.531.716.232.721.38.0
LongLive20.710.750.813.536.25.78.0
BoxWorld20.792.290.597.391.691.283.9

W2, Q1 (a): Multi-turn interaction.

A2(a): PairedStateBench evaluates multi-turn interaction: State-Fid checks the status after every turn, and Task requires all turns to succeed in order.

  • Multi-turn cases: 34 of 87 cases are multi-turn, taking an object through three or more distinct statuses, and 18 through four or more.
  • State-Fid: after each turn, State-Fid checks whether each object holds its specified status within the state window, computed over 2,703 sampled states, where BoxWorld reaches 91.6% (Tab. 1).
  • Task: Task requires every turn to succeed in the same video, checking "whether all action stages, forbidden-state constraints, event ordering, and final outcomes hold in the same video"; BoxWorld reaches 83.9% vs. at most 25.3% for the baselines, and 80.6% vs. at most 8.3% on hard cases.

W2, Q1 (b): Minute-level generation, and whether quality holds under error accumulation.

A2(b):

  • Stage 3 distills the renderer on its own rollouts with Self-Forcing-style distribution matching, restoring few-step and long-video generation. On 30-second VBench-Long, it raises Total from 81.82 to 83.00, comparable to LongLive (83.52) and above Self Forcing (81.59), with Semantic 77.67, above every baseline (Tab. 3).
  • We added to the supplementary a 60-second rollout with 54 actions and 12 triggered events and a 30-second rollout from VBench-Long, both in BoxWorld_Additional_Qualitative.mp4.
Reviewer_mXqGOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes BoxWorld, which separates interaction logic from video generation for interactive video worlds with user-defined rules. A coding agent turns user-specified rules into an engine that updates object states. These states are exposed to a streaming autoregressive video generator as layout boxes, persistent attributes, and dynamic status descriptions. The generator injects them through frame-wise masked cross-attention and is trained in three stages on automatically annotated open-domain and gameplay videos. Experiments cover a new paired benchmark for rule-dependent outcomes, video quality on VBench, and layout-to-video generation on YouTube-VIS.

Critical strengths

1.The object-centric interface is practical and reusable. Boxes, attributes, and dynamic status can be extracted from unlabeled videos. The renderer is therefore trained without action-paired logs or simulators, and a single engine can drive multiple visual worlds..

  1. The renderer follows object-level conditions. Its YouTube-VIS results are competitive with offline layout-to-video methods despite few-step causal generation. The spatial-mask ablation, which roughly halves mIoU, directly supports the grounding design.
Critical weaknesses

1.The main comparison does not isolate the renderer’s contribution. BoxWorld receives time-aligned boxes and resolved object states, whereas the baselines receive only prompts or action and camera inputs. The timing of the oracle text is also unclear. A baseline given the same engine states, such as LongLive with event-aligned prompt updates, is needed to separate the benefit of the grounding mechanism from that of richer conditioning.

2.The path from user-defined rules to interactive worlds is only partly validated. The coding-agent step is not evaluated, with no success rates or human corrections reported. It is also unclear whether the benchmark’s state transitions already appear in the gameplay training data, which limits the claim of supporting new behaviors.

Questions for authors

1.Can the renderer handle status transitions or rules that are absent from its training data? An overlap analysis between the benchmark statuses and the gameplay annotations, or a held-out split, would clarify how far BoxWorld supports new behaviors.

2.Stage 3 uses only 400 DMD steps, yet it raises Paired-CF from 67.6% to 97.3%, well above its Stage 2 teacher. How was Stage 2 sampled at evaluation? Does this gain hold across repeated generations, given that the benchmark has only 37 pairs?

3.In live asynchronous use, what is the latency from a user action to its visible effect? How much human correction did the agent-written engines need?

5 comments
AuthorsOpenReview ↗

Author Response (1/2)

Thank you for recognizing that our object-centric interface is practical and reusable and that our ablation supports the grounding design! Below, we provide a point-by-point response to address your concerns. We welcome further discussion to enhance the clarity and effectiveness of our work.

W1(a): Whether the main comparison isolates the renderer's contribution, and when the oracle text is given.

A1(a): The oracle variants in Tab. 1 are intended to compare rendering, since they receive the resolved outcome and only need to render it. For example, in the key-and-door case, the oracle variant receives "the cat picks up the key and opens the door" as the global prompt, given once at the start of the clip (App. C.2, L1343-1344), so it only needs to render the door opening when the cat reaches the door. Compared with the oracle variants, our renderer achieves far higher Trigger (92.2% vs. 45.5%), Suppress (90.5% vs. 69.8%) and Paired-CF (97.3% vs. 16.2%).

W1(b): A baseline given the same engine states, such as LongLive with event-aligned prompt updates.

A1(b):

  • Per your suggestion, we added LongLive with event-aligned prompts, which receives the same engine state descriptions at the triggered times. The results are added to Tab. 1.
  • Event-aligned prompts raise LongLive's Trigger from 10.7% to 16.5%, while our State Grounding Module on the same frozen backbone (Stage 1) raises it to 87.3%, and our BoxWorld still significantly outperforms LongLive (event-aligned) on every metric:
MethodTriggerSuppressPaired-CFState-FidOnTimeTask
LongLive10.750.813.536.25.78.0
LongLive (event-aligned)16.560.310.842.514.26.9
BoxWorld Stage 187.360.364.983.483.849.4
BoxWorld (full)92.290.597.391.691.283.9

W2(a), Q3(b): Validation of the coding-agent step: success rates and human corrections.

A2: The rules-to-engine step is self-checked at the code level before any video is rendered, and in all our cases it needed no human correction.

  • Since the engine stays "editable and inspectable" code, the coding agent writes it within its own harness, runs it on the CPU and self-checks it against the user's rules before use.
  • Every engine in the paper, covering all PairedStateBench cases including multi-stage interactions, was generated by Kimi K2.5 from user-specified rules and used without manual edits. We will release the engine templates together with the code and model checkpoints.

We are happy to take any additional advice on which coding benchmark we should evaluate our chosen coding agent on.

W2(b), Q1: Status transitions and rules absent from the training data.

A3: The gameplay data differs from the benchmark, Stage 1 outperforms the baselines even without gameplay data, and rules never enter training.

  • Gameplay data: the gameplay clips show general actions and triggered events, such as a racing car accelerating through a track (e.g., Fig. 8), whereas PairedStateBench cases specify conditional consequences, such as credential-dependent doors, charging, and multi-stage interactions.
  • Rules: rules are not in the training data: they live in the engine, and the renderer is trained without engines or action-paired interaction logs.
  • Held-out evaluation: even without any gameplay data, Stage 1, trained only on open-domain videos, outperforms the best baseline on Trigger (87.3% vs. 53.5%), Paired-CF (64.9% vs. 16.2%), State-Fid (83.4% vs. 57.1%), OnTime (83.8% vs. 44.5%) and Task (49.4% vs. 25.3%) (Tab. 7 and A1(b)).
AuthorsOpenReview ↗

Author Response (2/2)

Q2(a): How Stage 2 was sampled, and why Stage 3 gains so much over its Stage 2 teacher.

A4(a): Stage 2 is sampled exactly like Stage 3, and Stage 3 gains because it trains on its own rollouts, the setting PairedStateBench tests.

  • Same sampling: both stages use the four-step causal sampler of our real-time mode on the same engine-exported states; we added this to the Tab. 7 caption.
  • Own rollouts: Stage 2's teacher forcing "trains it on clean prefixes, whereas inference conditions on self-generated ones", while Stage 3 distills the renderer "on its own rollouts", so the student learns the inference setting directly and can exceed its teacher there. The 400 steps suffice because Stage 3 "restores few-step generation" that LongLive, our distilled backbone, already has.
  • Rollout dependence: the gain grows with how much the metric depends on the whole rollout: VBench Total (83.57 → 83.76) vs. VBench-Long Total (81.82 → 83.00), and on PairedStateBench, Paired-CF (67.6% → 97.3%) and Task (64.4% → 83.9%). Paired-CF counts a pair only if both branches succeed, so gains on each branch compound.

Q2(b): Whether the gain holds across repeated generations.

A4(b):

  • Besides Paired-CF, each run scores 139 events (Trigger, OnTime), 2,703 state checks (State-Fid) and 87 full multi-stage tasks (Task), and Stage 3 raises all six metrics (Tab. 7), e.g., Task from 56/87 to 73/87.
  • Per your suggestion, we repeated the evaluation of Stage 2 and Stage 3 with three seeds on PairedStateBench (mean ± std over three seeds, %):
StageTriggerSuppressPaired-CFState-FidOnTimeTask
Stage 281.1 ± 2.288.4 ± 2.470.3 ± 2.783.0 ± 1.377.3 ± 4.567.8 ± 3.4
Stage 389.8 ± 2.292.1 ± 2.892.8 ± 4.191.0 ± 0.687.4 ± 3.582.0 ± 2.4

Q3(a): Action-to-visible latency in live asynchronous use.

A5:

  • Our BoxWorld's interactive latency matches state-of-the-art real-time generators (e.g., LongLive and Self Forcing), while being lower than our baseline video world models (e.g., LingBot-World). A state update is reflected in the next generated frames (Sec. 3.2), so the latency is set by the chunk size and FPS. Specifically, LongLive, Self Forcing and BoxWorld use a 3-latent-frame chunk at 17.0–20.7 FPS, while LingBot-v2 uses a 4-latent-frame chunk at 13.3 FPS, and LingBot-v1 generates the full clip bidirectionally at 0.05 FPS.
  • Our engine runs on the CPU at over 120,000 steps per second headless, with 47–49 MB of memory and less than 0.02% of one core at 16 Hz, adding negligible cost; we added this to App. B.

Thank you for adding the event-aligned LongLive baseline and the three-seed evaluation. These substantially address my concerns about the original comparison and the Stage 3 result. The report that the benchmark engines required no manual edits is also helpful.

Two questions remain:

  1. Does the evaluation establish that PairedStateBench transitions were absent from renderer training data? Excluding rules from training does not by itself establish this.
  2. Also, FPS and chunk size do not quantify end-to-end action-to-visible-effect latency.

If these analyses are unavailable, please clarify the corresponding limitations and narrow the claims accordingly.

Overall, my concerns have been substantially reduced, though these points remain.

Reviewer_PdP6OpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
3
Presentation
2
Soundness
3
Read review
Paper summary

This paper presents BoxWorld, a real-time interactive video world that separates interaction reasoning from generative rendering. A coding agent turns user-specified rules into a Box World Engine, which decides interaction outcomes and outputs each object's box, attributes, and status. A LongLive-based renderer turns this state stream into video in real time, and is trained on automatically annotated videos. On the new PairedStateBench, BoxWorld substantially outperforms end-to-end world models, while staying competitive on VBench, VBench-Long, and YouTube-VIS at 20.7 FPS.

Critical strengths
  • Flexible method: A coding agent builds a rule-based engine for each scene, giving explicit control over each object's state. One renderer can be driven by different engines through the same interface.

  • Flexible training: Object states are extracted automatically from ordinary videos, so the renderer needs no simulator-paired data or action logs.

  • Strong results: BoxWorld outperforms the baselines on PairedStateBench and YouTube-VIS, and stays competitive with its backbone on VBench and VBench-Long.

Critical weaknesses
  • Unclear advantage over existing simulator-driven generation: Using an explicit engine to decide what happens and a generator to render it has been explored before, e.g., Coarse-to-Real [1] and Vid2Sim. The paper separates itself from simulators only conceptually, yet its engine is itself a rule-based program, and App. B notes that existing 2D or 3D engines can also serve as the engine. What this engine offers over an existing simulator is neither discussed nor shown, beyond lines of code. A discussion of [1], ideally with a comparison on shared scenarios, would help.

  • Missing efficiency evaluation: The real-time claim rests only on FPS, without interactive latency, i.e., the delay from a user action to its visible effect. BoxWorld also reports the same 20.7 FPS as LongLive despite the added State Grounding Module, and the hardware is not given. A latency comparison with the diffusion baselines (e.g., LongLive, Self Forcing, LingBot) on the same hardware is needed.

  • Limited expressiveness of the state: The status is a text label, and the shown changes are mostly binary, e.g., a flower from closed to bloom. It is unclear how this extends to continuous states: the gradual blooming in the teaser would need intermediate states, but the engine only decides whether and when the flower blooms. The benchmark also scores states as discrete windows, so continuous control is not evaluated.

References

[1] Gomez-Nogales et al., "Coarse-to-Real: Generative Rendering for Populated Dynamic Scenes", arXiv:2601.22301, 2026.

Questions for authors
  1. Who specifies the initial layout boxes of each scene? If the coding agent chooses them, how does it keep them plausible (e.g., size and perspective)?
2 comments
AuthorsOpenReview ↗

Author Response (1/2)

Thank you for recognizing that our method and training are flexible and our results are strong! Below, we provide a point-by-point response to address your concerns. We welcome further discussion to enhance the clarity and effectiveness of our work.

W1(a): Advantage over existing simulator-driven generation, e.g., Coarse-to-Real (C2R), beyond a lighter engine.

A1(a): BoxWorld tackles real-time interactive video worlds with user-defined behaviors, with or without a simulator as the engine, whereas simulator-driven generation (e.g., C2R) renders a world built by a given simulator into realistic video. For this task, BoxWorld offers four advantages: lightweight, general, real-time and flexibly trained.

  • Lightweight: compared with C2R, BoxWorld uses a box-based engine, a "lightweight state machine" with no meshes or assets, which a coding agent creates from the user's rules and which runs on the CPU without simulating physics or animation.
  • General: one renderer is driven by different engines through the same interface, and one engine drives entirely different objects regardless of their geometry (e.g., Fig. 5), whereas in C2R the objects follow the geometry the simulator provides.
  • Real-time: our few-step causal renderer runs long interactive generation at 20.7 FPS, consuming object states as they arrive, whereas C2R generates 5s clips offline from a complete coarse video.
  • Flexibly trained: the renderer learns from ordinary videos annotated automatically, without engines or action-paired interaction logs, whereas C2R still relies on coarse and fully rendered pairs built with 3D tools to learn its coarse-to-real mapping.

Thank you for already recognizing three of these advantages in your review.

W1(b): Discussion of and comparison with C2R on shared scenarios.

A1(b):

  • Discussion: thank you for pointing out this recent simulator-driven generation work; we added it to the corresponding discussion in Sec. 1 and Sec. 2.
  • Comparison: per your suggestion, we compared BoxWorld and C2R on the shared scenarios of Fig. 4; see Fig. 11 in App. C.6 and the new supplementary video BoxWorld_Additional_Qualitative.mp4.
    • Settings: since C2R generates 5 s clips offline from a complete coarse video, we implemented it with a sliding window and compared it with ours in four settings: the engine's box render, box render + oracle text, a low-poly 3D version built for C2R, and low-poly 3D + oracle text.
    • Results: BoxWorld realizes the outcome the engine specifies, while C2R does not fully follow it, even with oracle text: the flower blooms and the door opens where the engine keeps them unchanged, the flower is in full bloom from the first frame, and the geometry drifts, e.g., the key turns into a panel attached to the wall and extra doors appear.

W2(a): Interactive latency, compared with real-time baselines.

A2(a):

  • Our BoxWorld's interactive latency matches state-of-the-art real-time generators (e.g., LongLive and Self Forcing), while being lower than our baseline video world models (e.g., LingBot-World). A state update is reflected in the next generated frames (Sec. 3.2), so the latency is set by the chunk size and FPS. Specifically, LongLive, Self Forcing and BoxWorld use a 3-latent-frame chunk at 17.0–20.7 FPS, while LingBot-v2 uses a 4-latent-frame chunk at 13.3 FPS, and LingBot-v1 generates the full clip bidirectionally at 0.05 FPS.
  • Our engine runs on the CPU at over 120,000 steps per second headless, with 47–49 MB of memory and less than 0.02% of one core at 16 Hz, adding negligible cost; we added this to App. B.

W2(b): Why BoxWorld reports the same 20.7 FPS as LongLive despite the added State Grounding Module, and on what hardware.

A2(b):

  • The 20.7 FPS is measured with our State Grounding Module, whose cost is offset by three implementation choices. We merge the LoRA adapters of LongLive and of our Stages 2 and 3 into the backbone weights (Sec. 3.3, L295-296), whereas LongLive's released inference keeps its LoRA unmerged; the State Grounding Module is active only at noise levels above 0.8; and it is implemented with FlexAttention (App. C.1, L1324-1325).
  • All our evaluations are conducted fairly on a single GPU with ~989 dense BF16 TFLOPS at 832×480 resolution, the same compute and setting as the reported LongLive FPS; we added this to the implementation details in App. C.1.
AuthorsOpenReview ↗

Author Response (2/2)

W3(a): How the text status, with mostly binary changes, extends to continuous states such as the gradual blooming in the teaser.

A3(a): BoxWorld can support continuous change: the engine steps through intermediate statuses, and our renderer animates each transition.

  • Engine: the status is a per-frame description, so the engine can step through intermediate statuses; in the teaser, the flower goes closed → charging → beginning to open → partly unfolded → fully unfolded while its box grows. We apologize that the teaser figure was simplified for readability; we added its engine details to App. B.
  • Renderer: our renderer learns state transitions from gameplay videos and animates each change, "such as a door swinging open".
  • Industry practice: this matches common practice in games, where gradual change is driven by discrete stages, e.g., Minecraft crops grow through stages 0–7; in the future, the same interface can extend to a scalar in the status (e.g., "opening, 40%").

W3(b): Whether continuous control is evaluated, given that the benchmark scores states in discrete windows.

A3(b): Following A3(a), continuous change is evaluated as multi-stage changes, at a fine-grained level in both state and position.

  • State: an object goes through three or more statuses in 34 of 87 PairedStateBench cases; State-Fid checks them over 2,703 sampled states (91.6%), and OnTime checks when each status switches (91.2%) (Tab. 1).
  • Position: the box is specified frame by frame, e.g., the flower's box grows as it opens; BoxWorld reaches 0.572 mIOU on YouTube-VIS, and PairedStateBench includes continuous direction, jumping and altitude control (e.g., Fig. 9).

Q1: Who specifies the initial layout boxes, and how the coding agent keeps their size and perspective plausible.

A4: The coding agent specifies them: it places each object as a 3D box with its real-world size in world coordinates, and the engine camera projects it into every frame, so size and perspective follow from the projection. All engines in the paper were created by the coding agent from user-specified rules and used without manual edits, and the user can optionally provide a reference image to the coding agent for the initial layout.

Comments on the paper

3 comments
AuthorsOpenReview ↗

General Response

Dear Program Chairs, Senior Area Chairs, Area Chairs, and Reviewers,

We sincerely thank all reviewers for their time and their thoughtful, constructive feedback. We are encouraged that the reviewers recognize our decoupled framework (UF4V, PdP6), general object-centric interface (mXqG, PdP6), and real-time renderer with strong results (PdP6, mXqG, UF4V). Following your suggestions, we have revised the manuscript and the supplementary material, with all changes marked in blue in the revised PDF. The main new experiments are:

  • More baselines: HY-World 1.5, YUME 1.5 and event-aligned LongLive (Tab. 1, Fig. 4; UF4V-A1, mXqG-A1(b)).
  • C2R comparison (Fig. 11, App. C.6; PdP6-A1(b)).
  • Held-out evaluation and three-seed repeated generations (mXqG-A3,A4(b)).
  • Minute-level rollouts (supplementary video; UF4V-A2(b)).

We hope that these responses and new results address your concerns. We would be happy to provide any further clarification, and we sincerely welcome further discussion.

Best regards,
Authors

Dear Reviewer UF4V,

Thank you for your positive feedback and for maintaining your positive rating! We sincerely appreciate your constructive suggestions and will include the new experiments and explanations in the final version.

Best regards,
Authors

Dear Reviewer PdP6,

Thank you very much for your positive feedback and for raising your score! We sincerely appreciate your constructive suggestions. We will keep the added discussion of simulator-driven generation and pipeline latency in the final version.

Best regards,
Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.