Agentic Variation Operators (AVO)

• AVO is a family of evolutionary operators where autonomous agents autonomously generate, repair, critique, and verify candidate solutions using integrated external knowledge.
• The approach unifies traditional variation processes into an agentic loop, enabling sophisticated adaptations in tasks such as GPU kernel optimization and workflow evolution.
• Empirical evaluations demonstrate significant performance gains, with up to +10.5% improvements over classical methods through dynamic planning, critique, and iterative repair.

Agentic Variation Operators (AVO) constitute a family of evolutionary search operators in which the entire process of generating, repairing, critiquing, and verifying candidate solutions is subsumed by autonomous, self-directed coding agents or workflow evolution mechanisms. Classical evolutionary algorithms employ hand-designed, fixed operators such as mutation and crossover, while AVOs elevate the locus of variation to an agent or sequence of agentic transformations—ranging from fully autonomous LLM-powered coding agents to structured workflow modifications guided by evolutionary principles. This paradigm enables integration of external knowledge, situated tool use, lineage analysis, and adaptive response to feedback within the core variation loop, producing novel candidates with high performance and adaptivity across a variety of domains, such as GPU kernel optimization and agentic workflow formation (Chen et al., 25 Mar 2026, Zhang et al., 11 Feb 2025).

1. Formal Definitions and Operator Taxonomy

Let $\mathcal{P}_t = \{(x_i, f(x_i)) \mid i \leq t\}$ denote the lineage of candidate solutions $x_i$ with evaluation scores $f(x_i)$. In standard evolutionary search, the variation operator is decomposed as: $$\text{Vary}(\mathcal{P}_t) = \text{Generate}( \text{Sample}(\mathcal{P}_t) )$$ where $\text{Sample}$ selects parents and $\text{Generate}$ modifies or recombines them (often via LLM prompt-and-decode).

AVOs redefine this by aggregating sampling, generation, repair, critique, and verification into a single agentic process: $$\text{Vary}(\mathcal{P}_t) = \text{Agent}(\mathcal{P}_t, \mathcal{K}, f)$$ Here, $\mathcal{K}$ is a domain-specific knowledge base (e.g., CUDA guides, PTX ISA documentation), and $\text{Agent}$ is a self-directed LLM-powered entity capable of planning, tool-based execution, and memory augmentation (Chen et al., 25 Mar 2026). For agentic workflow evolution, AVOs may be instantiated as tag-based retrieval, crossover, and mutation operators acting on structured workflow graphs (Zhang et al., 11 Feb 2025).

2. Architectural Characteristics

In the kernel optimization context, each AVO step executes as an autonomous inner loop comprising:

• Consultation of lineage history to compare prior commits.
• Querying of the knowledge base for constraints or best practices.
• Planning and application of code edits (e.g., to CUDA+PTX).
• Invoking compilation, correctness tests, and performance profiling.
• Diagnostic critique and repair of failed attempts.
• Iterative refinement until a correct and superior candidate emerges.
• Automated commit/update to the working lineage.

A lightweight supervisory process monitors for stagnation and, when necessary, seeds exploration via high-level strategic shifts (Chen et al., 25 Mar 2026). In workflow evolution, agentic operators act on directed graph representations of LLM-augmented workflows, enabling population-level adaptation of composition, model heterogeneity, and prompt structure (Zhang et al., 11 Feb 2025).

3. Comparison with Classical and LLM-in-the-Loop Evolution

Approach	Variation Mechanism	Adaptivity	Knowledge/Tool Use
Classical Evolution	Fixed mutation and crossover	Low	No
LLM-in-the-loop Pipelines	Prompt-based Generate step only	Moderate	Indirect/Manual
AVO	Full agentic variation/self-loop	High	Direct/Autonomous

Classical pipelines restrict LLMs to candidate generation in a fixed context; population management and sampling remain heuristic and decoupled. AVOs integrate all phases—including plan selection, critique, repair, and information seeking—into the agent’s control loop. This enables proactive problem decomposition, sophisticated tool-based intervention, and dynamic adaptation to runtime feedback (Chen et al., 25 Mar 2026, Zhang et al., 11 Feb 2025).

4. Workflow and Algorithmic Realizations

Pseudocode for the AVO kernel optimization step is as follows (Chen et al., 25 Mar 2026):

Algorithm AgenticVariation(𝒫ₜ, 𝒦, f): Input: Lineage 𝒫ₜ, KnowledgeBase 𝒦, ScoringFunction f Output: New committed kernel xₜ₊₁ Initialize context ← {𝒫ₜ, 𝒦} loop: plan ← Agent.plan(context) patch ← Agent.edit(plan, context) (ok, scores, logs) ← f(patch) if not ok: context.append(logs) continue if scores ≥ best_scores_in(𝒫ₜ): Commit(patch, scores) return patch else: context.append((patch, scores)) continue

In workflow evolution, the agentic variation sequence (abbreviated below) encompasses parent retrieval (tag-based similarity), LLM-driven crossover, and structured mutation (model, prompt, operator node), followed by local niching selection (Zhang et al., 11 Feb 2025):

scores = [S(G | q_t) for G in P(t)] parents = top_Kp(P(t), scores, Kp) G_off = Crossover(parents) if random() < mu_LLM: G_off = LLM_Mutation(G_off) if random() < mu_P: G_off = Prompt_Mutation(G_off) if random() < mu_Op: G_off = Operator_Mutation(G_off) return G_off

5. Empirical Evaluation

In the context of optimizing attention kernels on NVIDIA Blackwell (B200) GPUs, AVO was benchmarked against cuDNN v9.19.1 and FlashAttention-4 on multi-head attention (MHA) tasks across multiple sequence lengths and masking modes. Through 7 days of autonomous evolution, AVO discovered kernel variants with the following geometric-mean throughput and gains (Chen et al., 25 Mar 2026):

Mask	cuDNN TFLOPS	FA4 TFLOPS	AVO TFLOPS	Δ vs cuDNN	Δ vs FA4
Causal	1570	1490	1630	+3.8%	+9.4%
Non-causal	1680	1650	1710	+1.8%	+3.6%

At specific lengths (e.g., $L=32768$), AVO exceeded cuDNN by up to $+3.5\%$ and FA4 by up to $+10.5\%$. These gains transferred to grouped-query attention (GQA) tasks within approximately 30 minutes of agentic adaptation, achieving up to $+7.0\%$ over cuDNN and $+10.3\%$ over FA4.

6. Analysis of Agent-Discovered Optimizations

The agent uncovered multiple nontrivial micro-architectural improvements in CUDA+PTX code, including:

• Branchless accumulator rescaling: Removed conditional branches from the online softmax correction, leveraging predicate-select for rescale factor application, yielding $+8.1\%$ (non-causal) and $+1.6\%$ (causal) gains.
• Pipeline overlap: Reorganized dual Q-tile design to begin correction phase immediately post-GEMM, overlapping computation to eliminate idle cycles ($+1.1\%, +0.4\%$).
• Register rebalancing: Shifted register usage across warp groups to eliminate memory spill in critical correction routines ($+2.1\%$, non-causal).

These results required integrated reasoning over memory hierarchy, warp synchronization, tensor-core utilization, and low-level scheduling (Chen et al., 25 Mar 2026).

7. Domain-Generalization and Extensions

In agentic workflow evolution, AVOs operate over graph-structured populations with directed transfer, complexity adaptation, and LLM heterogeneity (Zhang et al., 11 Feb 2025). Operators (tag-based retrieval, crossover, LLM/prompt/operator mutation) enable population-level Pareto optimization over accuracy and cost metrics. Fitness assignment is localized via niche formation on tag and cost similarity, maintaining population diversity and specialization. Empirical results indicate up to $\times8$ cost savings for equivalent or superior task accuracy by exploiting workflow heterogeneity and fine-grained complexity adaptation.

A plausible implication is that AVOs serve as a general abstraction for learning and optimizing not just code or neural architectures, but entire structured processes mediated by agents, with applications extending from code synthesis to multi-agent orchestration and beyond.

---

References:

• "AVO: Agentic Variation Operators for Autonomous Evolutionary Search" (Chen et al., 25 Mar 2026)
• "EvoFlow: Evolving Diverse Agentic Workflows On The Fly" (Zhang et al., 11 Feb 2025)