Argus: Model-Invariant Runtime for Self-Evolving Agents
Argus is a runtime (not a larger language model) that lets an AI agent accumulate state across long campaigns while the underlying model weights stay frozen. The runtime coordinates four roles—Manager, Planner, Engineer, and Reviewer—across three planes and enforces a verification-gated update rule.
Architecture at a Glance
- Four roles, asymmetric permissions. Manager changes phases only; Planner defines bounded tasks; Engineer executes and can self-verify on low-risk work; Reviewer independently inspects, revises, or vetoes high-risk outputs by reading the same artifacts Engineer produced, not Engineer's summary.
- Three planes. Control plane schedules campaigns and missions; execution plane runs one bounded task; logging plane records what happened but cannot decide completion. Separating logging from execution prevents the recorder and executor from colluding on a "done" label.
- Verification-gated updates. Any candidate update—memory, skill, validation rule, rejected path—must pass (1) task-native evidence (tests, validators, formal checks), (2) authorized submission (Engineer self-check or Reviewer review), and (3) retrievable reuse in later tasks before it becomes runtime self-evolution.
- Mature windows (W19–22) vs startup windows (W1–6): 21% fewer solve tokens, 15% less active time per task.
- The curve is not monotone: W13–18 had the lowest token use but longer runtime, and W23–24 rebounded—token efficiency and execution latency are not the same axis.
- 466 (63.7%) routed to independent review; 265 (36.3%) Engineer self-check.
- Reviewer requested revisions on 43 tasks; 34 passed official validators after rework; 22 completed the full continue→revise→finish loop.
- Routed tasks averaged 2.75x tokens and 1.80x active time, indicating the router concentrates independent review on harder work rather than sprinkling it randomly.
- 79.1% of Reviewer-triggered rewrites passed official verification.
- Forward latency: 0.199 ms → 0.168 ms (1.18x).
- Forward+backward: 0.900 ms → 0.747 ms (1.21x).
- 13/13 correctness gates and 14/14 repo tests pass.
- Persistence via CHECKPOINT.md. Every Engineer/Reviewer call uses a fresh provider session; continuity lives in a plain
CHECKPOINT.md(persistent state, evidence links, open questions, next step). This makes the model swappable, sessions restartable, and state human-reviewable—memory moves from the context window to the filesystem. - Granularity match. Campaigns map to missions to rounds, mirroring trajectory-level optimization: manage behavior at the granularity where it actually lives.
- Solve at the right layer. The runtime handles coordination, scheduling, and review; the model handles generation. Good runtime on a small model can outperform bad runtime on a large one because the latter repeats old mistakes.
- Startup-vs-mature comparison is observational, not causal (no frozen-state matched replay).
- Reviewer routing is adaptive, not random, so causal attribution is limited.
- Six paper projects share one environment with overlapping campaign-hours.
- GLM-5.2 on Claude Code is still running (70.94%) without a matched Direct baseline.
- Chip results stop at synthesis and static timing—no place-and-route, power, or tape-out.
- The 989-crystal MOF subset uses the same designed-score batch, not an independent holdout.
- arXiv: https://arxiv.org/abs/2608.05144
- HTML: https://arxiv.org/html/2608.05144v1
- Upstream merge: https://github.com/fla-org/flash-linear-attention/pull/1045
Benchmark Results
| Benchmark | Argus | Reference | |---|---|---| | SWE-Bench Pro | ~78% | 59% (Direct Copilot) | | AARRI-Bench | 76.8 | — | | Math data synthesis | 28.0-pt gap | — | | GPU kernel optimization | competitive | — | | LM training | competitive | — | | Research-assistant tasks | competitive | — | | Data synthesis | competitive | — |
Authors explicitly refuse to average heterogeneous metrics into one "general score." On SWE-Bench Pro, the 19-point lift costs 1.41x tokens—spent on planning, execution, and review.
Runtime Self-Evolution Evidence
Across 731 SWE-Bench Pro tasks split into execution-order windows:
Reviewer funnel on the same 731 tasks:
Real Upstream Contribution
Argus optimized a TileLang RWKV6 kernel and submitted it to the Flash Linear Attention repo (fla-org). A Moonshot AI collaborator reviewed the generated CUDA, requested block-local exponent centering for long-sequence numerical stability, and merged the fix on 2026-07-20. Measured gains:
Math and Paper Campaigns
In a multi-day Erdős–Gyárfás campaign, the runtime kept a rejected path as reusable "this road is closed" knowledge while shipping six frontier updates with proofs. Across six full paper projects (eval reliability, vision-language matching, test-time adaptation, GUI agents, multimodal hallucination, model quantization), all reached submission stage: 286 Reviewer decisions, 89 session switches, 16 phase rollbacks. The multimodal-hallucination project ran a 12-hour search window with seven rollbacks before the Planner reframed the work from mitigation methods to a diagnostic negative-results study.
Engineering Insights
Honest Limitations
Why "Model-Invariant" Wins
The headline claim: better long-horizon reasoning does not require a bigger model; it requires a better runtime. Argus treats the runtime as the agent's operating system—scheduling processes, managing memory, enforcing permissions, and persisting state—while the model acts like a CPU executing instructions. Persistent, inspectable, lightweight runtimes are positioned as the next main battleground of agent engineering.