A component-based framework and open protocol for agent recursive self-improvement.
Every stage of the self-improvement loop is a standalone MCP server. Use one piece in your own stack,
or wire them all together with a single anyrsi.yaml.
English · 简体中文
News · Why AnyRSI · How It Works · Quick Start · Experiments · Integrations · Documentation
- 2026-11 · Measurement safeguards for Terminal-Bench. A run where the verifier never reached its tests is now unscorable, not a zero: it is left out of scores, gate comparisons and proposals, and a batch with more than
loop.max_unscorable(default 20%) of them stops the run.HarborRewardJudgereadsverifier/(each test case inctrf.jsonbecomes a rubric item with its failure message). New preflight check and gate-task selection: run the oracle and an empty agent before any model call, measure noise on train and gate tasks, and pick gate tasks the starting agent can be graded on but often fails. In the last five-generation run, none of the 19 gate tasks could show an improvement. - 2026-11 · Direction momentum (
loop.group.momentum): directions verified on the exam (which edits helped, on which task tags and rubric items, and which hurt) are handed to the proposer with decay, keeping one unguided proposal per generation as a control. On gpt-4o-mini it lowered the fresh-task score (0.58 → 0.40–0.44, lower in all 9 runs): guided edits are only slightly worse one by one, but guided proposals are less diverse. On gpt-6.1-terra it made no difference (0.93 vs 0.94). Text advice is not a good way to pass direction to the proposer. Runs now stop on quota or auth errors instead of silently scoring zero. - 2026-11 · Gradient-like direction finding (
loop.group.atomize+mergestrategy): each proposal is split into single edits, each edit is measured against the parent on the same exam tasks (a finite difference), and every edit that helps is merged into one step. On a toy problem a very weak proposer goes from 0.61 to 0.81 (best 0.85). On a real weak LLM (gpt-4o-mini, easy secret-ops) it beats the plain loop by +0.10 on fresh tasks at equal cost, as long as the exam is not split in halves; when the model almost never proposes the right change (hard version), it does not help. Newanyrsi_llm:PatchProposer;chat()retries dropped connections. - 2026-11 · Self-proposal tested on real LLMs (gpt-6.1-terra / gpt-6.1-sol / gpt-4o-mini):
loop.self_proposeworks end to end and matches a separate prompt rewriter (0.04 → about 0.9 on the hard secret-ops task). But with the prompt as the only thing evolving, a stronger agent version does not write better edits: the edit quality depends on the model, not on the evolved prompt. Recursion needs the model itself (weights) to improve. See benchmarks/self_propose_llm. The LLM components now handle models that rejectmax_tokensor a customtemperature. - 2026-11 · The agent proposes edits to itself (
loop.self_propose): instead of a separate proposer, "improve yourself" is given to the current agent version as a task, so as the agent gets better, so do its edits. On a toy problem where a stronger agent writes better edits, the normal loop ends 0.08 higher than with a fixed-skill proposer and the gap widens in the second half; in group mode the gain is small and not significant. - 2026-11 · Proposer feedback (
loop.improver_feedback): each generation, which edits did better or worse on the exam is written back into the proposer's strategy notes, so the proposer improves too. On a toy problem the proposer's rate of good edits rises by 11–13 percentage points, but improvement does not accelerate yet. - 2026-11 · Group proposals (
loop.group): the proposer makes a group of candidates; the parent and every candidate take the same exam (holdout) tasks with a shared seed per task; half of the exam picks, the other half confirms. The group-advantage rule is pluggable: built-in parent-paired, GRPO-style, best-of-N and Training-Free-GRPO-style, or your own class with the same interface. On a toy problem the final score matches the current loop while harmful accepts drop from 6–8% to 0; see Experiments. - 2026-11 · Renamed to AnyRSI (formerly OpenRSI, which clashed with another project). Package names, the CLI and the protocol identifier are now
anyrsi. - 2026-11 · RSIHub task banks (Harbor format) work as an AnyRSI environment, split by the same rule as RSIHub; one loop now evolves both agent code and weights. See examples/rsihub_weights.
- 2026-10 · v0.4: six evolution algorithms (GEPA-style Pareto, ShinkaEvolve, AlphaEvolve-style islands, MAP-Elites, archive, greedy), per-task no-regression gating, harness (agent code) and model-weight evolution, and adapters for verl and RSIHub.
- 2026-10 · An end-to-end pipeline that evolves a small model's system prompt and weights together ran on a real model (Qwen2.5-0.5B, CPU). GPU-scale results are pending.
- 2026-10 · Component-design tests: every algorithm/gate combination, identical lineage across in-process / stdio / HTTP transports, and a JavaScript component dropped into the Python loop.
Most self-improvement systems are monolithic: the evaluator, the search algorithm and the thing being improved are tied to one codebase. AnyRSI splits the loop into components with a published protocol, so they can be swapped, reused and audited independently.
- Components, not a monolith. 13 component kinds (environment, agent, evidence, judge, attribution, evolvable, memory, skill, proposer, algorithm, gate, guard, lineage). Each one is an MCP server with a fixed set of tools.
- Evolve anything. Memory, prompts, executable skills, the agent's own code (harness), model weights, and the judge itself, alone or several at once.
- Use one piece. Any MCP client (Claude Code, Cursor, another framework, another language) can call a single component. A gate written in JavaScript from the spec alone passes conformance and runs inside the Python loop.
- Safe by construction. The runtime enforces data isolation. A guard inspects every patch before it applies. A gate admits only real holdout gains, optionally with no per-task regressions. Judge changes are validated against human labels.
- Frontier search. Pareto frontiers (GEPA), novelty screening and adaptive proposer selection (ShinkaEvolve), island models (AlphaEvolve), MAP-Elites and open-ended archives (Darwin Gödel Machine).
- Interoperable. Use the judge as a verl reward function or a DSPy metric, and AnyRSI components as RSIHub operators.
flowchart LR
A["Algorithm<br/>picks a parent version"] --> B["Agent solves<br/>train tasks"]
B --> C["Evidence<br/>+ Judge"]
C --> D["Attribution"]
D --> E["Proposer<br/>writes a patch"]
E --> F["Guard<br/>inspects the patch"]
F --> G["Candidate scored<br/>on holdout"]
G --> H["Gate<br/>accept / reject"]
H --> I["Lineage"]
I --> A
A version maps each evolvable to one of its snapshots, for example prompt snapshot + weights checkpoint. Every patch creates a new snapshot. Rollback is always possible, and rejected candidates stay in the lineage for audit.
The runtime enforces these rules itself rather than trusting components to follow them:
- The agent never sees
task.reference(the answer) or the judge's rubric. - Only train episodes reach attribution and proposers. Holdout and final tasks are used only for scoring.
- If the environment mislabels a split, the run stops.
- A patch the guard blocks is never applied; it is recorded as rejected.
- A judge change is accepted only if agreement with a human-labelled anchor set improves. Agent and judge evolve in alternate generations.
| Evolvable | Snapshot | Patch | Package |
|---|---|---|---|
| Memory | item set | add / replace / remove items | anyrsi-memory |
| Prompt | ordered sections | add / replace / remove sections | anyrsi-evolvables |
| Skills | Python functions, run in a sandboxed subprocess | add / replace / remove code | anyrsi-evolvables |
| Harness (agent code) | git commit | write / delete / unified diff, within mutable paths | anyrsi-harness |
| Model weights | checkpoint | one training run: SFT on judge-verified answers, or DPO / KTO that also learn from wrong answers; built-in trainer (trainer: builtin, torch + transformers, optional LoRA) or any external command (verl, LLaMA-Factory, ...) |
anyrsi-weights |
| Judge rubric | rubric items | add / tighten checks; gated on human-label agreement | anyrsi-judge |
| Improver strategy (meta) | notes / parameters the proposer reads | replace; gated on downstream gain | anyrsi-evolvables |
| Curriculum (meta) | tag weights for picking train tasks | replace; gated on downstream gain | anyrsi-evolvables |
Meta evolvables (loop.meta_every) are never shown to the agent and never changed in ordinary generations. In a meta generation the runtime runs one ordinary round under the current and under the candidate meta state with the same budget, and keeps the candidate only if the improvement it produces on holdout is larger; the accepted version carries that improvement with it. Judges and attribution methods are upgraded by the outer loop (runtime/anyrsi_runtime/outer.py), which can generate and validate candidates on its own but never promotes without a named approver. runtime/anyrsi_runtime/nesting.py wraps a whole inner run as an agent (LoopAgent + GainJudge), so an outer loop can evolve the inner loop's algorithm, proposer or attribution; the inner env, judge, gate, guard, lineage and budget stay fixed. Gate, guard, sealed tests, human labels and budgets are never evolved.
| Kind | Official implementation | Package |
|---|---|---|
| judge, evidence | EvidenceJudge (rubric + evidence, optional LLM checks), EvolvingJudge; GainJudge scores a nested run |
anyrsi-judge, anyrsi-runtime |
| attribution | RubricEvidenceAttributor, CellContrastAttributor (blames environment coordinates when a task fails in some cells only); counterfactual reruns in the runtime |
anyrsi-attribution |
| proposer | LessonProposer, ClaudeProposer, RubricAuditor, CompositeProposer, RoutedProposer (picks a member by where the attribution points), CurriculumProposer and StrategyRewriter (meta layer), PromptRewriter, CodeRewriter (rewrites agent code), DistillProposer, PreferenceProposer |
anyrsi-proposer, anyrsi-llm, anyrsi-verl |
| algorithm | 6 algorithms, see below | anyrsi-algorithm |
| gate | HoldoutGate (gain, significance, paired per-task significance, anchor, cost, per-task and per-cell no-regression) |
anyrsi-gate |
| guard | PolicyGuard (dangerous code, secrets, protected items and paths, eval tampering) |
anyrsi-guard |
| lineage | LineageStore (JSONL, resumable) |
anyrsi-lineage |
| agent | ChatAgent (any OpenAI-compatible endpoint, restarts vLLM when weights change), HarnessAgent, LoopAgent (a whole inner run) |
anyrsi-llm, anyrsi-harness, anyrsi-runtime |
| evolvable, memory, skill | see the table above | |
| env | user-provided; examples include GSM8K |
--kind |
Inspired by | Parent selection |
|---|---|---|
greedy |
hill climbing | always the best version |
archive |
Darwin Gödel Machine | every accepted version, weighted by score and child count |
pareto |
GEPA, Meta-Harness | per-task frontier: any version that is best on some task stays; dominated ones are pruned |
shinka |
ShinkaEvolve | sigmoid score weighting, novelty screening before evaluation (rsi_algorithm_screen), UCB over proposers |
islands |
AlphaEvolve, FunSearch | independent islands with periodic migration of the best version |
map-elites |
MAP-Elites | one elite per behaviour cell; cells sampled uniformly |
Requires Python 3.10+.
git clone https://github.com/TraceLite-AI/anyrsi && cd anyrsi
pip install -e sdk/python -e runtime -e components/judge -e components/memory -e components/attribution \
-e components/proposer -e components/algorithm -e components/gate -e components/lineage \
-e components/evolvables -e components/guard -e components/harness -e components/llm -e components/weights \
-e adapters/verl
cd examples/secret_ops
anyrsi run # runs until done; rerunning resumes from the lineage
anyrsi log # show the lineageEach of 8 symbols hides an unknown binary operation. The agent looks up rules in memory, and the proposer induces rules from failed train tasks. No model or API key is needed. Output:
gen parent train base cand result
· root snap_root: holdout=0.000
1 snap_root 0.111 0.000 0.375 accepted snap_7f0d3e1244746973
2 snap_7f0d3e124474697 0.667 0.375 0.500 accepted snap_7df638e7d96838e1
...
8 snap_f474c409fda4e93 0.778 0.875 1.000 accepted snap_0145c98ef4d8eda8
cd examples/small_model
python make_toy_data.py toy_data && anyrsi run anyrsi.mock.yaml # mock model, seconds, no GPU
anyrsi run anyrsi.cpu.yaml # Qwen2.5-0.5B on CPU via transformers, ~1 h
anyrsi run anyrsi.yaml # Qwen2.5-0.5B on one GPU via vLLMEach generation, ShinkaEvolve's UCB picks one of two proposers: rewrite the system prompt from failed train tasks, or fine-tune on trajectories the judge passed (rejection-sampling self-distillation). When the weights change, ChatAgent restarts the inference server on the new checkpoint. See examples/small_model.
| Example | Shows |
|---|---|
secret_ops |
the full loop with memory; one component runs as a separate MCP process |
skill_ops |
evolving executable skills; the guard blocks a patch that imports os |
judge_coevolution |
a judge that misses test tampering is fixed, gated on human labels, then the agent stops cheating |
harness_ops |
evolving the agent's own code in a git repo; an edit to eval/ is blocked |
small_model |
real LLM; system prompt and weights evolve together |
rsihub_weights |
an RSIHub task bank (Harbor) inside the AnyRSI loop; agent code and weights evolve together |
judge_standalone.py |
using the judge alone, in-process and over MCP |
In Python:
from anyrsi_judge import EvidenceJudge
judge = EvidenceJudge({"items": [{"id": "tests_pass", "check": "tests_pass", "required": True},
{"id": "no_test_edits", "check": "no_protected_edits", "required": True}]},
protect=["tests/**"])
verdict = judge.evaluate(task, trajectory, judge.collect(task, trajectory))As an MCP server for any client:
anyrsi-judge --rubric rubric.yaml --protect 'tests/**'
anyrsi-serve anyrsi_gate:HoldoutGate --with '{"min_gain": 0.01}' # any component class
anyrsi-serve my_pkg:MyJudge --transport streamable-http --port 8765Write your own component by subclassing an SDK base class, then run the conformance suite:
from anyrsi import Gate, GateDecision, serve
class MyGate(Gate):
name, version = "me/my-gate", "0.1.0"
def check(self, request):
ok = request.candidate["holdout"] > request.baseline["holdout"]
return GateDecision(candidate_id=request.candidate_id, accepted=ok)
serve(MyGate())anyrsi-conformance -- python my_gate.pyOther languages need no SDK: implement the tools in spec/tools.json. tests/xlang/gate.mjs is a gate written in JavaScript from the spec alone.
Any slot in anyrsi.yaml can be in-process (python:), a subprocess (command:), or remote (url:):
protocol: anyrsi/0.4
components:
env: {python: "my_components:MyEnv"}
judge: {python: "anyrsi_judge:EvidenceJudge", with: {rubric: rubric.yaml}}
evidence: {same_as: judge}
memory: {command: [anyrsi-memory, --path, .anyrsi/memory]}
algorithm: {python: "anyrsi_algorithm:ShinkaAlgorithm", with: {proposers: [prompt, weights]}}
gate: {python: "anyrsi_gate:HoldoutGate", with: {max_task_regressions: 0}}
lineage: {url: "https://lineage.internal/mcp"}
evolvables:
prompt: {python: "anyrsi_evolvables:PromptEvolvable"}Environment cells (draft for 0.5, opt-in): an env that implements rsi_env_cells declares cells (environment coordinates plus pinned versions; see the draft). Add a cells: section to run each task once per cell. The runtime keys per-task scores as <task_id>@<cell_id>, stops if a cell's fingerprint changes or a task's env_ref is wrong, and records the cells in the lineage. Without cells: a run behaves exactly as in 0.4. Each episode also gets an env_cell evidence record (cell, coordinates, fingerprint) written by the runtime, which CellContrastAttributor uses to compare the same task across cells. The runtime checks declarations only; it does not make the agent actually run in that environment. For that, add cells.binding (strict mode): before every task the runtime prepares the cell, runs pre-registered probes in a subprocess and compares them with the declared coordinates, and the agent must report the plan it used (HarnessAgent does). With records: {path} the raw tasks, trajectories, evidence and receipts are stored content-addressed and append-only, verdicts and attributions as derived records, and resuming with a different run manifest is refused. runtime/anyrsi_runtime/outer.py upgrades a judge or an attribution method only after a frozen validation plan passes on independent labels and someone approves; off by default.
cells:
train: [linux-utf8]
holdout: [linux-utf8, linux-cp1252]| Framework | What AnyRSI provides | Tested against the real framework |
|---|---|---|
| Any MCP client | every component | yes (Python and JavaScript clients) |
| verl | judge as compute_score reward; RL/SFT data export that refuses non-train data; model weights as an evolvable |
not yet (field tests ready) |
| RSIHub | guard validate, no-regression gate, Shinka select operators; archive import; the other way round, RSIHub task banks as an AnyRSI environment (RSIHubTaskEnv, HarborAgent, HarborRewardJudge) |
not yet (field tests, parity benchmark ready) |
| DSPy | judge as a metric, including GEPA feedback | with stubs only |
| LangGraph | state to trajectory conversion | with stubs only |
| vLLM / any OpenAI-compatible API | ChatAgent and PromptRewriter |
transformers server on CPU; vLLM pending |
Results marked pending need GPUs or paid APIs. The scripts are in the repository, and the tables will be filled in once the runs complete.
examples/small_model/anyrsi.yaml, Qwen2.5-0.5B-Instruct, 64 train tasks per generation, 200 holdout tasks, 8 generations.
| Setting | Root holdout | Best holdout | Accepted (prompt / weights) | Final split | Wall-clock |
|---|---|---|---|---|---|
| prompt + weights (vLLM, 1 GPU) | pending | pending | pending | pending | pending |
| prompt only | pending | pending | pending | pending | pending |
| weights only | pending | pending | pending | pending | pending |
A small run on CPU (12 train / 15 holdout tasks, 3 generations) completed end to end. Root holdout 0.20. The SFT candidate (4 examples) scored 0.13 and was rejected by the gate. The run surfaced four issues that the mock pipeline could not, all fixed; see examples/small_model.
benchmarks/rsihub_parity runs RSIHub's own evaluator twice. The two arms differ only in the validate and gate operators. 89 tasks, split 50 / 19 / 20, GPT-5.4.
| Arm | Train (seed → best) | Full benchmark (seed → best) | Accepted / generations | Blocked by guard | Cost |
|---|---|---|---|---|---|
| RSIHub published | 58.0% → 68.0% | 56.2% → 69.7% | — | — | — |
| baseline (our run) | pending | pending | pending | pending | pending |
| + AnyRSI guard and no-regression gate | pending | pending | pending | pending | pending |
| Test | Result |
|---|---|
| V1: AnyRSI reward vs verl's built-in GSM8K reward, per-sample agreement | pending |
| V3: GRPO, Qwen2.5-0.5B, validation score before → after, AnyRSI reward vs built-in | pending |
V4: two chained SFT runs through WeightsEvolvable, then rollback |
pending |
benchmarks/native_loop: A = no improvement, B = equal search budget but every generation starts from the root, C = equal budget and improvements are inherited. Budget 400 agent calls per arm; sealed test of 40 tasks run once per arm after the final version is locked.
| Arm | Sealed pass rate (seed 0 / 1 / 2) |
|---|---|
| A: frozen | 0.000 / 0.125 / 0.125 |
| B: independent from root | 0.375 / 0.500 / 0.500 |
| C: inherits improvements | 1.000 / 1.000 / 1.000 |
This is the secret_ops toy task: it shows the machinery works, not how well a real agent improves.
benchmarks/composition/overhead.py, Python 3.13, 4-core CPU:
| Transport | Gate check | Judge one task (evidence + verdict) |
|---|---|---|
| in-process | 0.003 ms | 0.025 ms |
| subprocess (stdio) | 2.4 ms | 5.4 ms |
| streamable HTTP | 3.4 ms | 7.0 ms |
A full secret_ops run (8 generations) takes 0.07 s in-process and 14 s with every component in its own process. Real agents spend seconds to minutes per task, so the overhead is negligible. Components called on every agent step should stay in-process.
benchmarks/group_toy: the optimum is known (true pass rate 0.39 at the start, 0.85 at best); 10 seeds, 6000 agent calls per arm. A is the current loop (one proposal per generation); the others use loop.group with 4 candidates per group, 30 exam tasks to pick and 30 to confirm.
| Proposer | A | Parent-paired | GRPO-style | Best-of-N | Training-Free-GRPO-style |
|---|---|---|---|---|---|
| Good | 0.788 | 0.572 | 0.773 | 0.784 | 0.764 |
| Poor | 0.720 | 0.406 | 0.699 | 0.701 | 0.715 |
Values are the true pass rate of the final version. The last three match A (differences not significant) while the share of accepted changes that are truly worse drops from 6–8% to 0; the cost is taking the exam five times per generation. The parent-paired test is too strict on 30 tasks and makes the least progress.
Recursive improvement (loop.improver_feedback): each generation, which edits did better or worse on the exam is written back into the proposer's strategy notes. A proposer that reads group-comparison feedback makes good edits 11–13 percentage points more often than the same proposer without it at the same moment (5–6 points with shuffled labels, 6–9 points with accept/reject feedback), but the gain does not grow over generations and the final score does not beat the no-feedback arm. See benchmarks/group_toy.
The agent improves itself (loop.self_propose): no separate proposer; "improve yourself" (recent failures, attributions, its own editable parts) is a task for the current agent version, and its JSON reply is the patch. The improver and the improved are the same thing, so gains can compound. Toy assumption: the agent's edit skill rises with its true pass rate (good-edit rate 0.2 → 0.9). 10 seeds, final true pass rate:
| Edits written by | Normal loop | Group (best-of-N) |
|---|---|---|
| Fixed proposer at the agent's starting skill | 0.678 | 0.698 |
| The agent itself | 0.758 | 0.717 |
| Always-strong proposer (reference) | — | 0.808 |
In the normal loop self-proposal ends +0.080 ± 0.042 higher (z 1.9) and gains more in the second half than the fixed proposer (+0.051, z 1.7): improvement accelerates. In group mode the difference is +0.019 ± 0.035 (not significant): five exam passes per generation leave few generations for the compounding to show. The link between agent skill and edit skill is set by the toy. On real LLMs (benchmarks/self_propose_llm) it holds across models (gpt-6.1 edits are almost always right, gpt-4o-mini edits almost never help) but not across prompt versions of the same model: the current version, the starting version and a plain assistant write equally good edits at every level. In a full loop, self-proposal and a separate prompt rewriter both reach about 0.9 with gpt-6.1 and stay near 0.05 with gpt-4o-mini.
Like a zeroth-order gradient: split each proposal into single edits, measure each against the parent on the same exam tasks with the same seed, and take every edit that helps in one merged step (loop.group.atomize: true, strategy: merge). Toy (benchmarks/group_toy), 10 seeds, final true pass rate (best 0.85):
| Proposer | Current loop | Best-of-N | Atomize + merge |
|---|---|---|---|
| Good | 0.788 | 0.762 | 0.837 |
| Poor | 0.720 | 0.706 | 0.823 |
| Very weak | 0.612 | 0.648 | 0.809 |
Real LLM (benchmarks/self_propose_llm), gpt-4o-mini, about 2000 agent calls per run, 3 seeds, scored on 48 fresh tasks:
| Easy version | Hard version | |
|---|---|---|
| Current loop | 0.47 | 0.13 |
| Best-of-N | 0.45 | 0.15 |
| Atomize + merge, exam split in halves | 0.33 | 0.06 |
| Atomize + merge, no split | 0.58 | 0.08 |
When the weak model sometimes proposes the right change, measuring single edits finds the direction (+0.10 over the current loop, higher on every seed). Each rule here affects only a few exam tasks, so splitting the exam in halves leaves too few relevant tasks to confirm a gain; use confirm_fraction: 0 or a larger exam. When the model almost never proposes the right change (2 of 246 rules correct on the hard version), measurement cannot help and more generations do better. Handing the verified directions to the proposer as text (loop.group.momentum) lowered gpt-4o-mini's score (0.58 → 0.40–0.44 on the easy version) and made no difference for gpt-6.1-terra.
AnyRSI is alpha software (protocol anyrsi/0.4). Protocol versions so far have only added fields and tools, so components built for an older version still work.
- Tested in CI: 382 tests on Python 3.10–3.13: protocol conformance, data isolation, every algorithm/gate combination, transport equivalence, cross-language components, crash and resume, and six end-to-end examples.
- Run on a real model: the small-model pipeline on CPU.
- Not yet run for real: GPU-scale small-model runs, verl training, RSIHub recipes. See Experiments.
- Fill in the experiment tables above
- Reinforcement learning (GRPO via verl) as a weights patch inside the loop, not only SFT
- Run AnyRSI's own runtime on Terminal-Bench 2 and τ³-bench via Harbor, with the same splits as RSIHub (components and config ready: examples/rsihub_weights; not yet run on real hardware)
- TypeScript SDK
- Adapters for OpenEvolve, Letta, OpenAI Agents SDK
- English translation of the protocol specification
The protocol specification and in-repo guides are currently written in Chinese. English translations are planned.
| Document | Content |
|---|---|
| spec/PROTOCOL.md | the protocol: component kinds, tools, data isolation, versioning |
| spec/tools.json, spec/schemas/ | machine-readable tool and data schemas |
| examples/small_model/README.md | the small-model pipeline |
| examples/rsihub_weights/README.md | code and weights evolving together on an RSIHub task bank |
| field_tests/README.md | tests to run against real verl and RSIHub |
| benchmarks/rsihub_parity/README.md | the RSIHub parity experiment |
| benchmarks/native_loop/README.md | the native A/B/C experiment |
| benchmarks/group_toy/README.md | four group-advantage strategies (toy problem) |
| REVIEW.md | the review checklist and per-version baselines |
spec/ protocol, JSON Schemas and tool definitions (generated)
sdk/python/ anyrsi-sdk: data types, component base classes, MCP server/client, conformance suite, anyrsi-serve
runtime/ anyrsi-runtime: wires components from anyrsi.yaml, runs and resumes the loop
components/ official components: judge, memory, evolvables, harness, llm, attribution,
proposer, algorithm, gate, guard, lineage
adapters/ verl, RSIHub, DSPy, LangGraph
examples/ runnable examples
benchmarks/ RSIHub parity, native A/B/C, composition overhead
field_tests/ tests to run on real frameworks and hardware
tests/ unit and integration tests, including tests/xlang (JavaScript)
pip install -e sdk/python -e runtime -e components/* -e adapters/* pytest ruff
npm ci --prefix tests/xlang # optional, for the cross-language tests
pytest
ruff check .
python -m anyrsi.export_spec spec # after changing sdk/python/anyrsi/types.py or protocol.pyNew or changed components need an updated rsi-component.yaml manifest. Reviews start from the three questions in REVIEW.md.
@software{anyrsi2026,
title = {AnyRSI: A Component-Based Framework and Open Protocol for Agent Recursive Self-Improvement},
author = {{AnyRSI contributors}},
year = {2026},
url = {https://github.com/TraceLite-AI/anyrsi}
}AnyRSI builds on the Model Context Protocol and draws on ideas from GEPA, ShinkaEvolve, AlphaEvolve, Darwin Gödel Machine, MAP-Elites, Self-Harness and AHE. It integrates with verl, RSIHub, DSPy and LangGraph.
The controlled direction pilot uses disjoint expression identities and equal search HTTP-attempt ceilings, including proposals and retries. Historical tables use the earlier protocol. CodeRewriter optionally emits bounded line hunks (max_hunk_lines); a hunk is a structural unit, not a guarantee of one behavioral change.
A five-generation Terminal-Bench run using AnyRSI selection components and RSIHub native scoring completed, but verifier startup failures invalidate a method-quality conclusion. Original scores, all candidate diffs, the per-trial audit and an offline consistency checker are in the experiment record. These results do not replace the unrun standard RSIHub parity recipe or establish a performance gain.