InfraRSI: Agent Harness That Tunes LLM Training for 2.75× Speedups

InfraRSI brings recursive-self-improvement rhetoric down to the metal of LLM training clusters. The November 2026 paper arXiv:2611.11558 from the InfraRSI team at TokenRhythm describes an agentic harness that turns human commands into verified training optimizations—not single-kernel demos, but end-to-end distributed jobs with OOM-aware search.

Artifacts: github.com/TokenRhythm/InfraRSI and infrarsi.github.io.

TL;DR

Why training infra needs agents, not just AutoTuner scripts

Isolated kernel RSI papers optimize one matmul or flash-attention variant. Real training runs fail for boring reasons:

• A parallelism degree tweak blows peak memory
• Two patches conflict in the inductor
• Timer jitter makes the agent pick the wrong config
• Silent numeric drift passes loss threshold once, then diverges

InfraRSI’s response is a fixed task contract: workload definition, loss invariants, and timing invariants agreed before search. Agents cannot claim victory by skipping gradient steps or shrinking eval batches without detection.

That design choice is what Hugging Face commenters praised: editable scope is bounded up front, and failed trials count toward cost.

InfraRSI five-stage agent workflow for training optimization

Image: TokenRhythm

Memory modeling with censored OOM trials

A distinctive piece is global execution-time and peak-memory models fit across all trials, including OOM failures as censored data points. Instead of throwing away crash runs, InfraRSI prices memory per setting and revises LLM priors after live measurements.

It also pairs memory-hungry wins with memory savers—critical on MoE stacks where one kernel speedup can push activations over the cliff.

Stacked GPU memory layers beside a training job timeline, illustrating censored OOM trials

Reported speedups

The paper tests four workloads spanning single- and multi-node dense and Mixture-of-Experts training. Headline numbers:

• Up to 2.75× end-to-end speedup
• Mean MFU from 17.4% to 30.0%
• Claims of beating existing tuners and coding agents on the same harness

MFU matters because TSMC and lab capex narratives assume training throughput keeps climbing—harness efficiency is how labs stretch rented GPU hours.

Two-level RSI loop

InfraRSI describes:

1. Online prior revision within a single optimization run
2. Cross-cluster experience bank distilling settings that transfer across GPU generations

That is closer to how human ML platform teams actually work—except automated and logged.

How to evaluate InfraRSI safely

1. Clone TokenRhythm/InfraRSI on a dev cluster with the same CUDA stack you use in prod.
2. Run doctor on a known baseline job you already trust—verify invariant hooks see your loss spikes.
3. Allow one promoted patch per week with human diff review; never auto-apply to checkpoint pipelines.
4. Compare against your existing manual playbook and SGLang or vLLM tuning notes for serving—not training—so you do not conflate problems.

Relationship to other 2026 harness papers

Hugging Face’s Librarian bot links cousins such as ForgeTrain, ForgeKernel, and AutoTuneBench—all agent + measurement loops. InfraRSI’s niche is full training job coupling, not serving-only autotune.

Stage-by-stage: what each phase buys you

Init is where human platform teams spend whiteboard time but rarely document. InfraRSI codifies editable paths—which Python files, which YAML launch keys—and invariants like “loss must match baseline within ε” and “step time must include allreduce.” Without init discipline, agents optimize fantasies.

Doctor profiles noise: straggler ranks, thermal throttling, NIC retries. Training autotuners that ignore noise pick configs that win once and fail nightly. Doctor’s output should become a PDF appendix your finops team recognizes.

Run is the expensive loop: propose knob vectors, apply patches, launch short runs, record censored OOMs. InfraRSI’s twist is diverse seeds instead of greedy hill-climb from one incumbent—closer to Bayesian search with LLM proposals.

Verify re-runs top candidates against the untouched baseline config. Skipping verify is how agents “speed up” training by shortening eval intervals—a classic reward hack init is meant to block.

Report / apply forces audit trails: which git paths changed, how many GPU hours burned on failures, whether promoted patches merged upstream.

MoE-specific pressure

MoE jobs explode communication and routing surfaces. A kernel win on dense models may OOM experts when all-to-all volume shifts. InfraRSI’s paper explicitly includes MoE workloads in the four-job suite—rare in generic autotune blogs. If you train Mixtral-class stacks, prioritize their MoE numbers over dense headlines.

When not to use InfraRSI

• Tiny fine-tunes on one GPU—setup dominates.
• Production without staging—never auto-merge agent diffs.
• Regulated workloads without numeric parity tests—invariants must include bitwise or tight fp checks.
• Teams lacking baseline recipes—doctor needs a trusted reference job.

Finops translation

Moving MFU 17.4% → 30.0% on a $2M monthly GPU rental is roughly $850k effective capacity returned if utilization was the binding constraint—not guaranteed if data loading or checkpoint I/O caps you. Pair InfraRSI wins with Bedrock tokenomics thinking: training savings fund inference, not the reverse.

Ecosystem map (2026 harness wave)

InfraRSI is the choice when your bill is ND-hours, not tokens per request.

Limitations

• Low GitHub star count at paper drop means rough docs—expect churn.
• Invariant design is on you; incomplete contracts let agents cheat.
• Cross-hardware bank needs enough trials to generalize; small labs may see noise.
• Not a replacement for NVIDIA’s own stack releases—watch NVIDIA snapshot GPU restore for complementary infra.

Install sketch (check README for current commands)

The GitHub README is authoritative; this is a planning sequence:

1. Clone TokenRhythm/InfraRSI and install Python deps pinned in the repo.
2. Point init at your cluster scheduler manifests (Slurm, K8s, or bare metal).
3. Register baseline job artifacts: loss curves, step times, memory peaks.
4. Define invariants with your numeric tolerance—copy values from last good production run.
5. Run doctor overnight to measure noise; do not skip on shared clusters.
6. Start run with a small epoch budget; promote only after verify passes twice.

If you use NVIDIA agent substrate on Kubernetes, align InfraRSI edits with Dynamo deployment manifests so agents do not fork divergent networking configs.

Questions for your platform lead

• Who signs off when an agent patch touches NCCL environment variables?
• Do we log failed-trial GPU hours separately from successful training?
• Can we replay experience bank entries on Blackwell after Hopper tuning?
• What is our rollback if loss invariant passes but downstream eval fails?

Paper metadata

• arXiv: 2611.11558
• Org: TokenRhythm on Hugging Face
• GitHub stars on Nov 11: about 18 on TokenRhythm/InfraRSI—expect rapid commits post-publication

Human-in-the-loop policy template

Agents accelerate search; humans retain merge keys.

Why RSI language is not hype here

“Recursive self-improvement” usually triggers sci-fi panic. InfraRSI uses it narrowly: the harness updates its own priors from trial logs and reuses them on new clusters. That is platform learning, not autonomous AGI. Frame it that way when briefing security reviewers.

Pair with checkpoint tooling

Faster iterations multiply checkpoint frequency. If your stack uses NVIDIA snapshot restore, ensure promoted configs still restart cleanly from mid-epoch checkpoints—not only from step zero.

Document cluster topology beside every InfraRSI report: same knobs on four-GPU dev boxes may OOM on 64-GPU tensors parallel jobs. The experience bank only transfers when metadata includes parallelism mode, sequence length, and microbatch—not just GPU SKU names.

Skeptical VPs will ask whether 2.75× survives your data loader. Schedule a doctor week where loaders stay fixed and only comm kernels change; if speedups vanish, your bottleneck was never MFU-visible matmuls.

Share failed-trial cost dashboards with finance the same way you share Bedrock tokenomics inference dashboards. Training agents that burn GPUs on illegal configs are still spend, and InfraRSI’s honesty about failures is only useful if leadership reads the report.

When briefing legal, emphasize InfraRSI does not exfiltrate weights—it edits configs and source in your VPC. Still require branch protections so an agent cannot push to main without review, mirroring Claude Code ownership practices. Re-run smoke training after every merge; a patch that wins on four GPUs may still destabilize eight-node expert parallelism you have not tested yet. Keep a human-written baseline config tagged golden for rollback during agent experiments on shared clusters, and never delete it while InfraRSI trials are active.

Related reading

• NVIDIA snapshot checkpoint restore
• Raindrop reasoning agent memory
• FP4 pretraining rare facts
• TSMC Anthropic OpenAI investment context
• Infrathon long-horizon infra agent benchmark
• WorkflowArena orchestration benchmark
• Deletion Tuning sparse post-training

Repository and paper links reflect Hugging Face paper 2611.11558 as of November 11, 2026.

Contributors fixing InfraRSI issues should open upstream PRs; downstream forks drift quickly when the experience bank format changes between commits.