Text2BFM: Text-to-Executable Motion

• Text2BFM is a framework that converts text into compact behavioral programs within a pretrained BFM's latent space, enhancing compositional motion generation.
• It employs a three-stage pipeline to extract, compress, and generate policy latents, effectively separating semantic planning from physical motion execution.
• The method improves temporal coherence and sampling efficiency over direct pose generation while maintaining physical realism and stability.

Searching arXiv for the cited Text2BFM paper and closely related text-to-motion context. Text2BFM is a text-to-motion framework that does not generate human poses directly. Instead, it generates compact behavioral programs in the latent policy space of a pretrained Behavioral Foundation Model (BFM), and then lets that frozen BFM execute the motion. The method was introduced in "Plan, Don't Pose: Long Composite Motion Generation with Text-Aligned BFM" as the first framework that aligns natural language with pretrained BFMs for text-to-motion generation without relying on heavy end-to-end motion generators (Shvetsov et al., 28 May 2026). Its central premise is that language naturally describes behavioral phases and intentions such as “walk, turn, sit,” whereas pretrained BFMs provide executable motion priors in policy-latent space.

1. Problem formulation and motivating premise

Text2BFM targets a structural weakness of standard text-to-motion systems. Existing methods typically synthesize pose trajectories, motion tokens, or kinematic latents directly from text, which forces a single model to simultaneously perform semantic parsing of the prompt, long-horizon temporal planning, phase ordering and transitions, and low-level physically plausible motion realization (Shvetsov et al., 28 May 2026). The paper argues that this coupling becomes especially brittle for long, compositional prompts such as “walk forward, turn left, punch, kick, then wave,” where the system must preserve the correct order of actions across an extended sequence.

The reported failure modes of pose-first formulations include missing stages, weak compositional consistency, unstable contacts, and poor motion realism. Text2BFM addresses these failures by changing the interface between language and motion generation. Rather than mapping text into framewise joint states, it maps text into a behavioral plan space that is semantically meaningful and executable. The method explicitly treats semantic planning and motion execution as separate problems.

A recurrent misconception is to treat Text2BFM as another latent pose generator. The paper states the opposite: the framework does not generate human poses directly, and its core claim is that the latent policy space of a BFM is a better interface for long-horizon, compositional motion generation because language describes behavior more naturally than frame-by-frame joint configurations (Shvetsov et al., 28 May 2026).

2. Behavioral Foundation Models as the motion interface

The architectural pivot of Text2BFM is the use of a pretrained and frozen Behavioral Foundation Model. In the paper’s formulation, the BFM supplies a latent-conditioned policy for motion execution, and its policy latents become the “language of motion.” The key insight is presented as a simple alignment: language describes behavior, and BFM latents represent executable behavior (Shvetsov et al., 28 May 2026).

This design matters because BFMs encode motion as local behavior commands rather than framewise joint states. That representation is better suited to phase-based prompts and allows the pretrained policy to absorb much of the burden of physical realism. In the paper’s terminology, the compact program stores high-level temporal structure, while the BFM policy serves as an executable motion prior.

Given a motion trajectory $\tau = \{s_t\}_{t=1}^{T}$, the frozen BFM is used to infer a sequence of local policy latents $z_{1:T_z}$ with $T_z = T-1$. The rollout is defined as

$$a_t \sim \pi_{\mathrm{BFM}}(a_t \mid s_t, z_t), \qquad s_{t+1} \sim p_{\mathrm{env}}(s_{t+1} \mid s_t, a_t).$$

To obtain training labels, the method uses the BFM backward map $B$ over a short lookahead window:

$$z^i_t = \operatorname{Proj}_z \left( \frac{1}{H_t} \sum_{k=0}^{H_t-1} B(s^i_{t+1+k}) \right), \qquad H_t = \min(L, T-t).$$

In this construction, each $z_t$ summarizes the future behavior that should unfold from state $s_t$.

A plausible implication is that Text2BFM treats behavior as the primary compositional unit and pose as a downstream consequence of policy execution. That is the conceptual basis for its claim that long-horizon prompting is better handled in policy-latent space than in pose space.

3. Three-stage generation pipeline

Text2BFM is organized as a three-stage pipeline that first extracts policy latents from motion, then compresses them into a shorter behavioral program, and finally generates that compact program from text.

Stage	Representation	Function
A	$z_{1:T_z}$	Extract BFM policy latents from motion
B	$m_{1:T_m}$ with $z_{1:T_z}$0	Compress policy-latent sequence with a text-aligned VBB
C	$z_{1:T_z}$1	Generate compact program from text and decode for BFM rollout

In Stage A, the method derives a full policy-latent trajectory from motion using the frozen BFM and its backward map. This creates training targets in the same latent policy space that the BFM can execute.

In Stage B, Text2BFM introduces a text-aligned variational behavioral bottleneck (VBB) that compresses the full policy-latent sequence into a shorter latent program $z_{1:T_z}$2, where $z_{1:T_z}$3 (Shvetsov et al., 28 May 2026). The encoder defines a Gaussian posterior,

$z_{1:T_z}$4

and a sampled compact program is decoded back into policy latents:

$z_{1:T_z}$5

The function of this bottleneck is not merely compression. It is trained to preserve the information needed to reconstruct executable BFM latents while aligning the representation with text.

In Stage C, the model trains a lightweight conditional generator in the compact space using Transformer-based flow matching. Given a target compact program $z_{1:T_z}$6, it samples noise $z_{1:T_z}$7 and interpolates linearly:

$z_{1:T_z}$8

The flow model $z_{1:T_z}$9 is trained with

$T_z = T-1$0

At inference, the method samples $T_z = T-1$1, solves

$T_z = T-1$2

obtains $T_z = T-1$3, decodes it into policy latents,

$T_z = T-1$4

and rolls out the frozen BFM policy with those latents.

The design principle is explicit: semantic planning happens in the compact behavioral program space $T_z = T-1$5, and motion execution happens in the frozen BFM policy space via decoded policy latents $T_z = T-1$6. Text2BFM therefore never asks the text generator to produce full motion directly (Shvetsov et al., 28 May 2026).

4. Bottleneck objective and semantic alignment

The VBB is trained by combining reconstruction, KL regularization, and semantic alignment. The reconstruction objective includes both latent reconstruction and a policy-level term:

$T_z = T-1$7

The latent space is regularized against a standard Gaussian prior:

$T_z = T-1$8

To make the bottleneck language-discriminative, motion program tokens and text tokens are projected into a shared normalized space,

$T_z = T-1$9

and a bidirectional contrastive loss is applied:

$$a_t \sim \pi_{\mathrm{BFM}}(a_t \mid s_t, z_t), \qquad s_{t+1} \sim p_{\mathrm{env}}(s_{t+1} \mid s_t, a_t).$$0

The full bottleneck objective is

$$a_t \sim \pi_{\mathrm{BFM}}(a_t \mid s_t, z_t), \qquad s_{t+1} \sim p_{\mathrm{env}}(s_{t+1} \mid s_t, a_t).$$1

The paper also gives a rate–distortion interpretation of this construction: the bottleneck preserves executable structure while forcing the representation to become compact and semantically aligned (Shvetsov et al., 28 May 2026). In that reading, semantic alignment is not an auxiliary convenience; it is part of the compression mechanism that makes the latent program useful for language-conditioned planning.

A second misconception is that compression alone explains the method’s behavior. The ablations indicate otherwise: average pooling performs poorly because it destroys temporal ordering, and the full text-aligned VBB is best, showing that both compression and language alignment matter.

5. Reported performance, compositional evaluation, and ablations

The paper reports several advantages for Text2BFM. Because generation occurs in the compact latent program space rather than in pose space or long token sequences, sampling is cheaper. The flow model uses only 16 Euler steps, compared with a diffusion baseline using 50 steps in the same latent space (Shvetsov et al., 28 May 2026). The frozen BFM is also claimed to improve physical grounding, temporal coherence, and contact-rich behavior relative to direct pose prediction.

On HumanML3D and KIT-ML, Text2BFM achieves the best retrieval-style metrics: highest R-Precision and best MultiModal Distance on both benchmarks (Shvetsov et al., 28 May 2026). The paper notes, however, that FID is not always best because the frozen BFM introduces a domain bias: generated motions can deviate from the real-motion distribution even when they are semantically strong and executable. This caveat is important because it separates semantic fidelity and executability from distribution matching.

For longer prompts with 3 or 4 stages, the evaluation uses Order Accuracy, MM-Dist, and Transition smoothness. The paper introduces a compositional variant, Text2BFM-Compose, that generates one compact program per clause and concatenates decoded BFM latents with overlap blending:

$$a_t \sim \pi_{\mathrm{BFM}}(a_t \mid s_t, z_t), \qquad s_{t+1} \sim p_{\mathrm{env}}(s_{t+1} \mid s_t, a_t).$$2

with overlap blending

$$a_t \sim \pi_{\mathrm{BFM}}(a_t \mid s_t, z_t), \qquad s_{t+1} \sim p_{\mathrm{env}}(s_{t+1} \mid s_t, a_t).$$3

For 3-stage prompts, Order Acc. improves from 0.395 for Text2BFM to 0.671 for Text2BFM-Compose. For 4-stage prompts, it improves from 0.322 to 0.509 (Shvetsov et al., 28 May 2026). These results are presented as evidence that modular behavioral programs are better for long-horizon composition.

The ablation suite isolates several design effects. Comparisons include average pooling, no compression, VBB without semantic loss, and the full text-aligned VBB. The paper also studies $$a_t \sim \pi_{\mathrm{BFM}}(a_t \mid s_t, z_t), \qquad s_{t+1} \sim p_{\mathrm{env}}(s_{t+1} \mid s_t, a_t).$$4, $$a_t \sim \pi_{\mathrm{BFM}}(a_t \mid s_t, z_t), \qquad s_{t+1} \sim p_{\mathrm{env}}(s_{t+1} \mid s_t, a_t).$$5, and $$a_t \sim \pi_{\mathrm{BFM}}(a_t \mid s_t, z_t), \qquad s_{t+1} \sim p_{\mathrm{env}}(s_{t+1} \mid s_t, a_t).$$6 compression, reporting that moderate compression preserves latent reconstruction and action similarity well, while very aggressive compression degrades policy fidelity. In the learned behavioral latent space, flow matching yields better FID, better MultiModal Distance, and far fewer sampling steps, whereas diffusion gives slightly better R-Precision. The method chooses flow matching for efficiency.

6. Limitations, scope, and relation to adjacent text-to-motion work

Text2BFM inherits the morphology, action space, simulator dynamics, and bias of the pretrained BFM (Shvetsov et al., 28 May 2026). If a requested motion lies outside the BFM latent space, generation can fail. The paper also states that comparisons are not perfectly equal-data because the BFM was pretrained on a different dataset. Rare motions, acrobatics, and object interactions remain challenging, and long compositions with 4 stages are still difficult.

These limitations constrain how the method should be interpreted. The framework is not a universal language-to-motion engine; it is a language-to-executable-behavior planner whose capabilities are bounded by the behavioral prior it uses. A plausible implication is that Text2BFM trades some openness of output space for stability and executability.

In the broader text-to-motion landscape, related work has argued that natural-language prompts often imply latent intent rather than explicit actions. TAAT, for example, reframes the task from action-text-to-motion to arbitrary-text-to-motion and emphasizes semantic ambiguity and one-to-many mappings for scene texts (Wang et al., 2024). This suggests a broader research trend: moving away from direct text-to-pose regression toward intermediate behavioral abstractions. Within that trajectory, Text2BFM is distinctive in making the intermediate representation an executable BFM latent program rather than an action label sequence or a direct motion token stream.

The paper’s one-sentence summary captures its design succinctly: Text2BFM turns text-to-motion into text-to-executable-behavior planning, using a compact text-aligned latent program to describe the motion and a frozen BFM to perform the actual motion (Shvetsov et al., 28 May 2026).