DynaFlow: Dynamic Flow Modeling Across Domains

• DynaFlow is a dynamic design paradigm where state-dependent flow replaces fixed sequences across fields like robotics, AI, and weather forecasting.
• It leverages intermediate structures to bridge declarative objectives with dynamic execution, enhancing physical consistency and computational efficiency.
• Applications range from physically consistent motion generation and parallel operator scheduling to differential filtering and adaptive world modeling.

“DynaFlow” is not a single canonical method but a recurrent label used across several technically unrelated research programs. In the recent arXiv literature, the name denotes, among other things, a dynamics-embedded flow-matching framework for physically consistent quadruped motion generation from state-only demonstrations, a Differential-Algebra-based particle-flow filter, a programmable operator-scheduling runtime for intra-device parallelism, and dynamic workflow frameworks for LLM-based agents. Related usages also appear in autonomous-driving world modeling, continuous weather forecasting, and optical-flow-guided avatar training. This multiplicity suggests a naming convention organized around “dynamic flow” as a general design principle rather than a single lineage or shared formalism (Lee et al., 24 Sep 2025, Servadio, 2 May 2025, Pan et al., 20 May 2026, Wang et al., 30 Sep 2025, Lin et al., 18 Sep 2025).

1. Cross-domain meaning and recurring technical pattern

Across domains, “DynaFlow” typically denotes a system in which a latent, physical, computational, or procedural state is advanced by an explicitly modeled flow rather than by a static pipeline or a one-step map. In robotics, the flow lives in action space and is tied to a differentiable simulator; in particle filtering, it is a pseudo-time homotopy update; in LLM agents, it is a feedback-driven workflow over operators or agents; and in systems work, it is a programmable execution schedule over subgraphs and micro-batches. The term therefore consistently marks an attempt to replace fixed sequencing with state-dependent evolution.

A second recurring feature is the use of intermediate structure that is not merely observational. In the motion-generation setting, actions are latent causes inferred from state-only demonstrations. In particle flow, a polynomial map replaces repeated per-particle ODE solves. In agentic reasoning, intermediate outputs, verifier feedback, and memory states determine subsequent subgoals. In runtime scheduling, graph annotations and asynchronous dependency tracking mediate between logical model structure and physical execution order. This suggests that “DynaFlow” is often associated with an architectural separation between a declarative objective and a dynamic execution mechanism.

2. Dynamics-embedded flow matching for physically consistent motion generation

In "DynaFlow: Dynamics-embedded Flow Matching for Physically Consistent Motion Generation from State-only Demonstrations" (Lee et al., 24 Sep 2025), DynaFlow is a conditional flow-matching model that generates action trajectories and then maps them to state trajectories through a differentiable rigid-body simulator. The central claim is physical consistency by construction: predicted states are not emitted directly in state space, but arise as simulator rollouts under generated actions. This addresses three difficulties identified in the paper: inferring actions from states, eliminating dynamically infeasible kinematic artifacts, and maintaining long-horizon stability on hardware.

The formulation begins from discrete-time dynamics,

$s_{t+1} = f(s_t, a_t),$

and a differentiable rollout map over a horizon $T$,

$$\boldsymbol{s}_{0:T} = \mathcal{S}(\boldsymbol{a}_{0:T}; s_0).$$

Flow matching is performed in action space through the probability-flow ODE

$$\frac{d\boldsymbol{a}_t}{dt} = u_\theta(\boldsymbol{a}_t, t, c),$$

with conditioning $c$. Training uses state-only demonstrations and a state reconstruction objective through the simulator,

$$\mathcal{L}_{\mathrm{state}} = \sum_{t=0}^{T} w_t \| s_t(\boldsymbol{a}_{0:T}) - s_t^{\mathrm{demo}} \|_2^2,$$

combined with a flow-matching term and optional regularization in

$$\mathcal{L}_{\mathrm{total}} = \lambda_{\mathrm{FM}}\mathcal{L}_{\mathrm{FM}} + \lambda_{\mathrm{state}}\mathcal{L}_{\mathrm{state}} + \lambda_{\mathrm{reg}}\mathcal{R}(\boldsymbol{a}_{0:T}, \boldsymbol{s}_{0:T}).$$

The implementation uses MuJoCo XLA as the differentiable simulator, JAX for vectorized rollouts, and a 1D Diffusion Transformer backbone with three transformer blocks and approximately 10.3M parameters. The reported setup uses horizon length $H=16$, state dimension $\mathbb{R}^{37}$, action dimension $\mathbb{R}^{12}$, Adam with learning rate $T$0, EMA decay $T$1, 25k steps, batch size 1024, and about 3 hours of training on a single NVIDIA RTX 4090. Sampling uses explicit Euler integration, and the authors state that a single step with $T$2 suffices for high-quality predictions on control tasks, enabling real-time inference.

The empirical claims are hardware-facing. On the Go1 quadruped, DynaFlow reproduces trotting and bounding at up to 2.0 m/s, executes receding-horizon deployment at 10 Hz, and supports a 450-step, approximately 9 s open-loop sequence traversing a 4 m path in a 1 m corridor without replanning. It also converts a dynamically infeasible 2.54 s retargeted gallop into an executable motion by removing foot penetrations of up to approximately 5 cm and reducing base pitch oscillations from approximately $T$3 to approximately $T$4. On the feasible simulation-rollout dataset, it achieves near-zero SAE comparable to action-supervised SA-Rollout; on the infeasible mocap dataset, it is reported as the only method that simultaneously achieves low SAE and low TRE while remaining trackable on hardware (Lee et al., 24 Sep 2025).

3. DynaFlow and dynamic workflow construction for LLM agents

A distinct usage appears in LLM-based agent systems. "DyFlow: Dynamic Workflow Framework for Agentic Reasoning" states that the framework is also referred to as DynaFlow in some contexts (Wang et al., 30 Sep 2025). It decomposes execution into a trained high-level designer $T$5 and a low-level executor $T$6. At step $T$7, the designer samples a stage subgraph

$T$8

where $T$9 contains the problem, prior plans, intermediate outputs, and errors. Each operator instance has the form $$\boldsymbol{s}_{0:T} = \mathcal{S}(\boldsymbol{a}_{0:T}; s_0).$$0, with a template $$\boldsymbol{s}_{0:T} = \mathcal{S}(\boldsymbol{a}_{0:T}; s_0).$$1, an instruction $$\boldsymbol{s}_{0:T} = \mathcal{S}(\boldsymbol{a}_{0:T}; s_0).$$2, and memory-key references $$\boldsymbol{s}_{0:T} = \mathcal{S}(\boldsymbol{a}_{0:T}; s_0).$$3. Execution proceeds over a shared memory $$\boldsymbol{s}_{0:T} = \mathcal{S}(\boldsymbol{a}_{0:T}; s_0).$$4, and conditional or iterative control arises from repeated replanning rather than from hard-coded graph logic.

The training pipeline combines supervised fine-tuning on successful subgraphs with offline preference optimization via KTO on self-play trajectories. The paper also gives a policy-class argument that static workflows are a subset of DyFlow policies and derives a value-gap bound in terms of Bellman residuals. The implementation uses Phi-4 as executor in the main experiments, DyPlanner initialized from Phi-4 14B as the designer, and GPT-4o-mini for state summarization. Reported training uses LoRA on 2 Nvidia A6000 GPUs, with a 2048-token cutoff for SFT and a 4096-token cutoff for KTO.

On SocialMaze, PubMedQA, MATH, LiveBench, and HumanEval, DyFlow reports 17.18, 72.91, 76.40, 48.67, and 92.07 respectively, with average 61.45. The paper states an average improvement of +8.01 over Vanilla and reports that DyFlow improves across executors including GPT-4o-mini, Phi-4, and GPT-4.1-mini. The ablation “w/o Dynamic Planning” drops average performance to 56.48, which the paper identifies as the largest degradation among the main ablations (Wang et al., 30 Sep 2025).

A related but not identical framework is "(P)rior(D)yna(F)low: A Priori Dynamic Workflow Construction via Multi-Agent Collaboration" (Lin et al., 18 Sep 2025). PriorDynaFlow uses tabular Q-learning to constrain the decision space to top-$$\boldsymbol{s}_{0:T} = \mathcal{S}(\boldsymbol{a}_{0:T}; s_0).$$5 next-agent choices while allowing a priori next-step selection based on task progress. Its update rule is the standard

$$\boldsymbol{s}_{0:T} = \mathcal{S}(\boldsymbol{a}_{0:T}; s_0).$$6

The method includes cold-start initialization, early stopping, and pruning. Reported results show an average improvement of approximately 4.05% over state-of-the-art baselines on HumanEval, MBPP, GSM8K, and MATH, while reducing workflow construction and inference costs to approximately 30.68%–48.31% of those required by existing methods. The paper further reports pass@1 values of approximately 93.90 on HumanEval, 89.40 on MBPP, 96.36 on GSM8K, and 89.10 on MATH for the full system (Lin et al., 18 Sep 2025).

4. Numerical, filtering, and flow-dynamics usages

In "Dynamical Update Maps for Particle Flow with Differential Algebra," DynaFlow denotes DA-based dynamical update maps for particle-flow filtering (Servadio, 2 May 2025). The objective is to replace per-particle pseudo-time ODE integration by a high-order polynomial map built once in Differential Algebra and then evaluated cheaply for each particle. The homotopy family is

$$\boldsymbol{s}_{0:T} = \mathcal{S}(\boldsymbol{a}_{0:T}; s_0).$$7

and the deterministic pseudo-time drift is

$$\boldsymbol{s}_{0:T} = \mathcal{S}(\boldsymbol{a}_{0:T}; s_0).$$8

Prediction and update are represented as Taylor maps,

$$\boldsymbol{s}_{0:T} = \mathcal{S}(\boldsymbol{a}_{0:T}; s_0).$$9

The paper reports more than one order of magnitude speedup over RK7/8 on a toy problem, up to two orders faster at low orders, and about one order of magnitude faster than a 12-core parallelized ODE implementation in CubeSat attitude determination, with nearly identical RMSE traces.

A much earlier usage appears in "Dynamic Mode Decomposition for Large and Streaming Datasets" (Hemati et al., 2014), where the supplied material labels the low-storage streaming DMD formulation as DynaFlow. Here the core reduced operator is

$$\frac{d\boldsymbol{a}_t}{dt} = u_\theta(\boldsymbol{a}_t, t, c),$$0

with incremental updates

$$\frac{d\boldsymbol{a}_t}{dt} = u_\theta(\boldsymbol{a}_t, t, c),$$1

The uncompressed streaming method is mathematically equivalent to batch DMD when the maintained bases span the images of $$\frac{d\boldsymbol{a}_t}{dt} = u_\theta(\boldsymbol{a}_t, t, c),$$2 and $$\frac{d\boldsymbol{a}_t}{dt} = u_\theta(\boldsymbol{a}_t, t, c),$$3 exactly; the compressed variant adds incremental POD projection through $$\frac{d\boldsymbol{a}_t}{dt} = u_\theta(\boldsymbol{a}_t, t, c),$$4 and $$\frac{d\boldsymbol{a}_t}{dt} = u_\theta(\boldsymbol{a}_t, t, c),$$5 to control noise and storage. The paper reports close agreement between batch and streaming DMD on cylinder wake data and gives dominant experimental PIV frequencies such as 0.888 vs. 0.887 Hz, 1.774 vs. 1.737 Hz, and 2.732 vs. 2.664 Hz for batch versus incremental processing.

In network-flow theory, "Dynamic Flows with Adaptive Route Choice" provides another distinct construct that the supplied material calls DynaFlow (Graf et al., 2018). The model uses continuous-time fluid queues, edge cost

$$\frac{d\boldsymbol{a}_t}{dt} = u_\theta(\boldsymbol{a}_t, t, c),$$6

and an instantaneous dynamic equilibrium condition

$$\frac{d\boldsymbol{a}_t}{dt} = u_\theta(\boldsymbol{a}_t, t, c),$$7

The paper proves existence and constructive computation for single-sink networks with right-constant inflows, finite termination for multi-source single-sink networks with bounded finitely lasting inflows, existence for multi-source multi-sink networks under general measurable inflow rates, and also the existence of single-source multi-sink instances in which any IDE flow cycles forever and never clears the network.

A still older applied-fluid-mechanics usage is associated with DYNAFLOW, INC. in "Bubble Dynamics in a Two-Phase Medium" (Jayaprakash et al., 2010). There the name refers to an experimental and modeling program on a spark-generated primary bubble in bubbly water. The study varies discharge voltage, capacitor size, ambient pressure, and electrolysis conditions to control bubble energy and the surrounding microbubble population. The reported central finding is that the presence of small bubbles dampens the growth of the primary bubble and decreases its collapse time; the work frames this as a validation platform for analytical and numerical models of bubbly-media compressibility and damping.

5. Transparent intra-device parallelism through programmable operator scheduling

In "DynaFlow: Transparent and Flexible Intra-Device Parallelism via Programmable Operator Scheduling" (Pan et al., 20 May 2026), DynaFlow is a torch.compile backend and scheduling framework for overlapping operators with different resource profiles on a single device. The motivating problem is the conflict between static sequential programming models and context-sensitive intra-device parallelism strategies such as overlap, splitting, and fusion. The paper’s solution is to decouple the logical model definition from its physical execution schedule.

The frontend exposes graph-partition annotations through SplitFunc, SplitModule, and mark, and a scheduler interface built around split(batch_sizes), get_ready_ops(ubatch_idx), and execute(operators, stream=None, replace_func=None). Programmers subclass OpSchedulerBase and write an async def schedule(self, batch_size: int) routine that can dynamically select splitting thresholds, fused kernels, and stream assignments based on runtime context. This is used to implement representative strategies such as Dual-Batch Overlap for shared-expert MoE and TokenWeave-like all-reduce-plus-RMSNorm fusion.

The backend manages asynchronous control and data flow, dependency tracking, and zero-copy resharding. Static analysis computes per-tensor reference counts and prealloc flags; runtime execution preallocates contiguous merge buffers when a tensor is an input to a future merge point, and producers write directly into the correct slices. The paper states that this eliminates copy overheads associated with naive split/concat patterns. Compatibility with TorchInductor is preserved by compiling each subgraph once into a callable, while CUDA Graphs are retained through per-subgraph and per-micro-batch capture backed by a shared graph pool.

The evaluation spans six systems: vLLM, SGLang, HuggingFace Transformers, Megatron-LM, xDiT, and FastVideo. The headline result is up to a 1.29x throughput improvement. Additional reported results include DBO in vLLM on DeepSeek-V2-Lite with up to 1.14x, TokenWeave-style overlap up to 1.21x in vLLM and 1.22x in Transformers, and Comet-style fused expert-parallel communication up to 1.25x on Qwen2-MoE and 1.27x on Mixtral. The paper also reports that naive “split-everything” scheduling can degrade small or medium workloads to 0.56x–0.35x, which is used to argue for dynamic scheduling rather than static policies (Pan et al., 20 May 2026).

6. Related and derivative uses in autonomous driving, weather, and avatar modeling

Several papers use closely related names or internal components labeled “DynaFlow” while applying the same dynamic-flow intuition to other modalities. In "DynFlowDrive: Flow-Based Dynamic World Modeling for Autonomous Driving" (Liu et al., 20 Mar 2026), the method learns a trajectory-conditioned latent world model with a rectified-flow velocity field. Multi-view observations are encoded into a compact world latent, action conditioning is introduced through concatenated world and trajectory embeddings, and the transition model is trained with a flow-matching loss. A stability-aware multi-mode trajectory selection score uses angular consistency of intermediate velocity vectors,

$$\frac{d\boldsymbol{a}_t}{dt} = u_\theta(\boldsymbol{a}_t, t, c),$$8

combined with reconstruction and trajectory terms. The paper reports no additional inference overhead because the world model is used only during training. On nuScenes, LAW improves from 0.61 m L2 and 0.30% CR to 0.57 m and 0.22% with DynFlowDrive, while the SSR-based variant improves from 0.39 m and 0.15% CR to 0.31 m and 0.11% CR in the configuration with ego-status. On NavSim, DynFlowDrive reports PDMS 88.7, ahead of WoTE at 88.3 and DiffusionDrive at 88.1 (Liu et al., 20 Mar 2026).

In "FlowCast-ODE: Continuous Hourly Weather Forecasting with Dynamic Flow Matching and ODE Integration" (He et al., 18 Sep 2025), the supplied material describes DynaFlow as the combination of dynamic flow matching and ODE-based continuous-time rollout for atmospheric state evolution. The coarse transport path is

$$\frac{d\boldsymbol{a}_t}{dt} = u_\theta(\boldsymbol{a}_t, t, c),$$9

and the model is trained to predict the transport velocity $c$0 under a weighted MSE over variables, levels, and latitudes. Hourly forecasts are then produced by explicit Euler integration,

$c$1

with $c$2 hour. The two-stage training scheme uses 6-hour dynamic flow matching followed by hourly ODE fine-tuning over 6, 12, and 18 hour horizons. The paper reports lower RMSE than baselines for MSLP and Z500 across all lead times, smoother kinetic and internal energy trajectories across assimilation boundaries, a model-size reduction from 54.2M to 45.7M parameters through low-rank AdaLN-Zero, and comparable tropical-cyclone track MAE to the state-of-the-art 0.25° Pangu-Weather model beyond 48 hours (He et al., 18 Sep 2025).

In "Zero-Shot Reconstruction of Animatable 3D Avatars with Cloth Dynamics from a Single Image," DynaFlow is a loss rather than a full framework (Kwon et al., 16 Mar 2026). The model renders an xy map

$c$3

obtains sparse LightGlue correspondences $c$4 with $c$5, and applies

$c$6

The loss is activated only after the midpoint of training and is intended to provide geometry-only motion-direction supervision for cloth dynamics in rendered space. The broader DynaAvatar system reports PSNR 23.74, SSIM 0.960, LPIPS 0.064 on 4D-Dress, and face consistency 0.712 on DNA-Rendering, with the authors attributing qualitative improvements in cloth boundaries and sweeping garment motion to DynaFlow-guided training (Kwon et al., 16 Mar 2026).

Taken together, these derivative usages preserve the same high-level motif: a state transition is supervised or executed through an explicit flow field, transport path, or dynamic alignment signal rather than through static regression or purely photometric matching. This suggests that “DynaFlow” has become a portable label for methodologies that elevate intermediate dynamics to a first-class modeling object.