Skip to content
TraceLite-AIPublic

About

No description, website, or topics provided.

Resources

Stars

1 star

Watchers

0 watching

Forks

Repository files navigation

AnyRSI

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.

CI License: Apache-2.0 Python 3.10+ Protocol anyrsi/0.4 Status: alpha

English · 简体中文

News · Why AnyRSI · How It Works · Quick Start · Experiments · Integrations · Documentation


News

  • 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. HarborRewardJudge reads verifier/ (each test case in ctrf.json becomes 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 + merge strategy): 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. New anyrsi_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_propose works 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 reject max_tokens or a custom temperature.
  • 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.

Why AnyRSI

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.

How It Works

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
Loading

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:

  1. The agent never sees task.reference (the answer) or the judge's rubric.
  2. Only train episodes reach attribution and proposers. Holdout and final tasks are used only for scoring.
  3. If the environment mislabels a split, the run stops.
  4. A patch the guard blocks is never applied; it is recorded as rejected.
  5. A judge change is accepted only if agreement with a human-labelled anchor set improves. Agent and judge evolve in alternate generations.

What can evolve

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.

Components

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

Evolution algorithms

--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

Quick Start

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 lineage

Each 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

Evolve a small model's prompt and weights

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 vLLM

Each 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.

More examples

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

Use a Single Component

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 8765

Write 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.py

Other 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]

Integrations

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

Experiments

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.

1. Small model: system prompt + weights on GSM8K

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.

2. RSIHub parity: Terminal-Bench 2 × MiniSWE × Hyperagents

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

3. verl

field_tests/verl.

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

4. Native loop A/B/C (synthetic smoke, not a benchmark)

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.

5. Cost of the component split (measured)

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.

6. Group proposals (toy problem, not a benchmark)

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.

7. Finding a direction with a weak proposer (atomize + merge)

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.

Project Status

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.

Roadmap

  • 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

Documentation

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

Repository Layout

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)

Contributing

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.py

New or changed components need an updated rsi-component.yaml manifest. Reviews start from the three questions in REVIEW.md.

Citation

@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}
}

Acknowledgements

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.

License

Apache License 2.0

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.

Recorded experiment audit (2026-11-05)

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.

About

No description, website, or topics provided.

Resources

Stars

1 star

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages