A²Flow Operator Induction

• The paper introduces a fully automated framework that induces self-adaptive abstraction operators from expert demonstrations, eliminating manual operator design.
• It clusters and refines operators using LLM embeddings and chain-of-thought prompting to synthesize coherent, multi-step workflows.
• Empirical results show improved efficiency and performance across diverse benchmarks, with significant resource reductions and enhanced task execution.

A²Flow Operator Induction is a fully automated framework for agentic workflow generation based on self-adaptive abstraction operators. This mechanism moves beyond prior methods that rely on manually predefined operators by automatically inducing, abstracting, and integrating reusable operator blocks from expert demonstrations, leveraging LLM reasoning throughout. The central objective is to construct efficient, generalizable workflows for complex tasks through data-driven operator synthesis, abstraction, and search, eliminating the need for hand-crafted, low-level primitives (Zhao et al., 23 Nov 2025).

1. Self-Adaptive Abstraction Operators: Definition and Formalization

In A²Flow, a self-adaptive abstraction operator is a reusable, LLM-powered code “block” encapsulating recurring subroutines (e.g., “Plan”, “Execute”, “Validate”) within multi-step agentic workflows. Each operator is defined as a Python-like class with a single asynchronous __call__ method, parameterized by the LLM itself. Operators act as black-box transforms, each mapping a single input to a single output. Formally, let $\mathcal{C} = \{C_1, \ldots, C_n\}$ denote a set of expert task cases and $M$ denote the LLM. Given a prompt template $P_e$, the case-based initial operator extraction function

$$E: \mathcal{C} \times \mathcal{P} \times M \rightarrow \mathcal{O}$$

yields, for each $C_i$, a set of code operators $O^{(e)} = \{ o_{i,1}, \ldots, o_{i,m_i} \}$ where

$o_{i,j} = E(C_i, P_e, M).$

These initial operators, $\mathcal{O}^{(e)}$, populate the operator pool used as nodes in subsequent workflow synthesis and search.

2. The Three-Stage Operator Extraction and Abstraction Cascade

A²Flow induces generalizable operators from raw cases via a pipeline of three refinement stages:

2.1 Case-Based Initial Operator Generation

Expert demonstrations $\mathcal{C}$ are split into 20% validation and 80% test subsets. For each $C_i$ in the validation set, the LLM is prompted with $P_e$ to extract operators for the case. Each extraction produces Pythonic code blocks (e.g.,

class DataExtractor(object): def __init__(self, LLM=AsyncLLM()): self.LLM = LLM self.operator_prompt = "Extract structured data from the paragraph." async def __call__(self, input): return await self.LLM(input, self.operator_prompt)

). Each candidate is scored using a pass/fail indicator, $\delta(o_{i,j}) = 1$ if the Python executor returns no errors (otherwise 0), and only those with $\delta=1$ are retained.

2.2 Operator Clustering and Preliminary Abstraction

This stage reduces redundancy. Each viable operator $o_{i,j}$ is embedded into a vector representation $e_{i,j}$ via the LLM. K-means clustering solves

$$\min_{\mu_1, \ldots, \mu_K} \sum_{i,j} \| e_{i,j} - \mu_{c(i,j)} \|^2,$$

grouping semantically similar operators. For each cluster $k$, a “preliminary abstract operator” $o_k^{(a)}$ is synthesized using an LLM prompt $P_a$ to merge and compress all code in the cluster into a single, well-titled, minimal block. The collection is $O^{(a)} = \{o_1^{(a)}, ..., o_K^{(a)}\}$.

2.3 Deep Extraction for Abstract Execution Operators

Each preliminary operator is further abstracted via multi-path, chain-of-thought (CoT) prompting. For $m=6$ chains, iterative CoT refinement is applied:

• Step 1: $o_{p,1} \leftarrow M(I, P_t, O^{(a)})$,
• Step 2: $o_{p,2} \leftarrow M(I, P_t, o_{p,1}, \text{CoT})$,
• Step 3: $$o_{p,3} \leftarrow M(I, P_t, o_{p,1}, o_{p,2}, \text{CoT})$$,

where $I$ is the task instruction and $P_t$ is a prompt to “make it deeper and more general.” Across chains, operators whose self-consistency frequency is at least $\tau$ (commonly $\tau \approx 0.5$) are retained, and reflection-driven regeneration ensures correctness ($\delta(o) = 1$ for all $o \in O^{(t)}$).

3. Operator Memory Mechanism

A²Flow augments workflow search with an operator memory mechanism, diverging from approaches where individual operators only see the immediate predecessor’s output. For workflow node $k$, the memory set is recursively extended:

$$\mathcal{M}_0 = \emptyset, \quad \mathcal{M}_k = \mathcal{M}_{k-1} \cup \{h_k\}$$

with $h_k$ as the complete response from $o_k$. Execution now follows

$$o_k = f_k(\text{input}_k, P_k, \mathcal{M}_{k-1}) = M\big(\text{prompt} = \text{concat}(P_k, \text{input}_k, \text{summarize}(\mathcal{M}_{k-1}))\big)$$

This enables each operator at step $k$ to utilize the summarized context of all preceding steps, improving workflow coherence (measured at $+4.1\%$ on MATH via ablation).

4. Experiments and Quantitative Performance

A²Flow is benchmarked across eight datasets covering code, math, QA, and embodied agent tasks: HumanEval, MBPP, GSM8K, MATH, HotpotQA, DROP, ALFWorld, and TextCraft. Used metrics include:

• F$_1$ on HotpotQA, DROP ($$2 \cdot \mathrm{TP} / (2\cdot\mathrm{TP} + \mathrm{FP} + \mathrm{FN})$$),
• pass@1 (fraction of correct first attempts) on HumanEval, MBPP,
• SolveRate (correct/total) on GSM8K, MATH,
• Binary success on ALFWorld, TextCraft.

Relative to AFLOW and other baselines, A²Flow yields a $+2.4\%$ average gain on reading, code, and reasoning tasks, $+19.3\%$ on embodied/game tasks, and a $-37\%$ reduction in resource usage. For example, on DROP with GPT-4o-mini, cost per run drops from \$1.37 to \$0.51 while F$_1$ increases by $+4.55\%$.

5. High-Level Induction and Search Pseudocode

The following LaTeX-formatted algorithm encapsulates A²Flow’s operator induction and memory-augmented workflow search procedure:

\begin{algorithm}[H] \caption{A²Flow Operator Induction {data} Workflow Search} \begin{algorithmic}[1] \Require expert cases 𝒞; LLM M; eval G; search rounds R \State Split 𝒞→𝒞_val (20%), 𝒞_test (80%) \Comment{ Extract Self-Adaptive Operators } \ForAll{Cᵢ ∈ 𝒞_val} \State Prompt Pₑ → O⁽ᵉ⁾_i ← E(Cᵢ, Pₑ, M) \State Prune any o with δ(o)=0 \EndFor \State Embed & cluster \{O⁽ᵉ⁾₁…\} → K clusters → O⁽ᵃ⁾ via Pₐ \For{p=1…m} \Comment{Deep extraction via CoT} \State o_{p,1}←M(I,Pₜ,O⁽ᵃ⁾), o_{p,2}←M(I,Pₜ,o_{p,1},CoT), o_{p,3}←M(I,Pₜ,o_{p,1},o_{p,2},CoT) \EndFor \State O⁽ᵗ⁾←𝒜ₜ(\{o_{p,3}\}_{p=1}^m,Pₜ,M) \Comment{each o∈O⁽ᵗ⁾ now δ(o)=1} \State %%%%45%%%% \State Initialize workflow template W₀, memory ℳ←∅ \For{iter=1…R} \State Select a partial workflow W via MCTS (balances exploitation/exploration) \State Expand W by inserting/modifying nodes using operators in O⁽ᵗ⁾ \State Execute candidate W on 𝒞_val: Initialize ℳ←∅; for k=1…|nodes|: o_k=selected operator; h_k←o_k(input_k,P_k,ℳ); ℳ←ℳ∪\{h_k\} Compute score s=G(W,𝒞_val) \State Backpropagate s in MCTS \EndFor \State Return best workflow W*; \end{algorithmic} \end{algorithm}

6. Significance and Context

A²Flow’s methodological contributions center on the full automation of workflow code block induction, deep abstraction, and integration. Its self-adaptive abstraction operators are derived without any hand-crafted definitions or templates. The combination of operator induction, semantic clustering, chain-of-thought abstraction, and memory-augmented search constitutes an end-to-end pipeline that yields improved generality, resource efficiency, and task performance, as reflected by results on diverse benchmarks (Zhao et al., 23 Nov 2025). A²Flow represents a scalable alternative to manual operator engineering, with empirical evidence demonstrating robust transfer and adaptability across domains and agentic task settings.