Instruction-Guided Routing (IGR)

Updated 1 January 2026

Instruction-Guided Routing (IGR) is a framework that converts external natural language instructions into vector representations to steer module selection and computational pathways.
IGR architectures enable flexible routing across robotics, generative modeling, and network optimization by adapting task-specific cost mapping and expert selection methods.
Empirical studies reveal that IGR improves efficiency and performance, such as higher SPL in path planning and enhanced compositional control in multimodal systems.

Instruction-Guided Routing (IGR) encompasses a family of architectures and algorithms in which external instructions, typically expressed in natural language, directly condition the selection and coordination of pathways, modules, or experts within complex computational systems. IGR mechanisms translate instructions into actionable internal representations, enabling task-adaptive allocation of computational resources, constraint-aware planning, modality-specific processing, or model selection. The paradigm is expressed across robotics, generative modeling, large-model routing, and network optimization domains with a shared goal: externalizing control logic from fixed system design to flexible, instruction-mediated routing.

1. Core Concepts and Modalities

Instruction-Guided Routing frameworks operate at distinct abstraction levels but share several defining characteristics:

Instruction Embedding/Encoding: Transform external, often natural-language, instructions into vector or token representations suitable for downstream controllers (via LLMs, embedding models, or bespoke encoders).
Conditioned Routing Policy: Use these representations to guide selection among system modules—e.g., sampling roadmap nodes, gating expert subnets, pruning tokens, or choosing entire models.
Explicit Modularity: Decouple control/routing decision-making from core module instantiation, often enabling plug-and-play extensibility.
Alignment with Task or Intent: Translate explicit operator preferences, semantic constraints, or required capabilities into internal selection criteria that directly shape computational outcomes.

This approach spans domains:

In robotics/path planning, it modulates the construction of search structures (e.g., cost-biased PRM graphs based on linguistic constraints) (Bao et al., 23 Feb 2025).
In generative modeling and multi-task learning, it governs expert selection in mixtures-of-experts or adapter-driven architectures (Xiao et al., 25 Dec 2025).
In multimodal, vision-language-action agents, it controls token flow and computational sparseness via instruction-modulated FiLM/pruning (Li et al., 28 Aug 2025).
In LLM ensembles or multi-model systems, it underpins model selection based on explicit model capability summaries and downstream task fit (Zhang et al., 24 Feb 2025).
In communication networks, it enables source/switch routing decisions to enforce externally specified service-level objectives (Bramas et al., 2023).

2. IGR in Path and Graph-Based Planning

The IG-PRM framework exemplifies IGR in robotic path planning by integrating natural-language instructions as a first-class signal throughout the planning pipeline (Bao et al., 23 Feb 2025). The key stages and mechanisms are:

Instruction Embedding: ℓ (e.g., “aim for wider paths”) is embedded via LLMs (e.g., Azure’s text-embedding models → random-projected, L2-normalized 128D embedding).
Instruction-Guided Cost Mapping: Occupancy map o and embedding e are stacked and processed through a U-Net (VGG-16 backbone) to obtain a dense cost map c(x) = g(o, e)(x). Costs reflect instruction semantics—e.g., high cost for traversing narrow passages under "wider" instructions.
Graph Construction:
- Node sampling is biased via acceptance probability ∝ 1–c(x), concentrating nodes in low-cost (instruction-preferred) regions.
- Edge weights are defined as the line integral of c along straight segments, approximated via discrete summing.
Path Search: The constructed roadmap (G = (V, E, w)) is searched with Dijkstra/A* to yield paths minimizing integrated instruction-guided cost.

Empirical results show IG-PRM yields 10–20% higher SPL and 20–50% lower DTW than standard PRMs, while retaining modularity. Notably, the mechanism changes graph topology such that regions favored by the instruction are denser and provide more diverse low-cost routes, demonstrating instruction-to-topology coupling.

3. IGR for Modular Expert and Token Routing

Several contemporary architectures employ IGR for expert selection, token selection, or both:

Global Instruction-Guided Council Routing: InstructMoLE utilizes a Mixture of Low-rank Experts (MoLE), in which a global instruction-derived routing signal Z_global is computed from a fused T5/CLIP embedding and used to select a sparse 'council' of experts for each instance at every network layer (Xiao et al., 25 Dec 2025). This council is applied uniformly per instance/layer, promoting spatial and semantic coherence. Gating weights are learned via a top-k softmax over expert scores G_l(Z_global) for each layer l, with the council/weight tuple broadcast to all tokens.
Output-Space Orthogonality Controls: An explicit loss penalizes cosine similarity between expert outputs to enforce specialization and prevent collapse. This is essential for preserving the expressivity and compositional control advantages of IGR in high-dimensional generative architectures.

Empirical analyses, including ablations, show instruction-guided council routing outperforms both per-token MoE (which causes spatial fragmentation) and coarse global selection. IGR paired with orthogonality yields state-of-the-art performance on compositional, multi-instruction conditional image generation, outperforming monolithic and prior MoE approaches.

4. IGR in Multimodal, Vision-Language-Action Systems

In vision-language-action agents such as CogVLA, instruction-guided routing operates at both the feature and token levels via progressive stages (Li et al., 28 Aug 2025):

Encoder-FiLM Aggregation Routing: FiLM-modulated self-attention and gating compress dual-branch image encodings, conditioned on embedded instructions, into a compact set of aggregation tokens.
- Aggregation and fusion operations are tuned by small MLPs of the form γi(·)=MLPγ,i(t_r), βi(·)=MLPβ,i(t_r), with instruction t_r as input.
LLM-FiLM Pruning Routing: Within the LLM, instruction-driven FiLM is again applied and, crucially, tokens are routed (pruned) by per-token scores from an MLP_route(·) compared to dynamic, layer-wise thresholds β_l controlling retention (via a shifted cosine schedule).
V-L-A Coupled Attention: Subsequent attention/masking ensures causal vision-language token flow and fully bidirectional action-chunk decoding.

In aggregate, the stages reduce visual tokens to 25% of baseline, prune ~50% per LLM layer, and permit parallel action decoding, achieving 3.1× FLOP reduction, 2.8× speedup, and a 97.4% LIBERO simulation success rate (vs. 76.5% for OpenVLA), demonstrating the computational and accuracy benefits of multimodal IGR.

5. IGR for Expert Model and LLM Selection

Instruction-guided routing also addresses the problem of model selection in large candidate ensembles, as formalized in the Model-SAT framework (Zhang et al., 24 Feb 2025):

Capability Instruction Synthesis: For every candidate black-box LLM, a capability representation c^m (free-text summary of model skills) is combined with the user instruction u and a performance inquiry prompt p to form a capability instruction z^m(u).
Routing via Router-LLM: A lightweight LLM φ is trained, via in-batch positive/negative contrastive loss, to predict (via Pr("Yes" | z^m(u))) whether the model is likely to succeed on u.
Deployment: For a new instruction, the router queries all candidate c^m, scores, and dispatches to the maximizing model. The process is efficient, requiring only the router LLM inference (fine-tuned Phi-3-Mini, 3.8B) over the compact capability summaries, as full candidate model inference is not needed until after routing.

Empirical results show this approach outperforms best-single-model and reranking-based baselines over diverse instruction benchmarks. The architecture is robust provided the capability representation is accurate and coverage bias is managed.

6. IGR in Networking and Source Routing

Outside machine learning, IGR concepts appear in source and segment routing, operationalized in the GOFOR-SR framework (Bramas et al., 2023):

Instruction-Like Traffic Engineering: Operators specify advanced routing objectives (e.g., segment-count bounds, metric constraints) as formal "instructions."
On-the-Fly Path Encoding: The GOFOR-SR algorithm embeds segment list encoding directly into Dijkstra/SAMCRA-style path search, with loose encoding minimizing segment usage while satisfying user-defined TE constraints.
Extended Dominance: A new dominance operator orchestrates the tradeoff between original path metrics (e.g., cost, delay) and instruction-induced segment limits.
Meta-DAG Output: For load balancing or TE diversity, the framework outputs multiple encodings per destination/constraint, which can be exploited as part of an operator-specified routing strategy.

GOFOR-SR shows that instruction-guided search can be achieved without significant additional computational overhead relative to standard algorithms and, in ECMP-rich topologies, substantially reduces segment utilization compared to strict approaches.

7. Limitations and Future Directions

Although IGR methods demonstrate substantial gains, several limitations are apparent:

Misalignment and Overfitting: High-dimension routing signals risk memorization and overfitting to seen instructions or model capabilities; evidence shows performance overfits when embedding dimension is too large (Bao et al., 23 Feb 2025).
Ambiguity and Contradiction Handling: For open-ended instructions, cost map hallucination and semantic ambiguity can degrade performance. Most frameworks cannot robustly resolve contradictory requirements.
Coverage Bias: Routing schemes based on capability summaries depend on the representativeness of benchmark tasks or textual descriptors (Zhang et al., 24 Feb 2025).
Systemic Scalability: In larger expert/model pools, even lightweight router LLMs or embedding comparisons can incur nontrivial deployment cost.

Anticipated future developments include:

Model or task validation modules to filter or clarify instructions prior to routing (Bao et al., 23 Feb 2025).
Higher-dimensional and continuous representation for expert/model capabilities (Zhang et al., 24 Feb 2025).
Plugging learned instruction-guided cost/routing functions into broader families of search/planning algorithms for improved modularity and compositionality (Bao et al., 23 Feb 2025, Kuzmenko et al., 2 Jul 2025).

Instruction-Guided Routing, by decoupling control from execution and explicitly linking system behavior to richly parameterized instructions, continues to enable new heights of flexibility, expressiveness, and task-alignment across computational disciplines.