betaFeedback

WorksComputer Science

KARMA: Training-Free Knowledge-Atomic Harness Evolution for Industrial Advertising Agents

Abstract

Industrial advertising agents must continually adapt their decision knowledge to changing product offerings, traffic patterns, and operating policies. We present KARMA (Knowledge-Atomic, Regression-Gated Modular Adaptation), a training-free framework that evolves six typed knowledge modules while keeping model weights and executable harness code frozen. During our evolution, a deterministic Trace Verifier maps observed errors to candidate modules, and a Critic compares successful and failed trajectories to guide a tool-constrained Evolver. The Evolver applies atomic knowledge edits, which a fixed validation gate retains only when their measured gain reaches a threshold; otherwise, the previous knowledge state is restored. We evaluate KARMA with three LLM families on cases sampled from a corpus of approximately half a million real-world operation logs across six e-commerce domains. Across 18 domain–model settings, KARMA raises the average hold-out score from 30.19 to 39.15 (+8.96 points, +29.7%). Ablations show that removing either successful or failed trajectories more than halves the average hold-out gain. Evolved knowledge also transfers across domains without further adaptation, yielding an average hold-out gain of 8.54 points across all source–target pairs. By linking retained patches to their diagnostic evidence and validation outcomes, KARMA supports inspectable, reversible knowledge adaptation for agents in Web marketplaces.

CCS Concepts

• Computing methodologies → Intelligent agents; Knowledge representation and reasoning; • Information systems → Online advertising.

ACM Reference Format:

Xinhua Miao, Yuanzhen Rong, Weiru Zhang, and Xiaoyi Zeng. 2018. KARMA: Training-Free Knowledge-Atomic Harness Evolution for Industrial Advertising Agents. In *Proceedings of Make sure to enter the correct conference title from your rights confirmation email (Conference acronym ’XX). ACM, New York, NY, USA, 12 pages. https://doi.org/XXXXXXX.XXXXXXX

Introduction

Web marketplaces allocate merchant spending and product exposure through advertising systems. Merchants must decide which products to promote, how much budget to allocate, and how aggressively to bid under changing demand and competition. LLM agents can retrieve business evidence and combine it with operating knowledge [2], but their recommendations depend on rules that may become incomplete or outdated. Updating those rules can change both the selected control (budget, bid, or item) and the direction of intervention. The research challenge is to improve this decision knowledge while making changes inspectable and screening for regressions across marketplace contexts. We study this challenge through an advertising agent that queries telemetry from a global e-commerce platform and emits structured decisions in an offline evaluation.

Repeated fine-tuning is costly, while manual prompt maintenance is difficult to scale as products and policies change. Whole-prompt rewriting can entangle changes to domain knowledge, decision heuristics, and output instructions. Broad harness-code editing provides more flexibility but also changes the tools or control flow that must be validated (Figure 1). This motivates a narrower adaptation object: external knowledge that can be revised while the executable decision process remains fixed. We therefore ask: can an industrial advertising agent improve its decision knowledge from evaluated trajectories without changing model weights or executable harness code?

Motivation: monolithic prompt, arbitrary harness, and KARMA comparison

Figure 1. Motivation. Whole-prompt rewriting obscures individual changes; broad harness editing complicates validation and rollback. KARMA freezes weights and code, derives atomic knowledge edits from successes and failures, and retains only patches whose validation gain reaches θ\theta.

Existing self-improving agents revise prompts, memories, workflows, or harnesses, mostly in coding and related environments [1, 3, 4, 8, 9, 24, 26]. Advertising introduces three considerations for this process. First, a wrong action type differs from a wrong direction within the correct type, so feedback should preserve this structure. Second, interacting rules can overgeneralize: a repair that helps failed cases may disrupt correct decisions. Third, tool and protocol failures must be distinguished from semantic errors before proposing knowledge changes. These considerations motivate structured diagnosis, evidence from both successes and failures, and an outcome-based acceptance gate.

We introduce KARMA (Knowledge-Atomic, Regression-Gated Modular Adaptation), a training-free framework that externalizes knowledge into six typed modules and restricts adaptation to schema-checked, journaled mutations. Rule modules preserve stable identifiers and provenance, allowing an edit to be inspected alongside the evidence that motivated it. The full knowledge context remains available during inference, while model weights, business tools, and executable code stay fixed. Each edit has an explicit target, and validation measures its effect on agent decisions.

A deterministic Trace Verifier maps observed failures to candidate knowledge modules and retains successful trajectories as context for repair. A Critic compares these evidence channels, and a tool-constrained Evolver translates suitable proposals into a small patch. The outer loop retains a patch only if its gain on a fixed validation set reaches θ\theta, and otherwise restores the full knowledge snapshot. An untouched hold-out set measures final generalization. Each cycle records the diagnostic evidence, knowledge changes, and validation outcome.

Our contributions are summarized as follows:

  • To our knowledge, we present the first training-free harness self-evolution framework designed and evaluated for an industrial advertising decision agent.

  • We make typed, rule-addressable knowledge the object of evolution. Schema-checked atomic edits, provenance, mutation journals, and full-directory snapshots support inspection and rollback while preserving the executable harness.

  • We combine deterministic component attribution with full success/failure ingestion: failures guide repair, while successes provide evidence for preserving effective behavior.

  • Across six domains and three LLM families, KARMA improves the average hold-out score by 8.96 points (+29.7%). Ablations, engine comparisons, and cross-domain transfers examine the design and its generalization.

Related Work

Training-Free Agent Adaptation

Tool-using agents combine language-model reasoning with external observations [15, 22]. Reflexion and Self-Refine use verbal feedback to improve subsequent attempts or iteratively revise outputs without additional weight updates [12, 16]. Prompt optimizers update instructions using task feedback: ProTeGi combines textual critiques with beam search [14], OPRO generates candidates from previously evaluated solutions [20], and GEPA combines reflective prompt updates through Pareto selection [1].

Persistent memories and skills offer another adaptation mechanism. ExpeL extracts reusable insights from successful and failed experiences [28], while Voyager accumulates executable skills through environment feedback and self-verification [18]. ACE maintains structured context playbooks through generation, reflection, and curation, using incremental updates to preserve accumulated knowledge [27]. RHO revisits challenging past tasks and selects harness updates through pairwise self-preference without labeled validation data [13]. RSIAgent constructs environment-specific memory through curriculum, actor, and verifier roles [29], while MetaSkill-Evolve adapts both task skills and the procedure that evolves them [19].

However, linking feedback to specific knowledge components and preserving effective behavior during revision remain challenging when decision rules interact.

Harness Evolution and Repair

Beyond individual prompts, DSPy optimizes modular language-model pipelines against task metrics [6], and TextGrad propagates textual feedback through computation graphs [23]. ADAS uses a meta agent to search code-defined agent designs [5]; AFlow searches executable workflows using Monte Carlo Tree Search and execution feedback [25].

Harness evolution extends adaptation to the runtime surrounding a frozen model. AHE exposes editable components, organizes execution evidence, and checks predicted edit outcomes in subsequent iterations [9]. Self-Harness mines failure patterns, proposes minimal modifications, and accepts them after regression testing [24]. Meta-Harness searches executable harness programs using the code, scores, and traces of prior candidates [8]; RHI instead refines prompt-level specifications of the agent loop through pairwise feedback over revision history [7].

Several methods explicitly address diagnosis and generalization. HarnessCompass combines constrained edits, proactive agent feedback, and component-wise optimization [26]. StarHarness stratifies evolution tasks and separates proposer-visible search from hidden selection tasks [4]. HarnessFix aligns traces with implementation artifacts to guide scoped repairs and regression-aware validation [3]. HarnessBank maintains diverse candidate harnesses in a gene bank and screens offspring through gated verification [11]. Related analyses distinguish the ability to generate useful harness updates from the ability to benefit from them during execution [10].

Editing executable harnesses expands the search space and the dependencies that must be validated. Even accepted changes may generalize unevenly across tasks, making evaluation beyond the optimization setting essential.

Commerce and Advertising Agents

Commerce agents span product search, customer interaction, and advertising decisions. WebShop evaluates grounded shopping agents that navigate product pages to satisfy user instructions [21]. In

advertising, RTBAgent combines click-through-rate estimates, expert strategies, memory retrieval, and daily reflection to inform bidding decisions [2]. HAT addresses changing harness configurations for live-commerce digital avatars through harness-state augmentation, supervised fine-tuning, distillation, and reinforcement learning [17].

These studies focus on specific interaction or bidding tasks; evidence on reusable knowledge updates spanning budget, bid, and item decisions across product domains remains limited.

Problem Formulation

Let xx denote the decision context of an advertising case, containing merchant and campaign identifiers, campaign type, and timestamp. The logged reference action y∗y^{*} and its details are kept separate from xx and are excluded from the inner agent’s inputs and tool observations. Reference actions are used only for scoring and outer-loop feedback after inference. The inner agent Aϕ(x;K)A_{\phi}(x; K) has frozen model parameters ϕ\phi and a mutable external knowledge state KK. It queries read-only business tools and emits a structured decision

y=(a,d,r,E),a∈{budget,bid,item},(1)y = (a, d, r, E), \qquad a \in\{\text{budget}, \text{bid}, \text{item}\}, \tag*{(1)}

where aa is the action type, dd the action direction, rr a rationale, and EE contains evidence identifiers. Budget and bid actions select increase or decrease; item actions select add or stop and additionally return item identifiers.

For a logged ground-truth action y∗y^*, let t(⋅)t(\cdot) and d(⋅)d(\cdot) denote action type and direction. We use a strict score

s(y,y∗)=121[t(y)=t(y∗)]+121[t(y)=t(y∗)∧d(y)=d(y∗)].(2)s(y,y^*)=\frac{1}{2}\mathbb{1}[t(y)=t(y^*)]+\frac{1}{2}\mathbb{1}[t(y)=t(y^*)\land d(y)=d(y^*)]. \tag*{(2)}

Here, 1[⋅]\mathbb{1}[\cdot] equals one when its condition holds and zero otherwise. A prediction with multiple action types, or with contradictory directions within the target type, receives no credit for the affected term. Execution failures score zero and remain in the denominator. The metric measures agreement in action type and direction; it does not assess item-identifier accuracy, adjustment magnitude, rationale quality, or downstream business utility.

Given TT training batches B1,…,BTB_1,\ldots,B_T, processed one per evolution cycle, a fixed validation set VV, and an untouched hold-out set HH, let

sˉD(K)=1∣D∣∑(x,y∗)∈Ds(Aϕ(x;K),y∗)(3)\bar{s}_D(K)=\frac{1}{|D|}\sum_{(x,y^*)\in D}s(A_\phi(x;K),y^*) \tag*{(3)}

denote the observed average score of knowledge KK on a set DD. Let K0K_0 be the initial knowledge, KtK_t the retained knowledge after cycle tt, and θ\theta the minimum validation gain required for acceptance. The goal is to construct KTK_T through atomic mutations such that each accepted update satisfies

sˉV(Kt)−sˉV(Kt−1)≥θ,(4)\bar{s}_V(K_t)-\bar{s}_V(K_{t-1})\geq\theta, \tag*{(4)}

while HH is never exposed to diagnosis, mutation, or selection. Final effectiveness is the paired gain sˉH(KT)−sˉH(K0)\bar{s}_H(K_T)-\bar{s}_H(K_0).

Method

System Overview

Figure 2 separates frozen decision execution from knowledge evolution. The inner agent renders current knowledge into its context and response schema, retrieves evidence, and emits a scored decision. The outer loop verifies trajectories, proposes and applies atomic edits, and retains them only after validation. Diagnosis, editing, and acceptance have distinct roles: the Critic proposes changes, the Evolver operates within the knowledge interface, and the deterministic outer loop controls validation and restoration. Accepted knowledge serves the next training batch.

KARMA overview

Figure 2. KARMA overview. The frozen inner agent collects evidence and emits structured decisions. The outer loop converts verified trajectories into atomic knowledge edits through the Critic and Evolver, then validates or rolls back each patch. The hold-out set is excluded from evolution.

Frozen Decision Agent

The context builder renders knowledge into a prompt πK\pi_K and response schema YKY_K that remain fixed within each trajectory:

(πK,YK)=Render⁡(K).(5)(\pi_K,Y_K)=\operatorname{Render}(K). \tag*{(5)}

A bounded two-stage protocol first collects evidence through whitelisted read-only business tools, then requires a standalone finish_analysis call before structured output. Each trace records the knowledge fingerprint, tool queries and observations, decision, termination reason, and protocol-error codes PP. Evidence identifiers EE must refer to successful tool responses, and the decision must conform to YKY_K. Violations trigger bounded corrective feedback. The trace links the output to the knowledge version and observations used during inference, supporting subsequent inspection of semantic and protocol errors. No advertising action is executed; tool and protocol details appear in Appendix A.

Typed Modular Knowledge

The knowledge state is a directory of six modules, K={Km}m∈MK=\{K_m\}_{m\in\mathcal{M}}, where M\mathcal{M} is the set of module identifiers (Table 1); the framework supports controlled edits to all six. Role, domain, and output protocol are typed text modules. Experience and constraints are ordered rule lists,

Km=⟨(li,σi,wi)⟩i=1nm,m∈{exp,con},(6)K_m=\langle(l_i,\sigma_i,w_i)\rangle_{i=1}^{n_m},\qquad m\in\{\mathrm{exp},\mathrm{con}\}, \tag*{(6)}

where exp and con abbreviate experience and constraints, nmn_m is the number of rules in module mm, lil_i is a stable rule identifier, σi\sigma_i its source, and wiw_i its text. Action descriptions parameterize YKY_K and the local finish tool in (5).

The registry is the only write boundary. An edit μ=(o,m,l,v)\mu=(o,m,l,v) uses operator o∈Oo\in\mathcal{O} and targets module mm, optionally rule ll, with value vv. Operators O={CREATE,UPDATE,DELETE,REPLACE}\mathcal{O}=\{\mathrm{CREATE},\mathrm{UPDATE},\mathrm{DELETE},\mathrm{REPLACE}\} support rule edits and text-module replacement. The predicate Valid checks schema validity across all six modules before writing:

Apply⁡(K,μ)={μ(K),Valid⁡(μ(K)),K,otherwise.(7)\operatorname{Apply}(K,\mu)= \begin{cases} \mu(K), & \operatorname{Valid}(\mu(K)),\\ K, & \text{otherwise}. \end{cases} \tag*{(7)}

Valid changes are written atomically to their target files and journaled with before/after values, and fp⁡(K)\operatorname{fp}(K) fingerprints the knowledge state.

This representation supports three aspects of controlled adaptation. Locality: each mutation names a rule or module field, so its textual scope is explicit. Auditability: stable identifiers, provenance, and before/after records connect edits to the diagnostic evidence from their cycle. Reversibility: a full-directory snapshot restores the pre-edit knowledge after rejection or error. A cycle permits at most three mutations, which are evaluated together as one candidate patch. Individual edits remain inspectable even when their effects interact during inference.

Verification and Full Ingestion

Without LLM calls, the verifier partitions scored batch trajectories Tt\mathcal{T}_t into full-credit successes StS_t, semantic failures Ft\mathcal{F}_t, and infrastructure errors RtR_t. Errors score zero but are reported separately. A semantic failure receives class c(x)c(x): no_action if output is absent, wrong_action_type if the type mismatches, and wrong_direction otherwise.

The candidate-module set α(x)\alpha(x) combines two fixed mappings to module sets: Γ\Gamma for failure classes and Λ\Lambda for protocol codes. With PxP_x denoting the protocol codes recorded for case xx,

α(x)=Γ(c(x))∪⋃p∈PxΛ(p)⊆M.(8)\alpha(x)=\Gamma(c(x))\cup\bigcup_{p\in P_x}\Lambda(p)\subseteq\mathcal{M}. \tag*{(8)}

For example, wrong action types map to domain and experience, where the interpretation of business context and decision heuristics reside. Wrong directions map to experience and constraints; protocol faults map to output protocol or action descriptions. These fixed mappings identify candidate modules for subsequent inspection. They provide a repeatable starting point for the Critic’s context-dependent analysis.

Failures and successes are then clustered by

κF(x)=(op⁡(x),c(x),α(x),Px),\kappa_F(x)=(\operatorname{op}(x),c(x),\alpha(x),P_x),
κS(x)=(op⁡(x),t(yx∗),d(yx∗)),(9)\kappa_S(x)=(\operatorname{op}(x),t(y_x^*),d(y_x^*)), \tag*{(9)}
ModuleResponsibility
roleAgent identity, objective, and communication stance
domainAdvertising products and operating semantics
experienceReusable decision heuristics with stable rule IDs
constraintsEvidence, comparison, and safety requirements
output_protocolAnalysis termination and structured submission rules
action_descriptionsField-level schema and local-tool descriptions

Table 1. Typed knowledge modules and their intended responsibilities.

DomainSymbolShare (%)
Home & LivingH\mathcal{H}24.8
AutomotiveA\mathcal{A}15.3
Electronics & OfficeE\mathcal{E}14.7
Fashion & ApparelF\mathcal{F}19.1
Beauty & HealthB\mathcal{B}8.2
Long-tail/OthersL\mathcal{L}17.9

Table 2. Corpus statistics and domain symbols. Each run uses 800 cases: 480 for training, 160 for validation, and 160 for hold-out evaluation.

where op⁡(x)\operatorname{op}(x) is the record’s reference operation, used only after inference, and yx∗y_x^* is its reference action. The report Dt=(Ft/κF,St/κS,Rt)D_t = (\mathcal{F}_t/\kappa_{\mathcal{F}}, S_t/\kappa_S, R_t) retains sample-level predictions, scores, rationales, evidence identifiers, and compact trace summaries. Here, Ft/κF\mathcal{F}_t/\kappa_{\mathcal{F}} and St/κSS_t/\kappa_S denote partitions into clusters with identical respective keys. Full ingestion covers all batch records. Failures indicate opportunities for repair, while successes expose conditions under which existing knowledge already works. A proposed general rule may match both groups; presenting them together lets the Critic consider that overlap before recommending a change. The evidence-channel ablations test the value of this joint context (§ 5.3).

Critic and Evolver

The Critic receives both the complete verifier report and the original trajectories in compact form, and returns a set of edit proposals

Pt=Critic⁡(Dt,Tt),Pt={(fk,δk,uk,mk,qk)}k.(10)P_t = \operatorname{Critic}(D_t, \mathcal{T}_t), \qquad P_t = \{(f_k, \delta_k, u_k, m_k, q_k)\}_k. \tag*{(10)}

The fields of each proposal denote a failure mode, diagnosis, proposed change, target module, and generality argument, respectively. The Critic compares failures with successes from four perspectives: missing knowledge, conflicting rules, protocol timing, and ambiguous wording. It has no direct knowledge access; the Evolver checks its proposals against current modules before deciding which edits to apply. The outer loop then measures the candidate patch’s effect through validation.

The Evolver then turns the report and proposals into a short patch of atomic edits,

Δt=Evolver⁡(Kt−1,Dt,Pt;O),\Delta_t = \operatorname{Evolver}(K_{t-1}, D_t, P_t; O),
Δt=(μ1,…,μk),0≤k≤M.(11)\Delta_t = (\mu_1, \ldots, \mu_k), \qquad0 \le k \le M. \tag*{(11)}

Sequential application through Equation (7) produces candidate K~t\widetilde{K}_t. The per-cycle mutation budget is M=3M = 3; the Evolver must inspect current knowledge, avoid sample-specific identifiers, and prefer no edit under uncertainty. The outer loop enforces the mutation budget and tool whitelist. Knowledge inspection and editing are allowed; business tools, shell access, and gate control are not.

Validation and Rollback

Before editing, the outer loop snapshots the knowledge directory. A cycle is eligible for gating only if it has semantic failures, a non-empty patch, and a real state change. Its eligibility indicator et∈{0,1}e_t \in\{0,1\} is

et=1[Ft≠∅∧∣Δt∣>0∧fp⁡(K~t)≠fp⁡(Kt−1)].(12)e_t = \mathbb{1}\left[\mathcal{F}_t \ne\varnothing\land|\Delta_t| > 0 \land\operatorname{fp}(\widetilde{K}_t) \ne\operatorname{fp}(K_{t-1})\right]. \tag*{(12)}

Here, ∣Δt∣|\Delta_t| is the number of edits in the patch. Cycles with Ft=∅\mathcal{F}_t = \varnothing skip the Critic and Evolver entirely; skipped or failed evolution cycles have et=0e_t = 0. For an eligible cycle, the validation gain gt=sˉV(K~t)−sˉV(Kt−1)g_t = \bar{s}_V(\widetilde{K}_t) - \bar{s}_V(K_{t-1}) instantiates Equation (4), and the knowledge update is

Kt={K~t,et=1∧gt≥θ,Kt−1,otherwise (restore snapshot),(13)K_t = \begin{cases} \widetilde{K}_t, & e_t = 1 \land g_t \ge\theta,\\ K_{t-1}, & \text{otherwise (restore snapshot),} \end{cases} \tag*{(13)}

with θ=0.01\theta= 0.01. On rejection or error, restoration returns the six-module knowledge directory to its pre-edit snapshot for subsequent batches.

Validation records for active knowledge are cached: the baseline is evaluated before the first Critic call, an accepted candidate replaces the cache, and rejection preserves it. Candidate inference is performed under the edited knowledge. Caching avoids repeatedly evaluating the unchanged reference state while retaining a fixed comparison for each proposal. Let NVN_V denote the number of full passes over VV. Then,

NV=1[∃t:Ft≠∅]+∑t=1Tet≤T+1,(14)N_V = \mathbb{1}[\exists t:\mathcal{F}_t \ne\varnothing] + \sum_{t=1}^{T} e_t \le T + 1, \tag*{(14)}

compared with 2T2T passes when naive A/B re-evaluation assesses both states in every cycle. Only after evolution are K0K_0 and KTK_T evaluated once each on HH. The gate constrains observed validation regressions and the separate hold-out set assesses whether retained changes generalize.

Experiments

The experiments address five questions: RQ1, whether knowledge evolution improves held-out decisions across domains and models;

RQ2, whether both evidence channels contribute; RQ3, how proposal engines compare under a shared gate; RQ4, whether knowledge transfers across domains; and RQ5, how gated evolution relates to hold-out generalization.

Experimental Setup

Dataset

We sample 800 cases per domain from approximately half a million July 2026 operation logs of verified merchants on a global e-commerce platform (Table 2). With seed 42, each domain has 480 training cases in six batches of 80, 160 validation cases, and 160 untouched hold-out cases. Logged actions provide behavioral supervision for action selection. The data source and industrial relevance of this study are further discussed in Appendix F.

Models and Baselines

We evaluate Qwen3.8-Max, GLM-5.3, and Kimi-K3, using the same family for the inner agent, Critic, and Evolver. Each main setting is run once from shared initial knowledge K0K_0, with θ=0.01\theta= 0.01 and at most three mutations per cycle. Baselines replace the evolution engine under the same protocol (Section 5.4); implementation details are in Appendix A.

Metrics

We report average action-agreement scores (Equation 3), absolute gains in points, and relative gains in percent. Scores and absolute gains are scaled by 100; θ=0.01\theta= 0.01 is one point. Hold-out gains compare KTK_T with K0K_0 on the same cases. Ablations and engine comparisons use the main-run Base as their common reference; aggregate relative gains use the corresponding mean scores.

Main Results

Table 3 compares initial and evolved knowledge across 18 domain–model settings. KARMA raises the average hold-out score from 30.19 to 39.15 (+8.96 points, +29.7%), improving 16 settings. The improvement spans all model families and multiple domains, supporting the usefulness of external knowledge evolution under a fixed executable harness.

LLMsDomainsValidation set VVHold-out set HH
BaseKARMAGainRel. (%)BaseKARMAGainRel. (%)
Qwen3.8-MaxH\mathcal{H}33.1350.63+17.50+52.832.8148.75+15.94+48.6
A\mathcal{A}39.0641.25+2.19+5.635.6336.25+0.63+1.8
E\mathcal{E}34.3848.75+14.38+41.833.1343.44+10.31+31.1
F\mathcal{F}34.6943.75+9.06+26.126.8838.44+11.56+43.0
B\mathcal{B}35.3150.00+14.69+41.629.0647.19+18.13+62.4
L\mathcal{L}33.7546.88+13.13+38.931.8847.81+15.94+50.0
Avg.35.0546.88+11.82+33.731.5643.65+12.08+38.3
GLM-5.3H\mathcal{H}26.8842.81+15.94+59.326.5640.31+13.75+51.8
A\mathcal{A}40.0045.00+5.00+12.534.6936.25+1.56+4.5
E\mathcal{E}36.2542.50+6.25+17.230.9439.06+8.13+26.3
F\mathcal{F}27.8139.06+11.25+40.424.0636.25+12.19+50.6
B\mathcal{B}30.0038.13+8.13+27.127.5039.69+12.19+44.3
L\mathcal{L}32.1936.56+4.38+13.629.3835.00+5.63+19.1
Avg.32.1940.68+8.49+26.428.8537.76+8.91+30.9
Kimi-K3H\mathcal{H}28.1341.25+13.13+46.726.8836.88+10.00+37.2
A\mathcal{A}39.3844.38+5.00+12.740.3137.19−3.13−7.8
E\mathcal{E}38.4441.25+2.81+7.332.8130.94−1.88−5.7
F\mathcal{F}31.2540.63+9.38+30.024.6933.13+8.44+34.2
B\mathcal{B}30.0036.88+6.88+22.925.9442.19+16.25+62.7
L\mathcal{L}28.1337.50+9.38+33.330.3135.94+5.63+18.6
Avg.32.5540.31+7.76+23.830.1636.04+5.89+19.5

Table 3. Main results on 160 cases per set (scores ×100\times100). Base: K0K_0; KARMA: KTK_T; Gain: absolute points; Rel.: percentage gain over Base. Bold marks the higher score. Avg. averages six domains before rounding; symbols follow Table 2.

All three families gain on average: +12.08 for Qwen3.8-Max, +8.91 for GLM-5.3, and +5.89 for Kimi-K3. Qwen3.8-Max and GLM-5.3 improve in every domain, whereas Kimi-K3 improves in four. Because each family fills the inner-agent, Critic, and Evolver roles, these differences combine decision, diagnosis, and editing ability. Kimi-K3 starts above GLM-5.3 on average but ends below it after evolution, suggesting that stronger initial performance does not necessarily yield greater benefits from knowledge evolution.

Across domains, the largest model-averaged hold-out gains occur in B\mathcal{B} (+15.52), H\mathcal{H} (+13.23), and F\mathcal{F} (+10.73). Benefits are smaller on E\mathcal{E} and L\mathcal{L}, and A\mathcal{A} shows little net change. The overall gain therefore coexists with substantial variation in how useful the selected knowledge changes are for each setting.

Kimi-K3 regresses on A\mathcal{A} (−3.13) and E\mathcal{E} (−1.88), each after a single early patch. Section 5.6 examines the operation-level changes on A\mathcal{A}. Additional runs with five data seeds for Qwen3.8-Max on E\mathcal{E} all yield positive hold-out gains, but their magnitude ranges from +0.94 to +11.25 (Appendix C.1). The gains remain positive across these seeds, with substantial variation in magnitude.

Evidence Ablations

To assess full ingestion, we remove successful clusters and raw cases (w/o success, failure-only reflection) or failed clusters and raw cases (w/o failure, success-only consolidation), keeping the loop, gate, and mutation budget fixed. Both variants use Qwen3.8-Max on H\mathcal{H}, B\mathcal{B}, and L\mathcal{L} with the main run’s split and batch order. All gains use the common main-run Base.

Removing either channel more than halves the average hold-out gain relative to the common Base: +16.67 for KARMA, versus +8.23 without successes and +6.56 without failures (Table 4). Full ingestion scores highest in every domain on both validation and hold-out sets. The advantage therefore appears in the final evaluation as well as in the scores used for selection.

DomainsVariantsValidation set VVHold-out set HH
ScoreGainRel. (%)ScoreGainRel. (%)
H\mathcal{H}Base33.13––32.81––
w/o success39.69+6.56+19.843.75+10.94+33.3
w/o failure38.44+5.31+16.035.63+2.81+8.6
KARMA50.63+17.50+52.848.75+15.94+48.6
B\mathcal{B}Base35.31––29.06––
w/o success37.19+1.88+5.336.88+7.81+26.9
w/o failure39.38+4.06+11.539.38+10.31+35.5
KARMA50.00+14.69+41.647.19+18.13+62.4
L\mathcal{L}Base33.75––31.88––
w/o success40.63+6.88+20.437.81+5.94+18.6
w/o failure41.88+8.13+24.138.44+6.56+20.6
KARMA46.88+13.13+38.947.81+15.94+50.0

Table 4. Evidence ablation with Qwen3.8-Max. Bold marks the best score per domain and set.

Neither single channel dominates: failure-only evidence is stronger on H\mathcal{H}, success-only evidence on B\mathcal{B}, and the two are close on L\mathcal{L}. Success-only consolidation also produces positive hold-out gains in all three domains. Failure evidence directs repair toward incorrect decisions, while successful cases provide examples of behavior to retain or generalize.

Evolution Engine Comparison

We compare proposal mechanisms while holding the outer loop and validation gate fixed. We replace the Critic and Evolver with GEPA [1], AHE [9], or Self-Harness [24], re-implemented on the same knowledge directory and mutation interface. All engines use Qwen3.8-Max, the same split and batch order, and θ=0.01\theta= 0.01. We evaluate on the largest domain H\mathcal{H} and smallest B\mathcal{B}; implementation details are in Appendix A.4.

KARMA achieves the largest gain in every performance column (Table 5). On H\mathcal{H}, its hold-out gain is +15.94, compared with +9.06 for GEPA and +8.75 for AHE. On B\mathcal{B}, it gains +18.13, while the strongest alternative, AHE, gains +6.56. GEPA and Self-Harness show hold-out regressions in one domain each. The engines produce different hold-out outcomes despite sharing the same knowledge interface and acceptance gate.

MethodValidation set VV H\mathcal{H}Validation set VV B\mathcal{B}Hold-out set HH H\mathcal{H}Hold-out set HH B\mathcal{B}Cost TokensCost Hours
GEPA+11.25+1.56+9.06−1.8842.15M4.58
AHE+11.56+5.94+8.75+6.5640.74M3.40
Self-Harness+3.75+3.13−2.50+2.5040.72M3.60
KARMA+17.50+14.69+15.94+18.1341.48M4.53

Table 5. Evolution engines with Qwen3.8-Max. Tokens: mean total LLM tokens per cycle, including agent inference. Hours: runtime per cycle.

Mean tokens per cycle is similar across engines, while end-to-end runtime varies. KARMA achieves the largest hold-out gains in both domains at a comparable token cost.

Cross-Domain Transfer

To examine whether knowledge is tied to its source domain, we freeze the final knowledge evolved by Qwen3.8-Max on each source and evaluate it on the other five domains without further mutation. Each of the 30 source–target entries uses the target’s main-run Base hold-out score as its reference (Table 6). The comparison tests transfer of the knowledge state with the model and target cases held fixed.

SourceTarget domain H\mathcal{H}Target domain A\mathcal{A}Target domain E\mathcal{E}Target domain F\mathcal{F}Target domain B\mathcal{B}Target domain L\mathcal{L}
H\mathcal{H}−−0.63+7.81+17.50+12.19+19.38
A\mathcal{A}−5.00−−4.06−5.94−1.88−5.94
E\mathcal{E}+10.63+9.38−+13.44+15.31+10.00
F\mathcal{F}+5.94−3.44+8.75−+10.00+13.44
B\mathcal{B}+10.63+7.19+6.88+11.88−+15.94
L\mathcal{L}+13.13+11.88+9.06+19.69+23.13−

Table 6. Cross-domain hold-out gains with Qwen3.8-Max, relative to each target’s main-run Base. Bold marks gains exceeding the target’s in-domain gain.

The 30 source–target pairs average +8.54 points, about 71% of the average in-domain gain (+12.08); 23 are positive and nine exceed the target’s in-domain gain. Knowledge from L\mathcal{L} transfers best to every other domain, averaging +15.38. For example, it gains +23.13 on B\mathcal{B}, compared with +18.13 from that domain’s own evolution. Evolved knowledge is reusable across several product categories, with transfer effectiveness varying by source.

All seven negative entries involve A\mathcal{A}. Its evolved knowledge lowers the score of every other domain, while A\mathcal{A} benefits more from several other sources than from its own evolution. Excluding A\mathcal{A} as source or target leaves 20 positive entries averaging +12.73. Automotive is a weak source of transferable knowledge in these runs, even though it benefits from knowledge evolved elsewhere. Section 5.6 examines this heterogeneity.

Automotive Anomaly

The small aggregate changes on A\mathcal{A} conceal improvements and regressions across operation types (Figure 3). Qwen3.8-Max gains on price updates while losing on item operations; GLM-5.3 benefits mainly on additions; Kimi-K3’s losses concentrate in deletions.

Hold-out score changes on $\mathcal{A}$ by reference operation

Figure 3. Hold-out score changes on A\mathcal{A} by reference operation (ADD/DEL: add/delete offer; BUD/PRI: update budget/price). Bars sum to each model’s gain in Table 3, up to rounding.

Sample-level changes can offset one another, leaving little net gain despite altered decisions.

Mutation records and rationales show new decision priorities alongside existing heuristics. Stable rule identifiers make potential interactions easier to inspect. Transfer results show similar heterogeneity: knowledge evolved on A\mathcal{A} harms every other domain, while several other sources improve A\mathcal{A} (Table 6).

Gate Dynamics

Figure 4 shows stepwise improvements separated by plateaus. Rejected patches leave the active knowledge and cached score unchanged, so these curves track the validation scores of retained knowledge states. Useful updates occur at different stages across models and domains: some runs improve early, while others gain after longer plateaus. Appendix § 12 illustrates accepted and rejected cycles, and Appendix § 11.§ 2 examines alternative thresholds.

Cached validation scores during evolution across six domains

Figure 4. Cached validation scores during evolution (scores ×100; Init: K0K_0). Filled markers denote accepted patches; hollow markers denote rejection, which preserves the active knowledge and cached score.

Validation and hold-out improvements are broadly consistent (Table 3), but agreement is weaker on A\mathcal{A}. The gate selects patches using observed validation scores and does not guarantee hold-out improvement. Final evaluation on H\mathcal{H} provides a separate assessment of generalization.

Limitations and Future Work

Logged actions may encode historical policy biases; agreement does not establish gains in revenue, welfare, or fairness. KARMA is a research system evaluated offline without executing actions. Future work will consider deployment with business guardrails, monitoring, human oversight, and prospective evaluation. Experiments use access controls and anonymized reporting; direct merchant and campaign identifiers are not released. Deterministic attribution may miss complex interactions, and repeated selection on a fixed validation set can favor changes that do not carry over to hold-out or transfer evaluation. Each main configuration is run once; additional seed, threshold, and comparison studies cover selected settings. Generalization beyond the sampled cases, period, and platform remains open. The framework addresses external knowledge adaptation and cannot repair faulty tools or orchestration code.

Conclusion

We presented KARMA, a training-free framework for evolving typed, rule-addressable knowledge in advertising agents. Deterministic verification, success/failure reflection, constrained mutation, and validation-gated rollback link retained updates to diagnostic evidence and measured outcomes. Across six domains and three model families, KARMA raises the average hold-out score from 30.19 to 39.15 (+29.7%). Ablations support using both evidence channels, while cross-domain transfer yields an average gain of 8.54 points. KARMA supports inspectable, reversible knowledge adaptation while keeping model weights and executable harness code fixed.

References

Implementation Details

Data and Runtime Setup

Records contain decision context and one historical operation: ADD_OFFER, DELETE_OFFER, UPDATE_BUDGET, or UPDATE_PRICE, mapped to item-add, item-stop, budget-direction, or bid-direction labels. Identifiers support access-controlled queries and are excluded from evolved knowledge. Domain records are shuffled with the run seed before selecting 800 cases; the first 160 form VV, the next 160 form HH, and the remaining 480 are shuffled into training batches.

Initial knowledge K0K_0 comes from existing advertising instructions. Thinking is enabled at medium effort; inner inference permits 12 turns and two protocol corrections, and evolution permits eight turns, six Critic proposals, and three mutations. The Critic uses one structured call with at most one formatting retry. Read-only tools retrieve merchant, advertisement, industry, item, and budget-utilization data; failed responses cannot supply evidence identifiers.

Observed errorCandidate modules
Missing decisionOutput protocol, role
Wrong action typeDomain, experience
Wrong directionExperience, constraints

Table 7. Default routing of semantic failures. Protocol codes can add candidate modules to these assignments.

Algorithm 1 KARMA knowledge evolution

Require: Initial knowledge $K_0$, batches $B_{1:T}$, sets $V,H$
Require: Threshold $\theta$, mutation budget $M$
Ensure: Final knowledge $K_T$ and hold-out gain
1: $K \gets \operatorname{Copy}(K_0)$; $C_V \gets \perp$
2: for $t = 1,\ldots,T$ do
3:   $\mathcal{T}_t \gets \operatorname{RunAndScore}(B_t,K)$
4:   $S \gets \operatorname{Snapshot}(K)$
5:   $\mathcal{D}_t \gets \operatorname{Verify}(\mathcal{T}_t)$
6:   if $\mathcal{F}_t = \varnothing$ then
7:     continue
8:   end if
9:   if $C_V = \perp$ then
10:     $C_V \gets \operatorname{Evaluate}(V,K)$
11:   end if
12:   $\mathcal{P}_t \gets \operatorname{Critic}(\mathcal{D}_t,\mathcal{T}_t)$
13:   $(\widetilde{K},\Delta_t) \gets \operatorname{Evolve}(K,\mathcal{D}_t,\mathcal{P}_t,M)$
14:   if candidate is ineligible then
15:     $K \gets \operatorname{Restore}(S)$; continue
16:   end if
17:   $\widetilde{C}_V \gets \operatorname{Evaluate}(V,\widetilde{K})$
18:   if $\operatorname{Mean}(\widetilde{C}_V)-\operatorname{Mean}(C_V) \geq \theta$ then
19:     $K \gets \widetilde{K}$; $C_V \gets \widetilde{C}_V$
20:   else
21:     $K \gets \operatorname{Restore}(S)$
22:   end if
23: end for
24: $K_T \gets K$
25: Evaluate $K_0$ and $K_T$ once each on $H$
26: return $K_T$ and $\bar{s}_H(K_T)-\bar{s}_H(K_0)$

Diagnostic Evidence

The verifier report combines a cluster-level overview with the records needed to inspect individual decisions. Each failure cluster contains its frequency, operation, error class, candidate modules, and protocol codes. Its member records retain the prediction, component scores, rationale, evidence identifiers, and execution status. Clusters are ordered by frequency, giving the Critic an overview of recurring errors while retaining access to less frequent cases. Failure and success mode identifiers are local to each batch; rule identifiers persist in the knowledge state.

Table 7 gives the default semantic-error mapping in Equation (8). Protocol codes can add modules to this set. For example, malformed output fields implicate action descriptions, while tool-call and termination faults can implicate output protocol. Successful cases are grouped separately by reference operation, type, and direction. Infrastructure errors have their own report channel and contribute zero to the aggregate score.

Full ingestion preserves the batch membership across these channels. Long interaction traces are represented by compact process summaries containing turn stages, tool names and statuses, termination reasons, and evidence counts. The Critic can therefore compare successful and failed decisions alongside their execution context.

Critic and Evolver Guidance

The fixed Critic instructions ask for reusable decision criteria supported by the batch evidence. Each candidate identifies a failure mode and a reflection perspective, explains the diagnosis, proposes a change, names a target module, and states why the proposal should apply beyond the observed cases. The four perspectives focus on missing knowledge, conflicting rules, protocol timing, and ambiguous wording. The Critic is instructed to compare failures with successful cases and to omit candidates when the evidence offers no useful revision.

The Evolver is instructed to inspect the relevant modules before editing and to assess each proposal against the existing knowledge. It may approve a proposal, adapt it, or reject it with an explanation. Its guidance favors reusable evidence requirements and decision priorities, excludes case-specific identifiers from rule text, and calls for checking knowledge validity after changes. Tool feedback reports invalid arguments or schema violations so that the Evolver can revise its requests. The tool interface enforces the permitted operations and mutation budget; the outer loop determines whether the resulting patch is retained.

Engine Implementations

GEPA reflects on the verifier report and retains a candidate only if it outperforms its parent on eight training cases. AHE requires failure evidence and a predicted effect for each edit, then checks that prediction in the next cycle. Self-Harness proposes a minimal edit for the largest failure cluster and discards it if a second LLM call predicts changes to correctly handled cases. All use the same knowledge interface and outer gate. Token accounting includes engine calls and inference on the 80 training and 160 validation cases of a full cycle; runtime includes final hold-out evaluation.

Interfaces and Artifacts

The interface supports editing all six knowledge modules through create_rule, update_rule, delete_rule, update_text_module, and update_action_description, with reads, validation, and context preview. The outer loop controls the whitelist, mutation budget, snapshots, and restoration. Run artifacts record split membership, traces, scores, knowledge states, mutation journals, fingerprints, and gate decisions. Identifiers, proprietary tool responses, and credentials are excluded from public reporting.

Evolution Procedure

Algorithm 1 uses the fixed split described in Appendix A. CVC_V stores validation records and Mean(CVC_V) their average score. Here, Ft\mathcal{F}_t is the semantic-failure set identified by Verify(Tt\mathcal{T}_t), and ⊥\bot denotes an uninitialized validation cache. Eligibility follows Equation (12); an evolution error also makes a candidate ineligible.

State Management

Algorithm 1 maintains three complementary records: a snapshot for restoration, cached validation results for comparison, and a mutation journal for inspection. A fingerprint computed from the normalized module contents identifies changes to the knowledge state. After a successful write or restoration, the knowledge-loading cache is invalidated so that subsequent inference renders the current modules. This loading cache is separate from the validation cache CVC_V, which stores completed evaluation records.

When a candidate is accepted, its knowledge state and validation records become the reference for the next cycle. Rejection restores the snapshot and retains the previous validation reference. The mutation journal is stored outside the knowledge directory and preserves the edited module, target, and before/after contents; restoration is also logged. Thus, a rejected patch remains available for inspection after the active knowledge has been restored.

The cycle record brings together the snapshot, knowledge fingerprints, verifier report, Critic proposals, actual mutations, and gate outcome. Reading these artifacts in sequence connects the evidence that motivated a proposal to the edits applied and the validation decision. Proposal text records the intended change, while the mutation journal records the change actually made.

Robustness Checks

Data Seed

We repeat Qwen3.8-Max on E\mathcal{E} with seeds 43–46 in addition to 42. Seeds control case selection, partitioning, and batch order, but not LLM sampling; variation therefore combines both sources. All five hold-out gains are positive (+0.94 to +11.25; mean +6.06), with seed 42 toward the upper end (Table 8).

SeedValidation set VVHold-out set HH
BaseKARMAGainBaseKARMAGain
42†34.3848.75+14.3833.1343.44+10.31
4335.3144.38+9.0632.1943.44+11.25
4430.6335.31+4.6931.5632.50+0.94
4530.0038.44+8.4429.3832.81+3.44
4630.6340.94+10.3135.0039.38+4.38
Mean32.1941.56+9.3832.2538.31+6.06

Table 8. Data-seed variation for Qwen3.8-Max on E\mathcal{E} (scores ×100). Seed 42† is the main run in Table 3. Means are computed before rounding.

Gate Threshold

For Qwen3.8-Max on H\mathcal{H}, B\mathcal{B}, and L\mathcal{L}, five of six alternative domain–threshold combinations retain the default gains. Raising θ\theta reduces the gain on L\mathcal{L}, but every gain remains positive (Table 9). The shared default θ=0.01\theta= 0.01 was not selected using hold-out results.

DomainValidation set VVHold-out set HH
0.0050.010.020.0050.010.02
H\mathcal{H}+17.50+17.50+17.50+15.94+15.94+15.94
B\mathcal{B}+14.69+14.69+14.69+18.13+18.13+18.13
L\mathcal{L}+13.13+13.13+10.00+15.94+15.94+12.50

Table 9. Gate-threshold sensitivity with Qwen3.8-Max.

Case Studies

Figure 5 shows the largest accepted gain and rejected loss among 108 gated cycles. Both occur at cycle 2 on E\mathcal{E}.

Contrasting evolution cycles on $\mathcal{E}$

Figure 5. Contrasting evolution cycles on E\mathcal{E}: (a) Qwen3.8-Max’s largest accepted validation gain (+11.88) and (b) Kimi-K3’s largest rejected loss (−6.88). Each panel follows diagnosis, proposals, mutations, validation against the cached baseline, and hold-out behavior. Final hold-out gains reflect all retained edits. Aggregate scores use the 0–100 scale; sample scores use 0–1; θ\theta = 1 point. Rule texts translate the Chinese originals; FM/SM denote batch failure/success clusters. ADD/DEL/BUD/PRI denote the four reference operations.

Accepted cycle. For Qwen3.8-Max, the verifier groups 50 failures into ten modes. The Evolver adopts two of six proposals and generalizes them into rules E17–E19, while consulting successes to avoid overbroad changes. Validation improves from 36.88 to 48.75 (+11.88), so the gate retains the patch. Final knowledge, including edits from cycles 1 and 2, improves hold-out performance from 33.13 to 43.44 (+10.31), with both corrected and degraded cases. A corrected rationale explicitly cites E17/E18, illustrating rule-level traceability.

Rejected cycle. For Kimi-K3, the verifier finds 56 failures, including 40 wrong action types. Rationales implicate rigid budget-consumption thresholds; the Evolver deletes E06 and E12 and rewrites E07. Validation falls from 41.25 to 34.38 (−6.88), triggering restoration. The rejected patch is never evaluated on H\mathcal{H}, so its hold-out effect is unknown. Conversely, Kimi-K3’s accepted patch on A\mathcal{A} improves validation but regresses on hold-out (§ 5.6).

The accepted cycle adds decision rules to the retained knowledge, while the rejected cycle restores the previous state after a measured validation loss.

Discussion

The evidence ablations and engine comparisons examine two design choices: which trajectories inform an update and how proposals are generated. Full ingestion performs best among the evaluated evidence variants, and proposal engines produce different outcomes under a common acceptance rule. Transfer evaluation then measures how the retained knowledge performs in other product domains. These comparisons connect the design of the update process to its observed effectiveness and generalization.

For Web advertising, this separation offers a way to maintain operating knowledge across heterogeneous product categories while preserving the surrounding executable system. Transfer can make a learned rule set useful beyond its source, but the outcomes involving A\mathcal{A} show why reuse still requires evaluation in the target setting. Versioned rules and mutation records provide a basis for inspecting both improvements and regressions as those policies evolve.

Evaluation remains offline and measures agreement with logged actions. Experiments use access-controlled data and anonymized reporting. Deployment with monitoring and human oversight is a direction for future work; broader limitations and governance considerations appear in § 6.

Industry Relevance

We submit this work as an Industry Paper because it addresses the practical maintenance of advertising-agent knowledge using real merchant data from AliExpress. Our dataset comprises historical merchant operation logs across six e-commerce domains, covering budget, bid, and advertised-item decisions. These records ground the task and evaluation in actual marketplace operations. KARMA enables operating knowledge to be revised without retraining the model or changing executable code, while traceable edits, validation, and rollback support inspection and controlled updates. The experiments provide offline evidence of improved action agreement and cross-domain knowledge reuse in this industrial setting. Future work will explore deployment with business guardrails, monitoring, and human oversight.

References

  1. [1]Lakshya A Agrawal, Shangyin Tan, Dilara Soylu, Noah Ziems, Rishi Khare, Krista Opsahl-Ong, Anrav Singhvi, Herumb Shandilya, Michael J Ryan, Meng Jiang, et al. 2026. Gepa: Reflective prompt evolution can outperform reinforcement learning. In International Conference on Learning Representations, Vol. 2026. 8479–8565.arxiv.org/abs/2507.19457
  2. [2]Leng Cai, Junxuan He, Yikai Li, Junjie Liang, Yuanping Lin, Jiming Quan, Yawen Zeng, and Jin Xu. 2025. RTbagent: A llm-based agent system for real-time bidding. In Companion Proceedings of the ACM on Web Conference 2025. 104–113.arxiv.org/abs/2502.00792
  3. [3]Mengzhuo Chen, Junjie Wang, Zhe Liu, Yawen Wang, Haiming Zheng, and Qing Wang. 2026. From Failed Trajectories to Reliable LLM Agents: Diagnosing and Repairing Harness Flaws. arXiv preprint arXiv:2606.06324 (2026).
  4. [4]Esakkivel Esakkiraja, Denis Akhiyarov, Vikas Yadav, Sai Rajeswar, Patrice Bechard, Sridhar Nemala, and Sagar Davasam. 2026. StarHarness: Evolving harnesses with stratified search for enterprise environments. arXiv preprint arXiv:2608.24804 (2026).arxiv.org/abs/2608.24804
  5. [5]Shengran Hu, Cong Lu, and Jeff Clune. 2025. Automated design of agentic systems. In International Conference on Learning Representations, Vol. 2025. 21344–21377.
  6. [6]Omar Khattab, Arnav Singhvi, Pardhi Maheshwari, Zhiyuan Zhang, Keshav Santhanam, Saiful Haq, Ashutosh Sharma, Thomas Joshi, Hanna Moazam, Heather Miller, et al. 2024. Dsypy: Compiling declarative language model calls into state-of-the-art pipelines. In International Conference on Learning Representations, Vol. 2024. 54928–54958.
  7. [7]Hyunin Lee, Jinglue Xu, Jeffrey Seely, Donghyun Lee, Matei Zaharia, and Yujin Tang. 2026. Recursive Harness Self-Improvement. arXiv preprint arXiv:2607.15524 (2026).arxiv.org/abs/2607.15524
  8. [8]Yoonho Lee, Roshen Nair, Qizheng Zhang, Kangwook Lee, Omar Khattab, and Chelsea Finn. 2026. Meta-harness: End-to-end optimization of model harnesses. arXiv preprint arXiv:2603.28052 (2026).arxiv.org/abs/2603.28052
  9. [9]Jiahang Lin, Shichun Liu, Chengjun Pan, Lizhi Lin, Shihan Dou, Zhiheng Xi, Xuanjing Huang, Hang Yan, Zhenhua Han, Tao Gui, et al. 2026. Agentic harness engineering: Observability-driven automatic evaluation of coding-agent harnesses. arXiv preprint arXiv:2604.25850 (2026).arxiv.org/abs/2604.25850
  10. [10]Minhua Lin, Junchen Wu, Zijun Wang, Zhan Shi, Yisi Sang, Bing He, Zewen Liu, Tianxin Wei, Zongyu Wu, Zhiwei Zhang, Dakun Wang, Xiang Zhang, Benoit Dumoulin, Cihang Xie, Yujin Zhou, Suhang Wang, and Hanqing Lu. 2026. Harness Updating Is Not Harness Benefit: Disentangling Evolution Capabilities in Self-Evolving LLM Agents. arXiv:2605.30621 [cs.AI] https://arxiv.org/abs/2605.30621
  11. [11]Xiaotian Luo, Dizhan Xue, Fengxingyu Wang, Chuanhui Hu, and Yafeng Deng. 2026. HarnessBank: Semantic gene-bank search with gated verification for agent-harness self-evolution. arXiv preprint arXiv:2607.13683 (2026).arxiv.org/abs/2607.13683
  12. [12]Aman Madaan, Niket Tandon, Prakhar Gupta, Skyler Hallinan, Luyu Gao, Sarah Wiegreffe, Uri Alon, Nouha Dziri, Shrimai Prabhumoye, Yiming Yang, et al. 2023. Self-refine: Iterative refinement with self-feedback. Advances in neural information processing systems 36 (2023), 46534–46594.
  13. [13]Wenbo Pan, Shujie Liu, Chin-Yew Lin, Jingying Zeng, Xiamfeng Tang, Xiangyang Zhou, Yan Lu, and Xiaohua Jia. 2026. Evolving Agents in the Dark: Retrospective Harness Optimization via Self-Reference. arXiv preprint arXiv:2606.05922 (2026).arxiv.org/abs/2606.05922
  14. [14]Reid Pryzant, Dan Iter, Jerry Li, Yin Lee, Chenguang Zhu, and Michael Zeng. 2023. Automatic prompt optimization with “gradient descent” and beam search. In Proceedings of the 2023 conference on empirical methods in natural language processing. 7957–7968.arxiv.org/abs/2305.03495
  15. [15]Timo Schick, Jane Dwivedi-Yu, Roberto Dessì, Roberta Răileanu, Maria Lomeli, Eric Hambro, Luke Zettlemoyer, Nicola Cancedda, and Thomas Scialom. 2023. Toolformer: Language models can teach themselves to use tools. Advances in neural information processing systems 36 (2023), 68539–68551.arxiv.org/abs/2302.04761
  16. [16]Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. 2023. Reflection: Language agents with verbal reinforcement learning. Advances in neural information processing systems 36 (2023), 8634–8652.arxiv.org/abs/2303.11366
  17. [17]AIGC TaoLive, Yuhan Sun, Wenhao Lin, Yongdong Luo, Yibo Hu, Meiguang Jin, Junfeng Ma, Weihang Pan, Jiaxin Zhao, and Zulong Chen. 2026. Training Agents to Evolve with Their Harness: TaoLive Digital Avatar Agent Technical Report. arXiv preprint arXiv:2608.15763 (2026).arxiv.org/abs/2608.15763
  18. [18]Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. 2023. Voyager: An open-ended embodied agent with large language models. arXiv preprint arXiv:2305.16921 (2023).
  19. [19]Zefeng Wang, Minxi Yuan, Jinbo Bi, Sikuang Yan, Volker Tresp, and Yunpu Ma. 2026. MetaSkill-Evolve: Recursive Self-Improvement of LLM Agents via Two-Timescale Meta-Skill Evolution. arXiv preprint arXiv:2607.05297 (2026).arxiv.org/abs/2607.05297
  20. [20]Chengrun Yang, Quezhu Wang, Yifeng Lu, Hanxiao Liu, Quoc V Le, Denny Zhou, and Xinyun Chen. 2024. Large language models as optimizers. In International Conference on Learning Representations, Vol. 2024. 12028–12068.arxiv.org/abs/2309.03409
  21. [21]Shunyu Yao, Howard Chen, John Yang, and Karthik Narasimhan. 2022. Webshop: Towards scalable real-world web interaction with grounded language agents. Advances in Neural Information Processing Systems 35 (2022), 20744–20757.arxiv.org/abs/2207.01206
  22. [22]Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. 2022. React: Synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.03629 (2022).arxiv.org/abs/2210.03629
  23. [23]Mert Yuksekgonul, Federico Bianchi, Joseph Boen, Sheng Liu, Pan Lu, Zhi Huang, Carlos Guestrin, and James Zou. 2025. Optimizing generative AI by backpropagating language model feedback. Nature 639, 8055 (2025), 609–616.DOI
  24. [24]Hangfan Zhang, Shao Zhang, Kangcong Li, Chen Zhang, Yan Chen, Yiqun Zhang, Lei Bai, and Shuyue Hu. 2026. Self-harness: Harnesses that improve themselves. arXiv preprint arXiv:2606.09498 (2026).arxiv.org/abs/2606.09498
  25. [25]Jiayi Zhang, Jinyu Xiang, Zhaoyang You, Fengwen Teng, Xionghui Chen, Jiaqi Chen, Mingchen Zhuge, Xin Cheng, Sirui Hong, Jinlin Wang, et al. 2025. Aflow: Automating agentic workflow generation. In International Conference on Learning Representations, Vol. 2025. 34040–34077.arxiv.org/abs/2410.10762
  26. [26]Luan Zhang, Rorchen Zhu, Dandan Song, Zhengyu Chen, Yuhang Tian, Jun Yang, Huipeng Ma, Chenhao Li, Guangyuan Feng, Xudong Li, et al. 2026. Harnesscompass: Guiding automatic harness evolution toward generalizable and effective agent harnesses. arXiv preprint arXiv:2608.01918 (2026).arxiv.org/abs/2608.01918
  27. [27]Qizheng Zhang, Changran Hu, Shuhang Jupasani, Boyuan Ma, Fenglu Hong, Yamsidhar Kamanuru, Jay Rainton, Chen Wu, Mengmeng Li, Hanchen Li, et al. 2026. Agentic context engineering: Evolving contexts for self-improving language models. In International Conference on Learning Representations, Vol. 2026. 86069–86100.arxiv.org/abs/2510.04618
  28. [28]Andrew Zhao, Daniel Huang, Quentin Xu, Matthieu Lin, Yong-Jin Liu, and Gao Huang. 2024. Expel: LLM agents are experiential learners. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 38. 19632–19642.arxiv.org/abs/2308.10144
  29. [29]Sibo Zhu, Shicheng Fan, Xinyue Wang, Wenyi Wu, Kun Zhou, and Biwei Huang. 2026. RSIAgent: Autonomous exploration for recursive self-improvement in new environments. arXiv preprint arXiv:2609.15364 (2026).arxiv.org/abs/2609.15364

Paper details

vlnc:W_9kxyd7uk
Version
v2 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents