LEMCA: LLM-Guided Synthesis of Efficient Mode-Switching Control Architectures

Arjun Krishna; Vincent Pacelli; Dinesh Jayaraman

cs.ROSep 18, 2026

LEMCA: LLM-Guided Synthesis of Efficient Mode-Switching Control Architectures

Authors: Arjun Krishna, Vincent Pacelli, Dinesh Jayaraman

Organizations: University of Pennsylvania · Amazon Robotics · Georgia Institute of Technology

Abstract

Physical control tasks in the natural world, such as driving or object manipulation, frequently exhibit dramatic variations in sensory and compute complexity over time. Correspondingly, a natural resource-efficient choice for robot control is to dynamically switch between control modes with varying resource allocations. However, such "mode-switching controllers" (MSCs) have historically required laborious, expert-driven design and synthesis for each new task. Driven by these design difficulties, modern robotic control architectures often fall back to a wasteful "monolithic" one-size-fits-all structure, where resource allocation is permanently anchored to the hardest, most resource-intensive task phases. To facilitate the design of performant yet efficient MSCs, we propose LLM-Guided synthesis of Efficient Mode-Switching Control Architectures (LEMCA). LEMCA represents MSC designs as interpretable programs to be iteratively refined in an evolutionary loop. To evaluate design fitness, we propose MSC-compatible extensions of automated controller synthesis approaches, such as reinforcement learning in simulation. LEMCA then leverages the semantic priors, reasoning, and coding capabilities of Large Language Models (LLMs) to iteratively edit controller modes, their corresponding sensory-compute resource allocations, and mode transitions. Our experiments across diverse control benchmarks show that LEMCA consistently discovers strategies that surpass the Pareto frontier of monolithic designs by reclaiming wasted resources during "easy" task phases. LEMCA thus presents an automated, low-effort path to synthesize resource-efficient MSC designs.

Figures & tables

Figure 1: point-to-disk

Figure 2: LEMCA System Diagram: An LLM-in-the loop evolutionary search pipeline to synthesize and refine mode-switching control architectures represented as a finite state machine specifying various operating modes (containing the sensory-compute configuration

\phi_{j}

, control policy

\pi_{j}

, and monitor policy

\lambda_{j}

), and mode-transitions

\delta

(see Sec. 2 ). A controller-synthesis procedure is used to generate a performant controller adhering to the design specified. The resulting controller’s performance metrics serve as feedback for iterative refinement.

Figure 3: Computation graph of the three stages in MSC-PPO. [Stage I] Mode-transitions unroll according to privileged

\delta

specified by the design

{\mathcal{D}}

, corresponding policy networks

\pi_{\sigma_{t}}

are activated to sample actions and receive policy gradients. [Stage II] Traces from the learned policy are used to train mode-specific monitors

\lambda_{\sigma_{t}}

to mimic

\delta

with temporal label smoothing [Stage III] Fine-tunes the policy

\pi

to adapt to the mode-transitions determined by

\lambda

Figure 4: Performance-Resource curve for the evaluated tasks. LEMCA consistently identifies MSC designs that dominate the Monolith frontier. The errorbars depict

\pm 1\sigma

bands of 1000 rollouts.

Figure 5: Salient MSC designs identified by LEMCA for different tasks. More designs and rollout videos are available at https://lemca-robotics.github.io/ .

Figure 6: Design decisions and refinements by LEMCA over generations for cartpole-swingup .

Appendix figures & tables15 assets

Supplementary material from the paper’s appendix.

Appendix

Architecture (actor / critic / monitor MLPs)
Hyperparameter		point-to-disk	RF-DMC
	depth (# hidden layers)	$3$ / $3$ / $3$	$4$ / $4$ / $4$
	width (hidden dim)	$64$ / $256$ / $64$	$512$ / $512$ / $512$
	activation	SiLU
	critic value head	two-hot, $[-20,20]$ , $255$ bins
PPO Parameters

Appendix

Table 1: MSC-PPO hyperparameters across tasks.

Hyperparameters		Value
$N$	Population Size	20
$N_{\text{new}}$	Offspring per Generation	3
$T$	Tournament Size	5
$K$	Number of Inspirations	3
$\rho$	Explore Rate	0.2
	max_retries (LLM Validation)	1

Appendix

Table 2: The hyperparameters of LEMCA designer loop across tasks.

Cost Structure	GPS		RadialSector
Cost Structure	$c^{\text{gps}}_{\text{base}}$	$c_{\text{gps}}$	$c^{\text{rad}}_{\text{base}}$	$c_{\text{ang}}$	$c_{\text{dist}}$
CostlyGPS	$0.01$	$0.01$	$0.01$	$0.01$	$0.01$
CheapGPS	$0.02$	$0.01$	$0.01$	$0.05$	$0.01$

Appendix

Table 10

Sensor configuration	CostlyGPS	CheapGPS
SectorRadar(s=1, d=())	$0.010$	$0.010$
SectorRadar(s=3, d=())	$0.044$	$0.178$
SectorRadar(s=4, d=(0.01,0.05))	$0.066$	$0.217$
SectorRadar(s=8, d=(0.05,0.2,0.5))	$0.080$	$0.272$
GPS(sigma_xy=0.01)	$0.183$	$0.193$
GPS(sigma_xy=0.05)	$0.136$	$0.146$

Appendix

Table 3: Representative per-step sensor costs under the two cost structures.

RadialSector monoliths
		Per-step cost
Configuration	$\mathrm{J}/\mathrm{J}_{\text{oracle}}$	CostlyGPS	CheapGPS
SectorRadar(s=3, sigma_theta=0.8)	$0.39\,\pm\,0.03$	$0.036$	$0.142$
SectorRadar(s=3)	$0.43\,\pm\,0.03$	$0.044$	$0.178$
SectorRadar(s=4)	$0.66\,\pm\,0.03$	$0.048$	$0.199$
SectorRadar(s=5, sigma_theta=0.2)	$0.76\,\pm\,0.02$	$0.049$	$0.206$

Appendix

Table 4: The monolithic seed designs used to initialize LEMCA for point-to-disk.

Task	Rangefinder Site	Priv. State Size	$\mathrm{J}_{\text{oracle}}$	$\mathrm{J}_{\text{target}}\,(/\mathrm{J}_{\text{oracle}})$
cartpole-swingup	pole tip	$5$	$881.8\pm\>\,4.9$	$650\;(0.74)$
cup-catch	cup center	$10$	$977.8\pm 15.7$	$700\;(0.72)$
finger-spin	fingertip	$19$	$969.9\pm 11.7$	$750\;(0.77)$

Appendix

Table 5: RF-DMC task settings. The oracle performance corresponds to episodic return achieved with full state information (measured over

N=1000

rollouts).

Grade	$c_{\text{hit}}$	$c_{\text{max}}$	$c_{\text{rand}}$	$\sigma_{\text{hit}}$	$\mathrm{SNR}_{\text{dB}}$	Rel. Cost / Ray
$\mathsf{A}$	$0.995$	$0.003$	$0.002$	$10^{-5}$	$32.0$	$22.61$
$\mathsf{B}$	$0.990$	$0.005$	$0.005$	$8{\cdot}10^{-4}$	$28.1$	$15.39$
$\mathsf{C}$	$0.970$	$0.010$	$0.020$	$10^{-3}$	$22.2$	$7.62$
$\mathsf{D}$	$0.950$	$0.010$	$0.040$	$10^{-2}$	$19.4$	$5.08$
$\mathsf{E}$	$0.850$	$0.050$	$0.100$	$5{\cdot}10^{-2}$	$15.2$	$2.44$
$\mathsf{F}$	$0.650$	$0.100$	$0.250$	$10^{-1}$	$11.3$	$1.00$

Appendix

Table 6: Rangefinder quality grades: mixture weights, hit-noise scale,

90

th-percentile SNR, and per-ray energy cost normalized to grade

\mathsf{F}

(all grades use

c_{\text{short}}{=}0

		Task Performance: $\mathrm{J}/\mathrm{J}_{\text{oracle}}$
Config $(q,h,n)$	cost/step	cartpole-swingup	cup-catch	finger-spin
$(\mathsf{F},4,3)$	$6.0$	$0.26$	$0.12$	$0.00$
$(\mathsf{E},8,3)$	$11.8$	$0.60$	$0.11$	$0.09$
$(\mathsf{D},16,3)$	$21.2$	$0.96$	$0.11$	$0.37$
$(\mathsf{C},4,4)$	$34.5$	$0.84$	$0.82$	$0.65$
$(\mathsf{C},4,10)$	$86.2$	$0.93$	$0.83$	$0.94$

Appendix

Table 7: The

11

monolithic seed designs used to initialize LEMCA across all RF-DMC tasks. Each seed design uses the same sensor RayScanSensor(quality

=q

, history

=h

, nrays

=n

) throughout the task. The task performance is measured over

N{=}1000

rollouts.

	Parameter	Description	Domain
Sensor	$R_{0}$	sensor power (reliable-detection range, $\propto$ SNR)	$[2,\,50]$
	max_range	range cutoff for returned detections	$[5,\,15]$
	fov	angular field of view (rad); $2\pi$ omnidirectional	$[\pi/3,\,2\pi]$
Planner	n_samples	MPPI rollouts per refinement iteration	$\{256,512,1024\}$
	n_iters	MPPI refinement iterations	$\{1,\dots,5\}$
	horizon	planning horizon (s)	$[2,\,5]$

Appendix

Table 8: clutter-nav per-mode Sensor + Planner Configuration space.

Configuration	cost/step
(R0=2, max_range=10, fov= $\pi$ /3, n_iters=1, n_samples=256, horizon=2, period=10)	$0.25$
(R0=20, max_range=10, fov= $2\pi$ , n_iters=3, n_samples=512, horizon=3, period=4)	$28.00$
(R0=50, max_range=15, fov= $2\pi$ , n_iters=5, n_samples=1024, horizon=5, period=1)	$681.75$

Appendix

Table 9: Example per-step costs for clutter-nav under cost model described in Sec. D.3 .

Template	Modes	Free params	Approach-mode radial structure
T1	2	3	single radial band
T2	2	5	3 radial bands
T3	2	7	5 radial bands
T4	3	6	two nested approach modes

Appendix

Table 10: The four hand-authored BO-MSC templates for point-to-disk [CostlyGPS] . All modes sense via RadialSector detectors and transition based on

\|{\mathbf{x}}\|_{2}

; the free parameters are the per-mode Sector resolutions

s_{i}

and the radial band edges

d_{j}

( Figure 7 , bottom).

Figure 7: BO-MSC on point-to-disk [CostlyGPS] : we run black-box BayesOpt to populate the free parameters (highlighted in color) of four pre-specified mode-switching templates (T1--T4, bottom; see Table 10 ). Each panel plots the reciprocal resource cost of the best feasible parameterization found so far against the number of trials (evaluations), for a performance target $\mathrm{J}_{\text{target}}\!\in\!\{200,300,450\}$ ; the horizontal band is LEMCA’s best design and shaded regions denote $\pm 1\sigma$ over 1000 rollouts.

Variant (legend)	Search mechanism	Pop. + Crossover	Cross-Iter. Memory
GA + Design Log (LEMCA)	feasible-first GA	✓	design log
GA	feasible-first GA	✓	none
Refine Best + Design Log	greedy hill-climb (best)	--	design log
Refine Latest + Design Log	greedy hill-climb (latest)	--	design log
Single Chat	one growing conversation	--	raw chat history

Appendix

Table 11: The five LLM-in-the-loop variants compared in Figure 8 . GA removes only the design log from LEMCA; the two Refine variants replace the population/crossover with greedy single-design refinement (of the global best or the most recent design, respectively) while keeping the design log; Single Chat additionally drops the design log, letting an unbounded conversation history serve as the only memory.

Figure 8: Ablation of LEMCA’s LLM-in-the-loop search mechanism on clutter-nav ( Table 11 ). Each panel plots the reciprocal resource cost of the best feasible design found so far against the generation count for a reciprocal collision-rate target ( $1/\mathrm{cpt}_{90}\!=\!30$ , i.e. $\mathrm{cpt}_{90}\!\leq\!0.033$ , left; and $40$ , i.e. $\leq\!0.025$ , right) under the $\geq\!80\%$ success constraint; the median of 3 seeds is represented in bold and individual seeds are marked in faint colors. Both GA variants ( GA + Design Log , GA ) reach substantially cheaper designs than the greedy single-design ( Refine Best / Latest ) and Single Chat variants -- the GA harness clearly drives improvement, whereas adding the design log to the GA yields no clear advantage.

LLM-Based Program Synthesis

Large language model (LLM)-based program synthesis turns natural-language goals and examples into executable programs, often using tests or formal constraints.

See all 311 papers

Code to Control: Synthesizing Parameterized Reactive Controllers
Sep 30, 2026Zergham Ahmed, Joshua B. Tenenbaum, Chris Bates +1RL Control Language Model-Based Control
Harvard University · Massachusetts Institute of Technology · Florida Institute for Human and Machine Cognition
Benchmarking and Reasoning Distillation of Large Language Models for Feedback Controller Design in Complex Dynamical Systems
Aug 7, 2026Zhongchao Zhou, Yixuan Xie, Wenwei Yu +5LLM Evaluation Language Model-Based Control
Matsuo-Iwasawa Laboratory, Department of Technology Management for Innovation, School of Engineering, The University of Tokyo, Tokyo, Japan · Department of Statistics, University of Illinois Urbana-Champaign, Champaign, IL, USA · Center for Frontier Medical Engineering, Chiba University, Chiba, Japan +1
From Language Models to Control Policies: Search, Selection, and Verification
Mar 20, 2026Nima H. Siboni, Seyedreza Kiamousavi, Vahid Rostami +1Automated Heuristic Design LLM-Based Program Synthesis
Juna.ai, Kastanienallee 32, 10435 Berlin · Institute of Metal Forming, RWTH Aachen, Intzestr. 10, 52072 Aachen

Sep 30, 2026J/K move · Enter open · S save

Code to Control: Synthesizing Parameterized Reactive Controllers

Zergham Ahmed, Joshua B. Tenenbaum, Chris Bates, Samuel J. Gershman

Harvard University · Massachusetts Institute of Technology · Florida Institute for Human and Machine Cognition

RL Control Language Model-Based Control LLM-Based Program Synthesis Derivative-Free Optimization

Open paper AskPDF arXiv

Recent LLM-based approaches to control either invoke a language model to select actions or synthesize world models that require planning at every decision, introducing latency that can limit real-time use. We introduce Code to Control, an approach that synthesizes Python controllers which execute directly as policies. Code to Control separates program structure from parameters. An LLM synthesizes the controller structure, while derivative-free search fits its parameters for continuous control using feedback from the environment. Once learned, the resulting controllers require neither LLM inference nor planning at decision time, enabling real-time gameplay and, under our timing protocol, faster action selection than a PPO policy. Across a suite of Atari games, Flappy Bird, and MuJoCo tasks, Code to Control outperforms planning-based program synthesis methods, remains competitive with deep reinforcement learning while using fewer environment interactions, transfers across substantial changes in environment dynamics, and scales to complex locomotion tasks.

Abstract

LLM-Based Program Synthesis

Explore similar work

Code to Control: Synthesizing Parameterized Reactive Controllers

Benchmarking and Reasoning Distillation of Large Language Models for Feedback Controller Design in Complex Dynamical Systems

From Language Models to Control Policies: Search, Selection, and Verification