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

Sep 30, 2026

Code to Control: Synthesizing Parameterized Reactive Controllers

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.

Zergham Ahmed, Joshua B. Tenenbaum, Chris Bates +1

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

Ask PDF

Aug 7, 2026

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

Although remarkable capabilities have been demonstrated by Large Language Models (LLMs) across scientific domains, feedback controller design remains underexplored. Existing benchmarks focus mainly on linear single-Degree-of-Freedom (DoF) systems and large API-hosted models, leaving performance on complex controller-design tasks and feasibility for edge deployment unclear. To address these limitations, we introduce the Complex Dynamics-to-Control Benchmark for Large Language Models (CoDyControlBench), comprising 132 system configurations across five evaluation dimensions: number of DoF, system type, coupling level, damping regime, and controller type. Six state-of-the-art LLMs were evaluated over three independent runs, including three commercial models (GPT, Gemini, and Claude) and three open-source models (GLM, DeepSeek, and Qwen). GPT achieved the highest design success rate at 94.8%, whereas Qwen showed the lowest rate at 50.0%. Across the benchmark dimensions, DoF and controller type exhibited the largest model-averaged variations in design success, with success-rate ranges of 36.3% and 17.6%, respectively, exceeding those associated with system type, coupling level, and damping regime. Comparison of GPT and Qwen showed that their performance gap arose mainly from the control-design knowledge, particularly gain selection and the use of transient-limiting mechanisms. For edge deployment, a specialized 1.5B-parameter model was developed through reasoning distillation. The reasoning-distilled model outperformed the answer-distilled and base model on CoDyControlBench, maintained stable performance across 1-6 DoFs, and achieved successful traget tracking in all three physical trials on a pneumatic-artificial-muscle-driven robotic arm. These results establish a benchmark baseline and highlight the potential of lightweight, edge-deployable controller-design models.

Zhongchao Zhou, Yixuan Xie, Wenwei Yu +5

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

LLM Evaluation Language Model-Based Control Reasoning Distillation Feedback Control

Ask PDF

Mar 20, 2026

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

Industrial process control demands policies that are interpretable and auditable, requirements that black-box neural policies struggle to meet. LLM-driven heuristic synthesis offers an alternative: a language model iteratively proposes and refines human-readable Python controllers using rich behavioral feedback from a simulator. We study this form of programmatic policy search on hot steel rolling, a physics-simulated, multi-pass control problem with competing objectives and hard equipment constraints, and address three questions that arise once the search is run at scale: how to split a fixed budget of LLM iterations between restarting and refining, how to deploy the resulting pool of heuristics, and how to verify it. Treating each search run as a randomized algorithm, we find across 52 independent runs that runs of moderate length match the hindsight-optimal budget allocation, and that Luby-style universal restarts reach this regime without problem-specific tuning. Because each heuristic is cheap to simulate, a small portfolio selected per job outperforms the best single heuristic, also under cross-validation and on out-of-distribution operating conditions on which the best heuristic stalls. Finally, an automated audit pipeline combining static analysis, Z3 proofs, and property-based testing proves key safety properties for all 174 synthesized heuristics; the stall, which neither the search reward nor these properties reveal, shows that the specifications must also cover progress.

Nima H. Siboni, Seyedreza Kiamousavi, Vahid Rostami +1

Juna.ai, Kastanienallee 32, 10435 Berlin · Institute of Metal Forming, RWTH Aachen, Intzestr. 10, 52072 Aachen

Automated Heuristic Design LLM-Based Program Synthesis Manufacturing Feedback Control

Ask PDF

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