/self-improvement-loops

name: self-improvement-loops
description: "This skill should be used when the harness, scaffold, workflow, or optimizer itself is the optimization target: recursive self-improvement (RSI) loops, meta-harnesses, self-improving harnesses that mine their own failures and propose bounded edits, evolutionary or population-based search over agent scaffolds, acceptance gates for self-modifying systems, and agentic context evolution where the mechanism that produces context is versioned and evolved. Route governance of a single autonomous loop (locked surfaces, durable logs, rollback, novelty gates, approval boundaries) to harness-engineering, measurement and quality-gate design to evaluation, judge design to advanced-evaluation, and remote sandbox infrastructure to hosted-agents."

Self-Improvement Loops

This skill covers systems where the harness is the artifact being optimized: an agent mines its own failures and edits its own scaffold, a meta-agent searches over harness code, a population of workflow candidates evolves against an evaluator, or the mechanism that produces context is itself versioned and improved. The design question shifts from "how do I control one loop" (harness-engineering) to "how do I let a loop rewrite parts of itself without corrupting the signal that steers it".

The controlling constraint across every published system: the loop optimizes whatever signal it is given, including the signal's own weaknesses. Design the loop assuming the optimizer will find every gap between the metric and the intent.

When to Activate

Activate this skill when:

• Building a loop where an agent proposes edits to its own harness, prompts, context playbook, or workflow based on mined failure patterns
• Designing meta-level search over harness or scaffold code: meta-agent search, tree search over workflow graphs, evolutionary program search with an LLM mutation operator
• Choosing acceptance criteria for any self-modifying agent system
• Evolving the mechanism that manages context (a skill, playbook, or context function) rather than hand-editing the context artifact
• Diagnosing a degenerating self-improvement loop: reward hacking, diversity collapse, context collapse, or silent stagnation
• Deciding which level of the optimization ladder (prompt, context, workflow, harness code, optimizer code) a recurring failure should be fixed at

Do not activate this skill for adjacent work owned by other skills:

• Governance of a single autonomous loop that does not modify itself: locked and editable surfaces, durable logs, rollback, novelty gates, PR preparation, and human approval boundaries belong to `harness-engineering`. That skill defines the control surfaces; this skill defines what happens when the surfaces themselves become the optimization target.
• Building the evaluator, regression suite, or quality gates that score candidates: `evaluation`.
• LLM-as-judge design, pairwise comparison, and bias mitigation for candidate scoring: `advanced-evaluation`.
• One-shot token efficiency, masking, or caching without an improvement loop: `context-optimization`.
• Remote sandboxes and background execution infrastructure for running the loop: `hosted-agents`.
• Whether to build the loop at all, pipeline shape, and cost estimation: `project-development`.
• The self-editing context behavior and efficiency reward a loop optimizes: `self-managed-context`.

Core Concepts

The Optimization Ladder

Published self-improvement systems target progressively deeper objects:

| Rung | Optimized object | Example systems | | --- | --- | --- | | 1 | Instruction prompts | Promptbreeder, GEPA | | 2 | Structured context | ACE (playbook of itemized bullets) | | 3 | Context mechanism | MCE (the skill that produces context) | | 4 | Workflow graph | ADAS, AFlow | | 5 | Harness code | Self-Harness (bounded self-edits), Meta-Harness, Darwin Godel Machine | | 6 | Optimizer code | STOP (the improver improves the improver) |

Each rung up buys a larger design space and more leverage, and costs more per evaluation with a larger surface for gaming. Fix a recurring failure at the lowest rung that can express the fix. A stale-library failure is a context fix, not a workflow rewrite. Only move up when failure clusters at the current rung persist across candidates.

The Loop Is Not the Intelligence

Recursive structure amplifies base-model quality in both directions. The same recursive improver design that compounds gains with a strong model degrades mean performance across iterations with weaker models (claim-self-improvement-capability-threshold). Two implications:

1. Run a capability validation before enabling recursion: a fixed number of iterations on a held-out task set, with the loop counted as net-negative if the trajectory declines. 2. Detect the degenerate stagnation mode. A broken improver that silently returns its input unchanged looks like stability in aggregate metrics. Track edit diffs, not only scores.

The Outside-the-Loop Invariant

The evaluator, its instrumentation, permission control, and budget enforcement must live outside the surface the loop can modify. Every documented reward hack broke this invariant: agents removed the logging markers a hallucination detector depended on, and hacking became more frequent when the checking code was visible to the agent (claim-self-improvement-visible-evaluator-hacking). Agents given sight of scoring functions overwrote timing functions and monkey-patched evaluators to return perfect scores (claim-self-improvement-scorer-visibility).

Operational rules:

• Constraints stated in prompt text get evolved away. Enforce budgets, permissions, and sandbox boundaries in the runtime, never in the mutable prompt or harness code.
• Hide the scoring implementation from the proposer. Expose scores and traces, not evaluator source.
• Sandbox at the OS or container level. Framework-level permission gates can be bypassed through side channels the loop discovers.

-