TeNet: Text-to-Network for Compact Policy Synthesis

1 Introduction

Recent advances in large language models (LLMs), such as GPT [Brown et al., 2020] and LLaMA [Touvron et al., 2023], have demonstrated that natural language can act as a powerful and flexible interface across a wide range of domains. In robotics, this has led to growing interest in language-conditioned control, where robots are guided by natural-language instructions, often alongside perceptual inputs. Prominent examples include vision-language-action

(VLA) systems such as PaLM-E [Driess et al., 2023], SayCan [Brohan et al., 2023], RT-2 [Zitkovich et al., 2023], OpenVLA [Kim et al., 2025], and OCTO [Team et al., 2024]. These systems highlight how expressive language can be for specifying complex robotic behaviors. However, this expressiveness often comes at the cost of scale. Many recent approaches to language-conditioned control rely on large end-to-end architectures, which can be computationally expensive and difficult to deploy in high-frequency control loops or on robots with limited onboard compute.

At the other end of the spectrum are compact sequence models such as Decision Transformers (DT) [Chen et al., 2021] and Prompt-DT [Xu et al., 2022], which prioritize efficiency and ease of deployment in offline reinforcement learning. However, these models do not naturally incorporate language: instead, they rely on trajectory prompts or taskspecific demonstrations to distinguish tasks, often requiring demonstrations even at test time and degrading as task diversity increases. This leaves a clear gap between expressive language-conditioned systems and compact policies that are efficient but are not language-enabled.

Several works attempt to bridge this gap by using language indirectly. Code-as-Policies [Liang et al., 2023] translates instructions into robot API calls, while Code-asRewards [Venuto et al., 2024] maps task descriptions into reward functions for reinforcement learning. Although effective in specific settings, these methods depend on predefined interfaces or accurate simulators, limiting their applicability to real-world robotics.

In this work, we ask a simpler question: can language itself be used as a direct conditioning signal for policy instantiation? Rather than executing a large language model inside the control loop, we use it once-at policy instantiation-through a hypernetwork [Ha et al., 2016]. We introduce TeNet (Text-to-Network), a framework that conditions a hypernetwork on LLM-derived text embeddings to generate compact, task-specific policies. 1 The resulting controller operates solely on low-dimensional state inputs, requires no demonstrations at inference time, and can run at high control frequencies on resource-constrained robots.

While direct text-to-policy instantiation is effective, we find that performance improves when language is grounded in behavior. By aligning language representations with expert trajectories during training, task descriptions capture not only linguistic intent but also behavioral semantics, leading to stronger generalization in multi-task and meta-learning settings. Importantly, grounding is used only during training: at inference, policies are instantiated from text alone.

1 Project page, code, and supplementary materials are available at: https://sites.google.com/view/tenet-policy-synthesis.

This paper takes a first step toward utilizing large robotic foundation models for resource-constrained robots through language-enabled hypernetworks for compact policy synthesis. While this could be applied to VLAs in the future, our first steps focus on low-dimensional, trajectory-based domains (Mujoco and Meta-World), isolating the role of language in policy instantiation without addressing perception.

In summary, our contributions are:

• Text-to-Network Policy Generation. We introduce TeNet, a framework that conditions a hypernetwork on LLM text embeddings to synthesize compact, taskspecific robot policies suitable for real-time deployment.
• Grounding Language in Behavior. We show that aligning language with expert trajectories during training enriches linguistic representations with behavioral semantics and improves generalization in multi-task and meta-learning settings.
• Empirical Insights into a New Paradigm. We provide an extensive study on Mujoco and Meta-World benchmarks, highlighting both the promise and limitations of language-enabled hypernetworks and outlining paths toward future vision-grounded extensions.

2 RelatedWork

Language-Conditioned Control in Robotics. Large language models (LLMs) have recently been integrated into robotic systems to enable natural language instruction following and high-level planning. Early approaches such as SayCan [Brohan et al., 2023] and PaLM-E [Driess et al., 2023] leverage pretrained LLMs to map language into symbolic plans or action primitives executed by low-level controllers. These methods exploit LLMs' world knowledge but typically operate at a goal or planning level rather than synthesizing executable control policies.

Other works connect language and control indirectly. Code-as-Policies [Liang et al., 2023] translates instructions into robot API calls, while Code-as-Rewards [Venuto et al., 2024] maps task descriptions into reward functions for reinforcement learning. SayTap [Tang et al., 2023] similarly maps language into structured locomotion patterns. While effective in constrained settings, these approaches rely on predefined interfaces or accurate simulators, limiting their generality. More recent vision-language-action systems, such as RT-2 [Zitkovich et al., 2023], OpenVLA [Kim et al., 2025], and OCTO [Team et al., 2024], integrate language and perception in large end-to-end models, but their computational demands hinder deployment in resource-constrained or highfrequency control settings.

Several works also explore grounding language in behavior through representation learning. For example, CLASP [Rana et al., 2023] learns joint language-state-action embeddings via contrastive objectives, focusing on representation pretraining rather than policy synthesis. In contrast, our use of alignment is auxiliary: language grounding serves to stabilize text-conditioned policy generation rather than constituting the primary modeling objective.

Compact Sequence Models for Policy Learning. A separate line of research explores compact sequence models as policies for reinforcement learning. The Decision Transformer (DT) [Chen et al., 2021] formulates offline RL as conditional sequence modeling, generating actions autoregressively given states and return-to-go. While effective in singletask settings, DT lacks an explicit mechanism for task identification and therefore struggles in multi-task or meta-learning regimes.

Extensions such as Prompt-DT [Xu et al., 2022] and MetaDT [Wang et al., 2024] introduce task-conditioning via trajectory prompts, improving generalization at the cost of requiring demonstrations at inference time. Diffusion-based approaches, including MTDiff [He et al., 2023] and MetaDiffuser [Ni et al., 2023], similarly condition on trajectories or task contexts to generalize across tasks. Although these methods demonstrate strong performance, their reliance on prompt trajectories limits scalability when demonstrations are unavailable or expensive.

In parallel, visuomotor diffusion policies such as Diffusion Policy [Chi et al., 2025] generate actions directly from images and have shown impressive real-world results. These approaches differ fundamentally from the low-dimensional, state-based settings we consider. We therefore focus on DTbased baselines to maintain architectural comparability and isolate the role of language-conditioned policy instantiation.

Overall, compact sequence models demonstrate that lightweight architectures can scale to multi-task RL, but their dependence on trajectory prompts and lack of direct language grounding constrain their applicability as instructionfollowing agents.

Hypernetworks and Policy Generation. Hypernetworks [Ha et al., 2016] generate the parameters of another network and have been widely explored for rapid specialization and meta-learning in reinforcement learning [Beck et al., 2023]. Prior work conditions hypernetworks on a variety of signals, including structured task embeddings [RezaeiShoshtari et al., 2023; Ren et al., 2025], demonstration trajectories [Hegde et al., 2024; Liang et al., 2024], behavior descriptors or archives [Hegde et al., 2023], robot morphology [Xiong et al., 2024], or visual observations [Gklezakos et al., 2022].

In parallel, language-conditioned hypernetworks have been studied in NLP to generate adapter or LoRA weights from task descriptions [Ye and Ren, 2021; Mahabadi et al., 2021; Lv et al., 2024; Charakorn et al., 2025]. These methods focus on adapting large language models rather than synthesizing control policies.

Across these domains, existing approaches either rely on structured task descriptors, demonstrations, morphology signals, or use language only to adapt large models. None directly combine LLM-based text encoders with hypernetworks to synthesize compact, task-specific robot control policies.

Summary. Prior work has explored language-conditioned planning, compact sequence models, and hypernetworkbased policy generation. However, no existing approach directly instantiates executable robot policies from natural language via a shared hypernetwork. Our work fills this gap by using language as a conditioning signal for compact policy synthesis, grounded in behavior during training and executable without demonstrations at inference time.

3 Problem Statement

Language-Augmented MDP (LA-MDP). We model a single task as a Language-Augmented MDP

which extends a standard MDP by including a language descriptor. The first six elements (S,A, P,R, µ,H) are the standard MDP components: S is the state space, A the action space, P(s′ | s, a) the transition dynamics, R(s, a) the reward function, µ the initial state distribution, and H the horizon. The additional component L ∈ ∆(L) is a language descriptor, i.e., a probability distribution over natural-language strings in the space L. Each task is associated with its own descriptor distribution L, which generates natural-language paraphrases (e.g., "move forward" vs. "go straight") of the same underlying dynamics P and reward function R. Thus, the LA-MDP can be viewed as a standard MDP augmented with a generative source of equivalent task descriptions. A policy π(a | s) induces a trajectory distribution in ˜M, and its performance is

with the task-optimal policy π∗ = argmaxπ∈Π J(π).

Multi-task LA-MDP. We consider a distribution over tasks, where each task τ ∈ T is an LA-MDP

Tasks may differ in Sτ , Pτ , Rτ , µτ and Lτ , while sharing the action space A. The multi-task objective is to learn a single policy that maximizes expected return across tasks: π∗ = argmaxπ∈Π Eτ∼p(T )[Jτ (π)].

Offline setting. No online interaction is permitted. The learner receives a static dataset collected from training tasks Ttrain, each modeled as an LA-MDP

where Xτ = {ξ (k) τ }Kk=1 is a set of expert trajectories ξ (k) τ = (s0, a0, r0, . . . , sH), and Dτ = {d(m) τ }Mm=1 are i.i.d. descriptions sampled from the language descriptor, d(m) τ ∼ Lτ .

Multi-task learning. The learner is trained on demonstrations from a set of tasks Ttrain. The objective is to learn a single model that approximates π∗ τ for all τ ∈ Ttrain, exploiting shared structure across tasks instead of training disjoint policies.

Meta-learning. The learner is trained on a collection of tasks Ttrain with the objective of generalizing to previously unseen tasks τ ∈ Ttest. The challenge is to acquire transferable structure from Ttrain that enables rapid policy instantiation for new tasks without further environment interaction.

Few-shot adaptation (baselines). A common meta-RL strategy is to provide a small number of expert trajectories from the unseen task as adaptation data (few-shot setting). Prompt Decision Transformers (Prompt-DT) implement this by using short expert rollouts (prompt trajectories) as testtime task identifiers.

Language-based instantiation (ours). In contrast Prompt-DT, we do not rely on prompt trajectories; instead we leverage natural-language descriptions sampled from Lτ to instantiate policies for τ ∈ Ttest, requiring the learner to ground language into behavior.

4 Method

Our framework, TeNet (Text-to-Network), synthesizes compact, task-specific robot policies directly from natural language descriptions by conditioning a hypernetwork on language embeddings. At training time (Figure 1, top), the model receives task descriptions and expert demonstrations. Task descriptions are first encoded into text embeddings. Expert demonstrations supervise the policy through an imitation loss. In the grounded variant, we additionally introduce a trajectory encoder, and align its embeddings with the text embeddings (i.e., language grounding), thereby enriching the language representation with behavioral semantics. At inference time (Figure 1, bottom), a new task description is passed through the text encoder, projected to the appropriate embedding space, and fed into the hypernetwork to generate a policy that can be executed without further demonstrations.

We present two variants of our approach: Direct TeNet, which conditions the hypernetwork solely on text embeddings, and Grounded TeNet, which aligns text embeddings with trajectory embeddings during training to capture behavioral semantics and improve generalization.

4.1 Direct TeNet

In the Direct TeNet variant, policies are instantiated directly from task descriptions without trajectory grounding. Given a description d ∈ L, the text encoder ftext produces an embedding zd = ftext(d) ∈ Rdz . A projection network g maps zd into the conditioning space of the hypernetwork: ˜ zd = g(zd). The hypernetwork h then generates the parameters θπ of a task-specific policy network πθπ

Training relies on expert demonstrations ξτ = {(st, at)}Ht=0 from task τ. The policy is supervised by behavior cloning (imitation learning)

Thus, Direct TeNet provides a simple mechanism for mapping language directly into executable policies through the hypernetwork.

4.2 Grounded TeNet

Direct TeNet instantiates policies solely from projected text embeddings (Section 4.1). To better capture behavioral semantics, Grounded TeNet augments training with additional grounding objectives that align text and trajectory embeddings. We emphasize that grounding is not the primary conceptual contribution of TeNet: it is an auxiliary mechanism that stabilizes and enriches the text embeddings, while the core novelty lies in generating executable policy parameters directly from natural language.

Given an expert trajectory ξ = {(st, at, rt, st+1)}Ht=0 , the trajectory encoder ftraj produces an embedding zξ = ftraj(ξ). Both zξ and the projected text embedding ˜ zd are mapped into a shared space, and a grounding loss Lground is applied. We explore two variants:

Direct alignment (MSE). A simple strategy is to directly minimize the squared distance between projected text and trajectory embeddings Lalign = E(d,ξ) [∥˜ zd - zξ∥22 ]. This objective enforces absolute closeness of paired embeddings in the shared space.

Contrastive alignment. Let sim(·, ·) denote cosine similarity and β > 0 a temperature parameter. For each update, we consider a finite candidate set of trajectory embeddings Cξ and a finite candidate set of text embeddings Cd that provide negatives for the contrastive normalization.

(i) Text-trajectory contrastive (symmetric). For paired (˜ zd, zξ), we align text to trajectory and trajectory to text with a symmetric InfoNCE

(ii) Text-text contrastive. Task descriptions can be structurally similar (e.g., differing only in goal parameters), which may collapse text embeddings. To encourage descriptionlevel discrimination, we add

The final contrastive objective is Lcontrastive = Ltext-traj + Ltext-text .

Summary. The total training loss combines imitation learning with grounding: L = LBC+λg Lground, where Lground may include Lalign or Lcontrastive, and λg balances their contribution. At inference time, no trajectories are required - the policy is instantiated from text alone. Grounding is used only during training to shape the representation.

5 Experiments

We conduct an extensive empirical study to evaluate TeNet and to provide insights into the design and behavior of language-enabled hypernetworks. Our experiments are performed on Mujoco control benchmarks (HalfCheetah-Vel, HalfCheetah-Dir, Ant-Dir) [Todorov et al., 2012] and MetaWorld manipulation benchmarks (ML1 Pick-Place, MT10, MT50) [Yu et al., 2020], covering both multi-task and metalearning settings.

Beyond reporting standard performance, our goal is to systematically answer a series of questions about when and why TeNet is effective, how grounding influences policy quality, and how design choices affect performance. This section is therefore organized around these questions, with results interleaved with analysis.

5.1 Experimental Setup

Benchmarks. We evaluate on Mujoco locomotion (HalfCheetah-Dir, HalfCheetah-Vel, Ant-Dir) and MetaWorld manipulation (ML1 Pick-Place, MT10, MT50), spanning multi-task and meta-learning regimes. Full task definitions, state/action spaces, and splits are provided in the supplementary materials.

Models. We compare DT [Chen et al., 2021], PromptDT [Xu et al., 2022], and three TeNet variants: TeNet (direct, no grounding), TeNet-MSE (MSE grounding), and TeNetContrast (contrastive grounding). Implementation details, Prompt-DT size variants, and the Prompt-DT+Hypernetwork modification are provided in the supplementary materials.

Metrics & protocol. We report episodic return on Mujoco and success rate on Meta-World, plus controller size and control frequency for deployability. Results are averaged over 3 seeds; each task is evaluated with 50 rollouts.

Defaults. Unless stated otherwise: the text encoder is Llama-3 8B (frozen), the trajectory encoder is Prompt-DT (used only for grounded variants), and TeNet uses a small MLP hypernetwork to instantiate a ∼40K-parameter policy. Training is strictly offline.

5.2 Results

Figure 2 summarizes performance across all six benchmarks, with a shared legend shown on top.

Several general trends are clear. First, DT is consistently the weakest model across all domains, confirming that a compact sequence model without explicit task signals is not suitable for multi-task or meta-learning. Both Prompt-DT and TeNet address this limitation by providing task signals, but they do so in fundamentally different ways: Prompt-DT relies on short expert rollouts (prompt trajectories) as identifiers, while TeNet derives task signals directly from natural language descriptions. This text-based conditioning avoids the need for demonstrations at test time, making TeNet more scalable and practical, as it removes the requirement for taskspecific trajectory prompts.

Second, when comparing TeNet variants (more specifically TeNet-Contrast) against Prompt-DT, we observe consistent advantages. TeNet-Contrast outperforms Prompt-DT in HalfCheetah-Dir and Ant-Dir, matches it in HalfCheetahVel, and is slightly worse in ML1 Pick-Place (which we analyze further in Section 5.2). Most strikingly, in MT10 and MT50 TeNet-Contrast hugely outperforms Prompt-DT. This large gap prompted us to investigate why Prompt-DT struggles in multi-task benchmarks and to identify which design choices in TeNet are responsible for its robust performance. We return to this question later in this section.

Can We Directly Build Policies from Language, or Do We Need Grounding?

The results in Figure 2 reveal a mixed picture. Direct TeNet already provides a substantial improvement over DT across all benchmarks, confirming that natural language is an effective source of task signals. However, its relative performance compared to Prompt-DT depends critically on the setting. On meta-learning benchmarks (HalfCheetah-Vel, Ant-Dir, ML1 Pick-Place), Direct TeNet falls behind Prompt-DT, suggesting that text encodings, while informative, do not generalize to unseen tasks as effectively as trajectory prompts. In contrast, on multi-task benchmarks (MT10, MT50), Direct TeNet consistently outperforms Prompt-DT. These results indicate that direct language-to-policy instantiation is viable and scales well in diverse multi-task regimes, but that grounding is required for robust generalization in meta-learning settings where the agent must extrapolate to unseen tasks.

How Should We Ground Language in Behavior?

The results in Figure 2 show that grounded TeNet, regardless of the chosen strategy, consistently outperforms Direct TeNet on the meta-learning benchmarks (HalfCheetah-Vel, Ant-Dir, ML1 Pick-Place). This confirms that additional grounding is necessary for robust generalization to unseen tasks.

Among the grounding methods, contrastive alignment generally performs better than direct alignment (MSE). The reason is that MSE enforces absolute closeness between paired text and trajectory embeddings, but provides no mechanism to separate embeddings from different tasks. As a result, embeddings from similar descriptions may collapse, limiting discriminability. In contrast, contrastive objectives simultaneously pull together matching text-trajectory pairs and push apart non-matching pairs, yielding a representation space that is both semantically aligned and better separated across tasks. This improved structure in the shared embedding space translates into stronger policy generalization.

Why Does Prompt-DT Struggle in MT10 and MT50?

The Meta-World multi-task benchmarks (MT10 and MT50) contain tasks that are far more distinct than those in Mujoco (e.g., pick-place versus drawer-open, compared to velocity or direction variations). This task diversity poses a major challenge for Prompt-DT. Furthermore, as the number of tasks increases, the success rate of Prompt-DT drops (from 0.73 on MT10 to 0.61 on MT50; see Figure 2). To better understand this gap, we conduct two follow-up experiments.

First, we ask whether the failure is simply due to insufficient model capacity. If trajectory prompts are expressive enough, then increasing the size of Prompt-DT (from small to medium to large) should yield meaningful improvements. Table 1 shows that this is not the case: larger Prompt-DT models achieve only marginal gains, indicating that the issue lies deeper than model capacity.

Second, we test whether the limitation arises from the lack of task-specific parameterization. In this variant, Prompt-DTHN serves as a trajectory-conditioned hypernetwork baseline, where the prompt trajectory is encoded and used to generate policy weights via a shared hypernetwork. To this end, we add a hypernetwork on top of Prompt-DT to generate policy parameters conditioned on task signals. Table 1 indicates that this modification yields a substantial boost in success rates on both MT10 and MT50. The comparison demonstrates that generating task-specific parameters is crucial when dealing with distinct multi-task benchmarks. TeNet naturally benefits from this principle while also being language-enabled, removing the reliance on demonstration prompts.

How Fast Are TeNet Policies?

Beyond task success, deployability depends critically on the efficiency of the policy: controllers must be compact enough to fit on resource-constrained robots, and fast enough to support high-frequency control loops. Table 1 reports both the number of parameters (controller size) and the control frequency that the method can sustain.

The results highlight a stark contrast. Prompt-DT variants range from 1M to 39M parameters, with control frequencies between 190 Hz and 600 Hz. Adding a hypernetwork further increases model size to 5M parameters, while improving task success, but the resulting policies remain limited to the subkHz regime. In contrast, TeNet policies contain only 40K parameters and sustain control rates of over 9 kHz, more than an order of magnitude faster than all Prompt-DT baselines.

Does Scaling the Number of Training Tasks Improve TeNet's Generalization?

In Section 5.2 we noted that TeNet-Contrast slightly underperforms Prompt-DT on ML1 Pick-Place. To investigate further, we study how scaling the number of training tasks affects generalization. Specifically, we vary the number of ML1

tasks available during training (50, 100, 200, 400, 800, 1600), while always holding out 10% of tasks for testing. The results are shown in Figure 3.

Performance improves steadily from a success rate of 0.80 with 50 tasks to 0.99 with 1600 tasks. This indicates that scaling the diversity of training tasks substantially enhances TeNet's ability to generalize. One possible factor is that as the number of training tasks grows, the domain gap between train and test tasks decreases, making generalization easier. In any case, reaching a success rate of 99%with 1600 training tasks shows that TeNet can fully solve ML1 Pick-Place when provided with sufficient data. These results highlight both the promise and the data demands of language-enabled hypernetworks: like foundation models in other domains, TeNet benefits strongly from scale, even if it is data hungry.

How Robust Is TeNet to Paraphrased Task Descriptions?

Since language is used only once to instantiate a policy, a key question is how robust TeNet is to variations in how a task is described. In practice, semantically identical instructions may differ substantially in wording, syntax, or length. We therefore evaluate TeNet's sensitivity to paraphrasing by training on canonical task descriptions and testing on increasingly complex paraphrases. We conduct this study on MT10, comparing two text encoders-LLaMA [Touvron et al., 2023] and BERT [Devlin et al., 2019]. Models are trained using 10 canonical (Level 0) descriptions per task and evaluated on unseen paraphrases of growing linguistic complexity (Level 1 and Level 2), which differ syntactically but describe the same underlying task.

Table 2 shows that both encoders achieve similar performance on canonical descriptions, indicating that TeNet can reliably instantiate policies from simple instructions regardless of the encoder choice. However, as paraphrasing complexity increases, performance degrades for both models, with a larger drop observed for BERT. This gap suggests that richer language models produce more stable and semantically consistent embeddings under linguistic variation, leading to more reliable policy instantiation from natural language.

Qualitative Evaluation: Velocity Following in HalfCheetah-Vel

HalfCheetah-Vel evaluates velocity tracking by rewarding policies for matching a target forward speed, r = -|vcurrent - vtarget|, so episodic return directly reflects tracking accuracy. Target velocities are defined on a grid from 0.075 to 3.0m/s. Models are trained on a subset of this grid and evaluated on unseen target velocities {0.225, 0.6, 1.2, 1.8, 2.025}m/s, as well as an out-ofdistribution instruction at 3.5m/s. Policies are instantiated from commands such as "Move forward with target velocity X m/s." and evaluated over 50 rollouts. Achieved velocity is computed as the average speed over the final 20 steps.

Figure 4 compares achieved versus instructed velocity for TeNet-Contrast and Prompt-DT. TeNet-Contrast closely tracks commanded speeds across all unseen test velocities, indicating smooth generalization over the continuous velocity range. For the extrapolated 3.5m/s instruction, both methods saturate near ∼ 3m/s, reflecting the limits of the HalfCheetah dynamics rather than a failure of instruction following.

5.3 Summary of Empirical Insights

Our results show that direct text-to-policy instantiation is viable, but that grounding language in behavior is essential for robust generalization. Across meta-learning benchmarks, grounded TeNet variants consistently outperform Direct TeNet, with contrastive alignment providing stronger task discrimination than direct (MSE) alignment.

We further find that task-specific parameterization is critical in diverse multi-task settings. Prompt-DT degrades sharply on MT10 and MT50, and increasing model capacity alone does not resolve this issue. In contrast, explicitly generating task-conditioned parameters-most effectively via language-conditioned hypernetworks-enables TeNet to scale to large and heterogeneous task sets.

Despite this added flexibility, TeNet remains highly efficient. Instantiated policies contain only ∼40K parameters and sustain control rates above 9 kHz, exceeding PromptDT baselines by more than an order of magnitude. TeNet also exhibits robustness to linguistic variation: performance degrades gracefully under increasingly complex paraphrases, with larger language models such as LLaMA producing more stable policy instantiations than BERT. Qualitative evaluation on HalfCheetah-Vel further confirms that text-instantiated policies accurately follow commanded velocities and generalize smoothly across unseen targets.

Additional ablation studies-analyzing the text-text contrastive term, grounded-flow, fine-tuning, and multiple task descriptions-are provided in the supplementary materials.

Overall, these findings indicate that compact, languageenabled hypernetworks can close much of the gap between lightweight sequence models and large language-conditioned systems within state-based, offline imitation settings. Extending TeNet to real-world robotics will require addressing noisy demonstrations, multimodal (vision-language) grounding, and reinforcement fine-tuning, which we leave as directions for future work.

6 Conclusion

We introduced TeNet, a text-to-network framework for instantiating compact, task-specific policies directly from natural language. By combining LLM-based text embeddings, trajectory grounding, and hypernetwork-based parameter generation, TeNet produces lightweight controllers that generalize across tasks without requiring demonstrations at inference time. Experiments on Mujoco and MetaWorld benchmarks show that TeNet outperforms Prompt-DT in multi-task settings, achieves competitive performance in meta-learning, and supports control frequencies above 9 kHz. Together, these results highlight language-enabled hypernetworks as a promising direction for scalable, efficient, and deployable robot learning.

Acknowledgements

This work was supported by the project TeNet: Text-toNetwork for Fast and Energy-Efficient Robot Control, file number NGF.1609.241.015, under the research programme National Growth Fund AiNed XS Europe 24-2, financed by the Dutch Research Council (NWO).