CASOP: Context-Aware Optimization Pipelines

• The paper introduces CASOP, a method that constructs optimization pipelines by conditioning algorithm selection on structured problem context.
• It employs a modular approach with repositories, semantic and statistical context features, and synthesis evaluators to generate valid, performance-driven pipelines.
• Implications include improved pipeline adaptability in domains like warehouse operations, C++ optimization, and AutoML, with measurable gains in efficiency and effectiveness.

Context-Aware Synthesis of Optimization Pipelines (CASOP) denotes a class of methods that construct optimization pipelines conditional on a representation of the current problem context rather than applying a fixed optimization sequence. In the warehouse-optimization formulation, CASOP comprises a modular repository of algorithms, semantic data and algorithm cards, a taxonomy that structures order-fulfillment problems into relevant subproblems, a pipeline synthesizer that identifies applicable algorithms for a given warehouse context and composes all valid optimization pipelines, and a pipeline evaluator that assesses all resulting pipelines (Bischoff et al., 25 Jun 2026). Closely related instantiations apply the same organizing idea to automated C++ runtime optimization, compiler pass sequencing, RTL-to-GDSII flows, AutoML pipeline construction, context-conditioned black-box tuning, and CUDA kernel optimization, with context represented as CFGs, static “autophase” features, backend physical metrics, intermediate-data meta-features, or streaming environment descriptors (Acharya et al., 28 Jan 2025, Lin et al., 13 Oct 2025, Wang et al., 25 Jul 2025, Zöller et al., 2021, Pan, 20 Apr 2026, Bhattacharjee et al., 12 Feb 2026).

1. Formal definitions and problem structure

A formal CASOP statement is given for order fulfillment in manual picker-to-goods warehouses. Let $\mathcal{A}$ be the set of articles, $\mathcal{S}$ the set of storage locations with inventory $I:\mathcal{A}\times\mathcal{S}\to\mathbb{N}_0$, $\mathcal{O}$ the set of customer orders, $\mathcal{R}$ the set of pickers with speed $s(r)$, handling time $\tau(r)$, and carrying-capacity vector $c(r)\in\mathbb{R}_+^k$, and $G=(V,E)$ the layout graph with depot nodes $v_0^-,v_0^+\in V$ and distances $\mathcal{S}$0. Decision variables include assignment variables $\mathcal{S}$1, batching and resource-assignment variables $\mathcal{S}$2, and tours $\mathcal{S}$3 on resolved pick-nodes. Common objectives $\mathcal{S}$4 include total travel distance, makespan, and total tardiness, subject to inventory, capacity, tour-feasibility, and scheduling constraints (Bischoff et al., 25 Jun 2026).

Within that formulation, the Pipeline Synthesis Problem is: given a warehouse context $\mathcal{S}$5, an algorithm repository $\mathcal{S}$6, and an order-fulfillment problem class $\mathcal{S}$7, automatically construct all valid pipelines $\mathcal{S}$8 that map domain objects to solutions, execute them on instances, and select the pipeline $\mathcal{S}$9 minimizing $I:\mathcal{A}\times\mathcal{S}\to\mathbb{N}_0$0. The associated taxonomy decomposes order fulfillment into four problem classes—PRP, OBP, OBRP, and OBRSP—over the subproblems IA, B, R, BR, and S. This decomposition makes pipeline synthesis a constrained composition problem rather than a single monolithic optimization step (Bischoff et al., 25 Jun 2026).

Other CASOP instantiations preserve the same structural idea while changing the underlying objects. AutoPatch turns raw C++ source code into a runtime-faster variant; AwareCompiler produces a compiler pass sequence $I:\mathcal{A}\times\mathcal{S}\to\mathbb{N}_0$1; MCP4EDA iteratively refines synthesis TCL scripts under backend feedback; dswizard incrementally constructs ML pipelines up to a depth limit in a layered DAG; RASP-Tuner composes retrieval, surrogate prediction, and adaptation for non-stationary black-box tuning; and OptiML treats CUDA optimization as search under verification over program variants and primitive transformations (Acharya et al., 28 Jan 2025, Lin et al., 13 Oct 2025, Wang et al., 25 Jul 2025, Zöller et al., 2021, Pan, 20 Apr 2026, Bhattacharjee et al., 12 Feb 2026). This suggests that CASOP is best understood as a design pattern for context-conditioned pipeline generation under explicit validity constraints.

2. Context representation as the organizing principle

Across reported systems, the defining feature of CASOP is not a particular optimizer but the explicit encoding of context before synthesis. In AutoPatch, the input is raw C++ source code $I:\mathcal{A}\times\mathcal{S}\to\mathbb{N}_0$2; Clang’s static analyzer is used to parse $I:\mathcal{A}\times\mathcal{S}\to\mathbb{N}_0$3, normalize headers and dependencies, and extract its Control-Flow Graph $I:\mathcal{A}\times\mathcal{S}\to\mathbb{N}_0$4. CFG embeddings $I:\mathcal{A}\times\mathcal{S}\to\mathbb{N}_0$5 are produced with a pretrained CodeBERT encoder, and each embedding is pooled to a single $I:\mathcal{A}\times\mathcal{S}\to\mathbb{N}_0$6. AutoPatch also computes a CFG difference $I:\mathcal{A}\times\mathcal{S}\to\mathbb{N}_0$7, where $I:\mathcal{A}\times\mathcal{S}\to\mathbb{N}_0$8 denotes added or removed blocks, $I:\mathcal{A}\times\mathcal{S}\to\mathbb{N}_0$9 changed edges, and $\mathcal{O}$0 edited statements (Acharya et al., 28 Jan 2025).

AwareCompiler represents each input program $\mathcal{O}$1 by static “autophase” features $\mathcal{O}$2, aggregating counts of IR constructs. The raw feature vector $\mathcal{O}$3 is mapped by a small feed-forward embedding network $\mathcal{O}$4 to a dense context embedding $\mathcal{O}$5, and the LLM prompt concatenates a textual serialization of $\mathcal{O}$6 plus any user-provided notes (Lin et al., 13 Oct 2025).

In dswizard, context is the intermediate dataset state. At each state $\mathcal{O}$7, the system computes a vector of $\mathcal{O}$8 “fast” meta-features $\mathcal{O}$9 over the transformed dataset, including statistical quantities such as mean, variance, skewness, and percentage of missing values; information-theoretic quantities such as class entropy and mutual information; and simple model-based landmarkers such as 1-NN cross-validation error and decision-stump error rate (Zöller et al., 2021).

RASP-Tuner uses observed context $\mathcal{R}$0 directly. It maintains a memory $\mathcal{R}$1 of past contexts $\mathcal{R}$2, best parameters $\mathcal{R}$3, and learnable soft prompts $\mathcal{R}$4. At each step it computes Euclidean distances $\mathcal{R}$5, retrieves the top-$\mathcal{R}$6 nearest contexts, and forms a retrieved prompt $\mathcal{R}$7 and a retrieval-based hint parameter $\mathcal{R}$8 by softmax-weighted averaging (Pan, 20 Apr 2026).

MCP4EDA extracts context from the design flow itself: the LLM ingests critical path delay $\mathcal{R}$9, Worst-Negative Slack, Total Negative Slack, cell count $s(r)$0 in $s(r)$1, routing congestion maps, and power breakdown. Unlike traditional flows that rely on statistical Wire-Load Models, it uses real post-layout extraction from OpenLane reports and parasitic data (Wang et al., 25 Jul 2025).

Warehouse CASOP uses semantic descriptors rather than learned embeddings. Each algorithm $s(r)$2 is described by a card $s(r)$3, where $s(r)$4 specifies allowed domain types, required features, and feature constraints. Each instance set or warehouse is described by a data card $s(r)$5 over the domains Layout, Articles, Orders, Resources, and Storage (Bischoff et al., 25 Jun 2026).

Setting	Context representation	Role in synthesis
AutoPatch	CFG $s(r)$6, embedding $s(r)$7, CFG diff $s(r)$8	Retrieve historical optimization example
AwareCompiler	“autophase” features $s(r)$9, dense embedding $\tau(r)$0	Score and generate LLVM passes
dswizard	40 “fast” meta-features $\tau(r)$1 of intermediate datasets	Predict priors, warm-start HPO, prune branches
RASP-Tuner	Context $\tau(r)$2, retrieved prompt $\tau(r)$3, hint $\tau(r)$4	Infer latent regime and condition surrogate
MCP4EDA	Post-layout timing, area, power, congestion, parasitics	Refine synthesis TCL scripts
Warehouse CASOP	Data cards and algorithm cards	Filter applicable algorithms and compose valid DAGs

A common misconception is that “context” in CASOP is merely natural-language instruction. In the reported systems, context is instead a typed optimization state: CFG structure, IR feature counts, intermediate-data statistics, streaming environment observations, or backend physical reports. Natural language appears mainly as the interface through which some LLM-based components consume these structured artifacts.

3. Retrieval, search, and synthesis mechanisms

AutoPatch realizes CASOP through four modules: Preprocessing and CFG Extraction, a Retrieval Module, Context Encoder and Fusion, and In-Context Generation. The retrieval database stores $\tau(r)$5 historical $\tau(r)$6 pairs drawn from IBM Project CodeNet together with CFG embeddings $\tau(r)$7 and textual rationales $\tau(r)$8. For a target program $\tau(r)$9, AutoPatch computes its CFG embedding $c(r)\in\mathbb{R}_+^k$0, ranks candidates by cosine similarity,

$c(r)\in\mathbb{R}_+^k$1

and returns the single top-ranked historical example $c(r)\in\mathbb{R}_+^k$2. The final prompt serializes $c(r)\in\mathbb{R}_+^k$3, the retrieved example’s CFG diff $c(r)\in\mathbb{R}_+^k$4, and optimization rationales $c(r)\in\mathbb{R}_+^k$5 into annotated text blocks; the LLM is not fine-tuned, and the implementation relies on in-context attention over the concatenated text block (Acharya et al., 28 Jan 2025).

AwareCompiler replaces one-shot prompting with a multi-turn pipeline-generation algorithm. It constructs a multi-relational knowledge graph $c(r)\in\mathbb{R}_+^k$6 whose node types include LLVM passes $c(r)\in\mathbb{R}_+^k$7, IR-pattern nodes $c(r)\in\mathbb{R}_+^k$8, and learned performance-model templates $c(r)\in\mathbb{R}_+^k$9, with edge types “prerequisite,” “conflict,” and “applies-to.” Given context embedding $G=(V,E)$0, graph attention computes relevance scores for pass nodes, and the next-pass policy combines raw LLM logits with graph scores:

$G=(V,E)$1

Training is hybrid: supervised fine-tuning on expert or heuristic sequences is followed by PPO-based reinforcement learning with intermediate performance reward, format reward, and answer reward, under the joint objective $G=(V,E)$2 (Lin et al., 13 Oct 2025).

dswizard addresses ML pipeline synthesis through incremental search-space construction. The full search space up to depth $G=(V,E)$3 is a rooted, layered DAG $G=(V,E)$4, but successors are generated on demand during Monte Carlo Tree Search. Meta-feature regressors predict the prior performance $G=(V,E)$5 of candidate next actions, and the selection policy combines predicted performance, empirical reward, exploration, and a penalty for long pipelines. Pruning occurs when $G=(V,E)$6 falls below a low-performance threshold $G=(V,E)$7, and through a multi-fidelity wrapper that allocates more HPO trials only to relatively strong pipelines (Zöller et al., 2021).

MCP4EDA uses a three-tier Model Context Protocol server architecture with MCP Host, MCP Clients, and MCP Server. Optimization follows a three-phase closed loop: Phase I baseline exploration via fixed TCL scripts, Phase II LLM-guided analysis of backend metrics and generation of refined scripts, and Phase III iterative refinement until convergence. The loop repeatedly runs synthesis, place-and-route, and report parsing; if the target constraints are not met, the LLM analyzes metrics and history, then generates the next TCL script. Retrieval-Augmented Generation over ABC and Yosys manuals is used to correlate backend bottlenecks with known commands such as map -B 0.87 (Wang et al., 25 Jul 2025).

RASP-Tuner decomposes online tuning into context retrieval, a mixture-of-experts surrogate with soft prompts, and prompt-subspace adaptation with occasional full surrogate updates. After retrieving top-$G=(V,E)$8 similar contexts, it forms

$G=(V,E)$9

and predicts short-horizon loss with a gated MoE. Most steps update only the retrieved prompts via a SmoothL1 loss and $v_0^-,v_0^+\in V$0 regularization; a full-model refit is triggered only when an anomaly score or disagreement variance exceeds a threshold (Pan, 20 Apr 2026).

OptiML formulates CUDA kernel optimization as search under verification. OptiML-G is a Mixture-of-Thoughts proposal policy over kernel implementation strategies, while OptiML-X refines either synthesized or user-provided kernels via MCTS over LLM-driven code edits. Every candidate transformation is compiled, verified with smoke tests and randomized tests, profiled with Nsight Compute, and scored by a composite reward that combines latency improvement, hardware proxy metrics, judge consistency, and guardrails against regressions such as new register spills or more than $v_0^-,v_0^+\in V$1 memory-traffic increase (Bhattacharjee et al., 12 Feb 2026).

Taken together, these systems show that CASOP synthesis can be retrieval-based, enumerative, agentic, search-based, or reinforcement-learned. The unifying mechanism is that synthesis is conditioned on context before the optimization sequence is chosen.

4. Evaluation regimes and reported outcomes

Reported CASOP systems are evaluated not only by final objective values but also by validity, compile or execution success, runtime overhead, and the gap between pipeline synthesis and downstream realization.

Setting	Evaluation scale	Reported outcomes
AutoPatch	1,200 C++ code pairs; 1,000 in vector database, 200 held-out test; 116 compiled and executed successfully	AutoPatch (CASOP) average time $v_0^-,v_0^+\in V$2 s vs Zero-Shot $v_0^-,v_0^+\in V$3 s, yielding a $v_0^-,v_0^+\in V$4 relative improvement; lexical averages: LO $v_0^-,v_0^+\in V$5, EDS $v_0^-,v_0^+\in V$6, TO $v_0^-,v_0^+\in V$7 (Acharya et al., 28 Jan 2025)
AwareCompiler	Seven benchmarks	Average code-size reduction $v_0^-,v_0^+\in V$8 vs Opt -Oz $v_0^-,v_0^+\in V$9, GPT-5 $\mathcal{S}$00, DeepSeek-V3 $\mathcal{S}$01; valid-sequence success rate exceeds $\mathcal{S}$02 on all suites; RL-aided search time overhead is $\mathcal{S}$03 that of -Oz (Lin et al., 13 Oct 2025)
MCP4EDA	Nine open-source RTL designs under SkyWater 130 nm	Geometric mean timing improvement $\mathcal{S}$04 and area improvement $\mathcal{S}$05; per-design improvement varied from $\mathcal{S}$06–$\mathcal{S}$07 in timing closure and $\mathcal{S}$08–$\mathcal{S}$09 in area reduction; Fixed-API degraded performance by $\mathcal{S}$10 delay and $\mathcal{S}$11 area (Wang et al., 25 Jul 2025)
dswizard	28 datasets, 60 min timeout, 35 algorithms	Outperforms both auto-sklearn and TPOT on $\mathcal{S}$12 of datasets and ties on $\mathcal{S}$13; pipelines average $\mathcal{S}$14 steps vs $\mathcal{S}$15 in TPOT and $\mathcal{S}$16 fixed in auto-sklearn (Zöller et al., 2021)
Warehouse CASOP	7 instance sets, 24,704 instances	Synthesized $\mathcal{S}$17 valid pipelines; SBS-VBS gap ranges from $\mathcal{S}$18 on SPRP to $\mathcal{S}$19 on Foodmart (Bischoff et al., 25 Jun 2026)
RASP-Tuner	Nine synthetic tasks, adversarial-context sanity check, three real-world streams	Improves or matches cumulative regret on seven of nine synthetic tasks at horizon $\mathcal{S}$20 and records $\mathcal{S}$21–$\mathcal{S}$22 times lower wall-clock per step than sliding-window GP-UCB; on real-world streams reduces mean cumulative regret by $\mathcal{S}$23–$\mathcal{S}$24 versus the next best baseline (Pan, 20 Apr 2026)
OptiML	ParEval and five representative CUDA tasks on A100 80GB	OptiML-G Pass@1 $\mathcal{S}$25 vs GPT-5.1 $\mathcal{S}$26; full OptiML achieves up to $\mathcal{S}$27 speedups and Pass@5 $\mathcal{S}$28 compile+correctness reliability (Bhattacharjee et al., 12 Feb 2026)

These results show two recurrent empirical themes. First, context-aware synthesis is typically compared against a context-poor baseline—zero-shot generation, naïve retrieval, fixed scripts, plain LLMs, or context-agnostic optimizers—and the main gains are reported precisely in those comparisons. Second, evaluation almost always includes a legality or realizability layer: compilation, execution, correctness tests, valid sequence generation, or DAG validity are treated as first-class outcomes rather than ancillary checks.

5. Variants, misconceptions, and boundary conditions

CASOP is not synonymous with a single learning paradigm. AutoPatch explicitly does not fine-tune the LLM and instead relies on in-context attention over serialized CFG diffs and retrieved examples (Acharya et al., 28 Jan 2025). Warehouse CASOP uses Combinatory Logic Synthesizer to enumerate all valid DAGs satisfying data-flow and template structure, which is a symbolic synthesis mechanism rather than a neural generator (Bischoff et al., 25 Jun 2026). AwareCompiler uses a hybrid SFT→RL pipeline grounded in a structured knowledge graph (Lin et al., 13 Oct 2025). OptiML uses MCTS over unified-diff edits with verification and profiling at each node (Bhattacharjee et al., 12 Feb 2026). RASP-Tuner updates chiefly in a low-dimensional prompt subspace and invokes full surrogate updates only when scalarized error or disagreement spikes (Pan, 20 Apr 2026).

Another common misconception is that context-aware synthesis merely means adding more information to a prompt. In the literature, context affects algorithm applicability, search-space pruning, or control decisions. In warehouse CASOP, matches(α.requirements, 𝓘.domains) verifies domain types, required features, and concrete constraints before an algorithm is even considered (Bischoff et al., 25 Jun 2026). In dswizard, meta-features decide both the prior performance estimate $\mathcal{S}$29 and whether historical HPO trials can be warm-started under the threshold $\mathcal{S}$30 (Zöller et al., 2021). In AwareCompiler, context embedding $\mathcal{S}$31 changes which pass subgraph is retrieved and how passes are scored (Lin et al., 13 Oct 2025).

A further boundary condition is that context must be informative. RASP-Tuner includes an adversarial-context sanity check in which contexts are pure noise; under that condition, its context-dependent inductive bias harms performance relative to context-agnostic CMA-ES and GP-UCB (Pan, 20 Apr 2026). MCP4EDA likewise shows that backend feedback is not optional in its domain: a Fixed-API one-shot LLM script degraded performance, which the authors use to underscore the need for backend feedback rather than fixed synthesis estimates (Wang et al., 25 Jul 2025).

The synthesized object also differs across domains. In some settings it is a code patch, in others a compiler pass sequence, a TCL script sequence, a Luigi DAG, or an online adaptation policy. This suggests that CASOP should be defined by conditional synthesis of valid optimization pipelines, not by a specific representation of the pipeline itself.

6. Limitations and open research directions

The literature identifies several recurring limitations. AutoPatch reports a maintainability-versus-performance trade-off: loop unrolling and block merging can reduce readability, and a few cases showed cyclomatic complexity rising by $\mathcal{S}$32. It also reports underperformance in the “Performance Enhancement” label when domain-specific flags such as compiler intrinsics were missed, and notes that retrieving only the top example can miss complementary patterns that multi-example retrieval might capture (Acharya et al., 28 Jan 2025).

MCP4EDA identifies runtime overhead as a structural issue because each iteration invokes a full place-and-route, with convergence in $\mathcal{S}$33–$\mathcal{S}$34 iterations. Current power feedback is described as coarse, scaling to million-gate blocks may require hierarchical partitioning, and extensions are proposed toward thermal and reliability metrics as well as domain-specialized LLMs (Wang et al., 25 Jul 2025).

RASP-Tuner is explicit that its idealized analysis and deployed system differ materially. The dynamic regret result is proved only in a cluster-separated, strongly convex regime model for regime-wise projected GD, whereas the deployed Prompt-MoE surrogate is non-convex, retrieval may be imperfect in overlapping or high-dimensional context spaces, and disagreement variance is only a heuristic uncertainty proxy. The paper lists open problems including bounding surrogate bias on streaming data, analyzing two-timescale prompt-only update dynamics, ensuring memory coverage under evolving contexts, and improving uncertainty calibration (Pan, 20 Apr 2026).

Warehouse CASOP makes clear that synthesis and filtering overhead are modest—loading and filtering are $\mathcal{S}$35 s and pipeline building is approximately $\mathcal{S}$36–$\mathcal{S}$37 s—but pipeline execution dominates, reaching up to hundreds of seconds when many pipelines must be evaluated. The framework therefore shifts complexity from manual design to exhaustive or near-exhaustive evaluation, which is advantageous when algorithm applicability is unclear but can be expensive at deployment time (Bischoff et al., 25 Jun 2026).

AwareCompiler frames reward sparsity, semantic misalignment, and inefficient interaction with compiler environments as the main obstacles in compiler optimization, then proposes context encoding, knowledge integration, and hybrid training as a general blueprint. A plausible implication is that future CASOP systems will increasingly combine explicit context models, structured domain knowledge, legality constraints, and staged training or search rather than relying on a single end-to-end generator (Lin et al., 13 Oct 2025).

Across domains, CASOP research converges on the same central claim: optimization pipelines are more effective when the system first identifies what kind of instance it is facing, then restricts, retrieves, or composes optimization steps that are valid for that context, and finally evaluates the resulting pipeline under the actual downstream objective.