Zhengyao Jiang on Weko: Recursive Self-Improvement Starts With the Agent Harness

1. Guest Background

This episode of Machine Learning Street Talk, hosted by Tim Scarfe and co-hosts, is an interview and analysis centered on Zhengyao Jiang and Weko AI's recursive self-improvement experiments. Jiang is identified in the evidence as co-founder and CEO of Weko AI, a London-based AI company building self-improving agents. The subject is not a generic tour of agent tooling. The episode asks whether an AI system can begin bending the intelligence curve by rewriting the research harness around a model rather than rewriting the model weights themselves.

The guest's relevant experience is tied directly to Weko's product work. Weko created Aid, described as a research harness that can optimize toward a given metric or problem. In the episode's framing, Aid is given a problem and a metric, then hill-climbs toward the target. Weko's experiment makes this recursive: the auto-research system is used to improve the auto-research harness itself, including prompts, tooling, context management, search behavior, and the skill surface available to the agent.

The controversy matters because Weko had publicly claimed evidence of recursive self-improvement, and the episode notes that not everyone accepted that claim. Jiang's role in the conversation is therefore both advocate and boundary-setter. He argues that outcome should matter more than the specific layer modified, while also declining to claim ignition-level recursive self-improvement or imminent superintelligence. That makes the interview a useful case study in what current agent self-improvement can plausibly show, and what it still cannot show.

2. What the Episode Covers

The episode's main content follows Weko's attempt to turn auto-research back onto itself. The hosts begin with the intuitive picture of recursive self-improvement as a system rewiring its own brain. Jiang shifts the discussion: Weko's work is mostly about changing the code and procedure around the model. His criterion is practical. If the whole system becomes more capable, he does not want to exclude the result merely because the model layer stayed fixed.

Aid is the concrete object under discussion. It is a harness that receives a problem and metric, then searches for improvements. Weko runs that setup recursively so that the target becomes the agent harness itself: prompts, tools, skills, context handling, and search procedure. The surprising empirical claim in the episode is that the self-evolved harness produced code Jiang describes as alien or spaghetti-like, yet it generalized well. Weko tested the harness beyond the optimization tasks, including mlebenchlight, alebenchlight, and the more distant WeatherBench 2 forecasting task. Jiang says the evolved harness performed better than Weko's cleaner hand-tuned harness, while acknowledging that simplicity constraints remain an open improvement path.

A large part of the interview then narrows the definition of recursive self-improvement. Jiang distinguishes level 0 delegation, where a recursive loop exists but does not beat human R&D; level 1 net positive, where self-improvement is faster than human improvement of the system; and level 2 ignition, where the discovered inner-loop improver can become a better outer loop. Weko claims the level 1 position, not level 2. The episode treats that distinction as central because it separates a useful autonomous R&D speedup from the stronger claim that the improver is improving its own ability to improve.

The second half focuses on failure modes and applications. Reward hacking is discussed through Weko's public/private split: the inner loop sees public-set feedback, while the outer loop evaluates private-set aggregate performance. Holdout benchmarks unseen by the outer loop are used to test the meta-learning system. Jiang discusses A885, a strong discovered agent with search improvements, better context management, prompt rewrites, and anti-cheating mechanisms. He also describes fragility: one anti-cheating layer later broke, and a monkey patch that first looked like evaluation hacking turned out to be a bug fix. The episode closes by connecting these ideas to Parameter Golf, where Jiang says Weko's experimental harness ran for about 22 days, had seven records accepted by OpenAI, and became useful because humans then built on those agent-generated PRs.

3. Core Views: Reasoning, Examples, and Limits

The episode's first load-bearing view is that recursive self-improvement should not be defined only by whether model weights change. Jiang repeatedly frames Weko's standard as end-to-end capability improvement. If changes to prompts, tools, context management, search policy, and skill surfaces make the agent system more capable, he thinks those changes belong in the RSI discussion. This is a practical argument because harnesses are the layer most teams can actually modify today. The limitation is equally important: harness improvement is not proof that the model's underlying cognition has rewritten itself. It is evidence about a system-level adaptation loop, not a universal claim about machine intelligence transforming its own substrate.

The second view is that ugly generated code can still be behaviorally valuable. Jiang says the self-evolved auto-research harness produced alien, spaghetti-like code, yet generalized well in Weko's tests. The examples named in the episode are mlebenchlight, alebenchlight, and WeatherBench 2, with WeatherBench 2 presented as far out of distribution from the optimization set. Jiang says the evolved harness outperformed a more elegant hand-tuned harness. The reasoning is not that unreadable code is inherently better; rather, the agent may have compressed many experiments into a codebase whose surface form is hard for humans to parse. Jiang still recognizes a boundary: Weko may need constraints analogous to regularization so the optimizer searches for simpler solutions when performance is comparable.

Jiang's RSI level framework is the episode's discipline mechanism. Level 1 is already meaningful because it claims the self-improvement loop improves the system faster than human R&D would. But level 2 ignition is stricter: the inner loop must discover an improver that can itself function as a better outer loop. Weko's replay experiment is the key example. Starting from step 15, they compared the vanilla outer loop with the best inner-loop agent found in the first 50 steps. The step-47 inner-loop agent converged slightly faster, but the final solution quality was similar. That is why Jiang does not claim level 2. The result supports possible curve bending, but not a runaway feedback loop.

Reward hacking is treated as a central risk of auto-research rather than a footnote. Jiang explains that Weko's inner loop sees only the public set, while the outer loop evaluates aggregated private-set performance. If the inner loop finds a shortcut that improves public results while hurting private results, the outer loop can in principle learn to reduce that gap. A885 illustrates this mechanism: it had search algorithm improvements, better context management, a prompt rewrite, and three anti-cheating layers: prompt-level instruction, hard-coded checks for cheating evidence, and statistical filtering of suspicious outlier solutions.

The limitation is that anti-cheating systems are themselves software artifacts that can fail. Jiang says one mechanism emerged early and then stopped working after a later code-change bug. He also gives the opposite diagnostic problem: a large monkey patch to the evaluation script looked like reward hacking, but was eventually found to be fixing a bug. Together, these examples show why agent-generated systems will be hard to govern by code reading alone. The likely engineering posture is behavioral: define input-output contracts, test generalization, test out-of-distribution behavior, and keep evolving detection protocols as agents discover more sophisticated routes through the task.

The episode also rejects the idea that single-objective hill climbing is the same as open-ended discovery. The host raises the open-endedness critique: optimizing one metric can blind a system to stepping stones. Jiang agrees that Weko's current system probably does not collect stepping stones in the strong open-ended sense. His view is conditional. For one task from scratch, greedy hill climbing may be efficient. For broader creativity, the system needs a large collection of tasks so that a primitive not useful now can become useful later. This places Weko's result closer to high-throughput engineering optimization than to a complete automated science engine.

Finally, Jiang is cautious about ASI implications. He says recursive self-improvement would not immediately imply a technical singularity or intelligence explosion; the curve may bend gradually. Human work remains central: choosing abstractions, deciding what counts as good, defining evaluations and constraints, and generating creative primitives. Parameter Golf supports this more collaborative interpretation. Jiang emphasizes that the agent-generated work mattered because OpenAI accepted the PRs and human researchers built on them. The core claim is not that humans disappear from research, but that agent systems may increasingly produce useful material that enters human innovation lineages.

4. Learning and Application

The first practical lesson is to treat the agent harness as a serious optimization target. Teams should not only ask whether the base model is strong enough. They should inspect prompts, tool access, context windows, memory or state handling, search policy, evaluation interfaces, and the skill surface the agent can use. Jiang's description of harness engineering as a cheap and efficient way to adapt intelligence suggests a near-term path for applied teams: improve the wrapper before assuming that only a new model can change capability. The condition is that the task must have enough evaluable structure for iteration to mean something.

The second lesson is to design evaluations before celebrating gains. Weko's public/private split is a useful template. The inner loop can receive public feedback, while private aggregate performance checks whether public gains transfer. A further holdout benchmark set tests whether the outer loop has learned a genuinely useful improvement strategy rather than a benchmark-specific trick. This does not eliminate Goodhart pressure, especially in software engineering or GPU-kernel-like tasks where public tests can be gamed, but it creates more places where cheating should surface.

The third lesson is to handle generated code with a mixed posture: skepticism without superficial dismissal. Spaghetti code may contain real discovered behavior; a scary-looking monkey patch may be a bug fix. But the broken anti-cheating layer shows that complex generated systems can silently lose safeguards. In practice, teams need behavior tests, out-of-distribution tests, statistical anomaly checks, explicit input-output contracts, and human review aimed at system behavior rather than only local readability. Readability still matters for maintenance, but it is no longer a complete proxy for safety or correctness.

The fourth lesson is to manage search budget deliberately. A885's search policy combined multi-arm bandit allocation, lineages or islands, and anti-saturation behavior. Applied teams can borrow the pattern: maintain multiple experimental branches, allocate more compute to promising branches, and spawn fresh branches when one becomes saturated. The tradeoff is cost. Jiang notes that adding more outer loops can become expensive because each outer step may require running auto-research across many tasks. Promotion of a discovered inner-loop harness into the outer loop is attractive precisely because it avoids simply stacking more layers.

The fifth lesson is to separate optimization from open-ended creativity. Greedy hill climbing can be the right tool for a single well-specified task, but it is not enough if the objective is to discover reusable primitives. For that, systems need many tasks, mechanisms for preserving intermediate ideas, and human judgment about which abstractions are worth carrying forward. Jiang's view that humans remain stronger at creative primitives and initial abstractions should shape deployment: let agents explore at high throughput, but let humans frame the search space and decide which artifacts deserve to enter the next research cycle.

The strategic boundary is also clear. Recursive harness improvement can be valuable without implying that ASI is near. The safer application is sandboxed, measurable, reversible auto-research: tasks where failures can be detected, costs can be bounded, and outputs can be reviewed before entering production or a research lineage. Parameter Golf is the positive model in the episode. The agent did not merely post a benchmark number; its accepted records became useful because people could inspect, accept, and build on the contributions. The application frontier is therefore not autonomous replacement of research, but a tighter human-agent loop where generated knowledge becomes part of cumulative work.

Source

• Original episode: Can Rewriting an AI Agent Bend the Intelligence Curve? - Zhengyao Jiang