Running RSI Repos Yourself: A Hands-On Walkthrough
The practitioner's primer lists which RSI repos are real and runnable. This piece goes one level deeper on three of them — FunSearch, the Self-Improving Coding Agent (SICA), and Gödel Agent — actually cloning each and reading through what setting them up really involves, so you know what you're getting into before you start.
Why This Companion Exists
The primer's repo table tells you a technique has a real, official repository and gives a one-line note on what running it takes. That's useful for deciding what to try, but it stops short of telling you what you'll actually see when you clone the thing — what files are there, whether "just run the demo" is really that simple, and where the friction actually is. This piece exists to close that gap for three repos spanning the difficulty range the primer describes: FunSearch (the easiest — zero local install), Gödel Agent (a middle case — plain Python, one API key), and SICA (the most involved — Docker, multiple possible API providers, and an explicit safety warning from the authors themselves).
FunSearch: Zero Install, Runs in Colab
cap_set, admissible_set, bin_packing, cyclic_graphs) each hold a runnable Colab notebook plus the specific mathematical objects FunSearch discovered for that problem, provided in numerical format so you can inspect the actual output without running anything. A fifth, corner_free_sets, provides discovered index sets in the same numerical format without a notebook. The sixth, implementation, is different in kind: it's the evolutionary-algorithm and code-manipulation logic itself — but the README is explicit that this directory does not include the language model that proposes new programs, the sandbox for executing untrusted code, or the distributed infrastructure DeepMind actually used. It's there for understanding the method and adapting it to your own LLM/sandbox setup, not for a one-command reproduction.SICA: Docker, API Keys, and an Explicit Safety Warning
make image (or make image-mac on Apple Silicon); then separately pip install the requirements plus the swebench package into your local Python environment. To confirm the setup worked, make int starts the container and attaches your shell, from which you run the agent interactively and can watch its execution on a local web UI at localhost:8080, showing the event bus and agent callgraph in real time.The actual self-improvement loop is a separate step from the interactive test: after confirming the interactive agent works, running python runner.py starts the full loop described in the primer — evaluate the current agent version on benchmark tasks, archive the results, let the agent edit its own codebase, repeat. Before doing this, the README says to check base_agent/src/benchmarks/__init__.py and make sure the benchmarks you actually want included are uncommented. The repo's own "Things to work on" list is candid about the system's current limits — it names reducing the variance of self-improvement runs (since early features reportedly influence what gets built later) and building more of the agent's own benchmarks as open problems, not solved ones.
Gödel Agent: The Middle Ground
pip install -r requirements.txt, then run python src/main.py. The one piece of required configuration is an OpenAI API key, set in a key.env file — no Docker, no choice of provider, no separate benchmark-selection step. The codebase is organized so that agent_module.py holds the actual self-awareness and self-modification logic (this is the file the primer's repo table points to directly), while separate task_*.py files (adapted from the ADAS project, per the README) define what environment or benchmark the agent is being evaluated against. The README's own "Development Tips" section is a genuine extension guide, not filler: it walks through exactly what you'd add to give the agent a new action (an entry in agent.action_functions, the implementation itself, and optionally a mention in the goal prompt) or to point it at a new environment (a reward function, an action_evaluate_on_task implementation, and an initial policy).Comparing the Three
| Repo | Install | Required credentials | Where the "self-improvement" actually happens |
|---|---|---|---|
| FunSearch | None — open a notebook in Colab | None to inspect existing results; your own LLM API access if you extend it | The evolutionary loop over generated programs, in the (LLM-less) implementation directory you'd extend yourself |
| Gödel Agent | pip install -r requirements.txt |
One OpenAI API key in key.env |
agent_module.py — the agent modifies its own code via what the paper calls monkey patching |
| SICA | Docker image build + local pip install |
At least one of six supported LLM provider keys; optionally Modal tokens for web access | runner.py's full loop — evaluate, archive, self-edit the codebase, repeat |