LLM-Assisted Strategy Discovery

• LLM-assisted strategy discovery is a systematic approach using LLMs to induce, evaluate, and optimize symbolic plans and algorithmic policies.
• It leverages iterative feedback loops, modular API integration, and quantitative evaluations to enhance planning, red-teaming, and control strategies.
• Empirical results show significant improvements in success rates, efficiency, and interpretability over traditional direct LLM output methods.

LLM-assisted strategy discovery refers to the systematic use of LLMs as active agents in the generation, evaluation, selection, refinement, and integration of strategies for problem solving, planning, decision-making, and exploration across scientific, engineering, security, and behavioral domains. Unlike applications of LLMs that directly solve end-to-end tasks or output actions without abstraction, LLM-assisted strategy discovery emphasizes the explicit induction, testing, optimization, and synthesis of strategies—symbolic plans, algorithmic policies, or attack patterns—through structured interaction with tools, simulators, or environments and iterative feedback cycles. The concept is instantiated in domains as diverse as robotics, algorithm and protocol analysis, automated red-teaming, interpretable control, combinatorial optimization, and behavioral experimentation with LLM agents.

1. Formal Foundations and Problem Definition

LLM-assisted strategy discovery is typically formalized as a multi-level optimization or search process, where the central challenge is to select or invent a strategy $m^*$ that maximizes a utility function $U(m;T,C,f)$, given a natural-language task description $T$, environment and constraint set $C$, and possibly a system dynamics model $f$. The strategy space $M$ may encompass API interfaces to expert planners, symbolic programs, high-level value heuristics, or attack schemas depending on the application domain. Typical formulations include:

• Automated robot planning/control: $\displaystyle m^* = \arg\max_{m\in M} U(m;T,C,f)$, where $M$ comprises planning/control APIs (e.g., astar, rrt*, cem, mpc, lqr, pid, milp); $U$ encodes task completion, constraint satisfaction, and secondary metrics such as iteration counts or errors (Meng et al., 3 Apr 2025).
• Algorithm discovery: Search over programmatic candidates $x$ with fitness $y(x)$, employing a semantic concept model to bias exploration toward constructive “concepts” via likelihood-ratio-based weights (Leleu et al., 3 Feb 2026).
• Security/red teaming: $U$ encodes attack success/novelty under black-box defense constraints, with an LLM iteratively generating, evaluating, distilling, and archiving reusable attack strategies (Liu et al., 4 Nov 2025).
• Behavioral experiments: An LLM agent operates over configurations in a high-dimensional landscape, with strategies emerging as meta-policies for search/exploitation, analyzed quantitatively vis-à-vis human data (Albert et al., 2024).

2. Core Architectural Paradigms

LLM-assisted strategy discovery frameworks share several architectural elements:

• Strategy Induction and Generation: An LLM agent receives structured or natural-language descriptions of tasks and environments, and is prompted to induce a set of candidate strategies. These may take the form of symbolic plans, program sketches, parameterized control API selections, attack blueprints, or verbal heuristics (Gao et al., 2023, Meng et al., 3 Apr 2025, Liu et al., 4 Nov 2025, Leleu et al., 3 Feb 2026).
• Execution and Evaluation: Candidate strategies are executed via downstream tools—planners, interpreters, environment simulators, or black-box APIs—and their performance is quantitatively assessed (e.g., success flags, accuracy, efficiency, constraint adherence) (Meng et al., 3 Apr 2025, Gao et al., 2023, Hu et al., 7 Aug 2025, Liu et al., 4 Nov 2025).
• Iterative Optimization and Feedback: A closed feedback loop allows the LLM agent to iteratively refine strategies based on outcome feedback, error types, or formalized utility scores. Re-prompting with error feedback, explicit optimization agents, or chain-of-thought adjustments are characteristic (Meng et al., 3 Apr 2025, Gao et al., 2023).
• Archival and Retrieval Mechanisms: In advanced frameworks (e.g., ASTRA), discovered strategies are distilled, categorized (e.g., effective, promising, ineffective), embedded, and indexed for retrieval, supporting transfer and reuse across queries (Liu et al., 4 Nov 2025).
• Strategy Fusion and Integration: Mechanisms such as SMaRT combine multiple base strategies through LLM-driven fusion prompts, instructing the LLM to select, cross-mix, and self-refine reasoning steps into a single, more robust solution (Verma et al., 20 Oct 2025).

3. Domain Instantiations and Methodological Variants

Robotics and Control

In AuDeRe, LLM-assisted strategy discovery decomposes task $T$ into structured environment and task descriptions, supplies a catalog of expert planner/control APIs $M$, and prompts the LLM to select optimal strategies and fine-tune parameters. This is followed by a Python-wrapper executing the selected API(s), performance evaluation, and iterative LLM reprompting based on execution outcomes. The system generalizes across linear/nonlinear dynamics and tasks with spatiotemporal constraints, consistently outperforming direct trajectory prediction or code generation by LLMs (Meng et al., 3 Apr 2025).

Algorithm and Program Discovery

Contrastive Concept-Tree Search (CCTS) introduces a representation where each LLM-generated program is annotated with a set of natural-language concepts, organized hierarchically in a dynamically growing tree. A contrastive model learns to upweight “good” concepts and suppress “bad” ones by analyzing the likelihood ratio of concept co-occurrence in high- vs. low-fitness solutions. This semantic guidance drastically improves search efficiency and avoids misleading patterns, yielding interpretable lineage trees of effective algorithmic ideas (Leleu et al., 3 Feb 2026).

Security: Protocol Attack and Jailbreak Discovery

LAPRAD orchestrates staged LLM use for protocol vulnerability discovery: Stage I employs prompt engineering (role/context/example/task template) to elicit attack ideas; Stage II automates attack configuration artifact generation using ReACT-style LLM-in-the-loop scripting; Stage III experimentally validates attack effects in simulation, quantifying impact on resolver throughput. This methodology resulted in the identification of previously unknown DNSSEC-based DDoS attacks (Aygun et al., 22 Oct 2025).

ASTRA implements an autonomous red-teaming loop in the jailbreak setting, iteratively generating attack prompts, evaluating success, distilling reusable strategies, and archiving them in a structured tiered library. Automatic retrieval is based on semantic embedding similarity; prompt generation is adaptively steered by effective or promising precedents. This increases both attack success rates and efficiency, with transferability across target models and datasets (Liu et al., 4 Nov 2025).

Interpretable Policy and Control Logic Discovery

MLES employs multimodal LLMs within evolutionary policy search, leveraging behavioral visualizations (IBE) and code-based strategy representations. The LLM analyzes failures via visual evidence, proposes interpretable (Python) policies with concise “thought” rationales, and enables knowledge transfer and traceability across generations. Performance matches or exceeds deep RL baselines in continuous control and racing benchmarks, with added interpretability (Hu et al., 7 Aug 2025).

Multi-Agent Decision-Making and Planning

STRATEGIST proposes a bi-level tree search, with high-level strategies abstracted and revised via LLM-based reflection, then executed through Monte Carlo tree search (MCTS) in the game environment. Self-play and iterative feedback produce modular, interpretable strategies that outperform both RL and direct LLM agent baselines in complex multi-agent games (Light et al., 2024).

Behavioral Science and Human-Agent Comparison

LLM agents have been embedded into classic human decision-making experiments (“alien game” on NK landscapes) to evaluate and extend search/exploration behavior. Detailed analysis of LLM-produced chain-of-thought sequences allows for fine-grained cognitive modeling and direct comparison with human heuristics, thus informing behavioral strategy theory and methodology (Albert et al., 2024).

4. Algorithmic Patterns and Representative Pseudocode

LLM-assisted strategy discovery typically adopts iterative optimizer–evaluator–archiver patterns, with modules encapsulating generation, execution, and analysis. Representative skeletons include:

• LLM-based API selection and feedback (Meng et al., 3 Apr 2025):

for k in range(max_iters): response = LLM(prompt_k) api, params, code = parse(response) try: result = execute(code) metrics = evaluate(result) if metrics.success: return result, api, params except Exception as e: metrics.success = False; metrics.error_type = e.type prompt_k = prompt_k + feedback(metrics)

• Strategy distillation and retrieval (ASTRA (Liu et al., 4 Nov 2025)):

for each harmful query q: M = [] for i in range(N): S = retrieve_strategies(q, E, P, I) if not S: p = gen_agnostic(q, M, Attacker) else: p = gen_guided(q, S, M, Attacker) r = T.call(p) s = Judge.score(q, p, r) M.append((p, r, s)) if s == 10: σ = Extractor.distill_effective(p, r) E.add(σ) break elif s > 5: σ = Extractor.distill_promising(p, r, s) P.add(σ) else: σ = Extractor.distill_ineffective(p, r) I.add(σ)

• Concept-tree guided program evolution (CCTS (Leleu et al., 3 Feb 2026)):

for t in 1..T: good, bad = partition(A, τ_t) for v in V: update (A^+, B^+, A^-, B^-) for good, bad η^+_v = (A^+ + α0)/(B^+ + α0 + β0) η^-_v = (A^- + α0)/(B^- + α0 + β0) compute w_i = exp(log p_{η+}(b_i) - log p_{η-}(b_i)) select parent ∝ w_i select concept v* maximizing Δ_v = log η^+_v - log η^-_v prompt LLM with parent code, request use of v* x_new = LLM(...) y_new = E(x_new) b_new = Φ(x_new) A.append((x_new, y_new, b_new))

5. Quantitative Performance and Empirical Benchmarks

Empirical studies demonstrate that LLM-assisted strategy discovery often yields dramatic improvements in success rates, efficiency, and error suppression compared to direct completion or unstructured code-generation baselines. Key results include:

Benchmark/Task	Baseline Success (%)	LLM-Assisted Strategy (%)
Robot maze & STL planning (Meng et al., 3 Apr 2025)	LLM-predict: 10–20	LLM-use-API: 95–100
Jailbreak attack ASR (Liu et al., 4 Nov 2025)	Best baseline: 62.1	ASTRA: 82.7
ALFWorld sequential decision (Verma et al., 20 Oct 2025)	Direct/Judge: 50–64	SMaRT: up to 96
Policy search, Car Racing (Hu et al., 7 Aug 2025)	PPO: 94.5	MLES: 96.4
Multi-agent games (GOPS) (Light et al., 2024)	Alpha-Go: –0.39	STRATEGIST: +1.5

In nearly all cases, the addition of modular LLM-driven strategy mining improves not only success but also query/sample efficiency (e.g., 1.4–2.3 rounds per success vs. 2.7–3.8 for pure LLM code/prediction), robustness (reduction of parse/syntax/time-out errors to <5%), and generalization across tasks and models.

6. Integration, Generalizability, and Limitations

LLM-assisted strategy discovery frameworks are typically constructed to maximize modularity and extensibility:

• Domain Agnosticism: Prompt templates and agent designs generalize across problem classes, enabling transfer between, for example, linear/nonlinear control, symbolic reasoning, policy synthesis, and adversarial task generation (Meng et al., 3 Apr 2025, Liu et al., 4 Nov 2025, Hu et al., 7 Aug 2025).
• Strategy Representation Variants: The strategy abstraction may be instantiated as a JSON API call, natural-language plan, symbolic computation tree, explicit code, or policy sketch, with appropriate mechanisms for integration and revision (Gao et al., 2023, Verma et al., 20 Oct 2025).
• Tool/Environment Coupling: LLMs interface with diverse backends (Python, CasADi, robotics APIs, protocol emulators), often via systematic wrappers or tool-agent loops (Meng et al., 3 Apr 2025, Aygun et al., 22 Oct 2025).
• Feedback Bottlenecks and Error Modes: Remaining sources of suboptimality include LLM misinterpretations of API signatures, parameter mis-specification, and hallucinations—often mitigated by prompt engineering and tool-based validation loops (Meng et al., 3 Apr 2025, Liu et al., 4 Nov 2025, Li et al., 2024).

Limitations noted include reliance on simulated environments for validation, computational overheads of multi-agent LLM orchestration, open challenges in full task automation (e.g., human-in-the-loop selection), and variance scaling for behavioral simulation (Aygun et al., 22 Oct 2025, Albert et al., 2024).

7. Outlook and Methodological Significance

LLM-assisted strategy discovery establishes a model for automated, modular, and interpretable strategy generation and refinement far beyond direct output paradigms. The field is rapidly advancing in:

• Automated red-teaming and adversarial testing through self-evolving libraries of attack or avoidance strategies (Liu et al., 4 Nov 2025).
• Interpretable policy induction and transfer in control, with transparent “thought” rationales and explicit lineage (Hu et al., 7 Aug 2025).
• Cross-strategy fusion for robust reasoning and planning using LLM integrators (Verma et al., 20 Oct 2025).
• Dynamic, concept-guided and feature-based optimization in algorithmic discovery, opening semantic search paradigms (Leleu et al., 3 Feb 2026).
• Integration of LLM agents into behavioral science for cognitive modeling and hypothesis testing at scale (Albert et al., 2024).

The paradigm is characterized by systematic prompt and tool design, modular feedback and optimization loops, empirical benchmarking, and demonstrable improvements in efficiency and generalization. With the ongoing maturation of LLM capabilities and ecosystem tooling, LLM-assisted strategy discovery is likely to underpin future advances in AI-driven science, engineering design, security, and complex system navigation.