A Lab That Never Sleeps
Imagine a lab with four researchers. A Manager decides what the team works on this week; a Planner breaks big goals into today-sized tasks; an Engineer actually runs experiments, writes code, and executes validations; and a Reviewer independently inspects results before the Engineer can claim "done."
This lab has no lunch breaks, no weekends, and no "I'll think about it tomorrow." It can work on one math problem for days, survive seven dead ends without crashing, and record every rejected path so future rounds never repeat them. Six papers taken from proposal to submission, 254 subtasks, 16 rollbacks—all completed autonomously.
This is not a bigger language model. This is a runtime.
Its name is Argus.
The Core Problem: Long-Horizon Reasoning Is Not "Longer Reasoning"
Over the past two years, a consensus has formed in the agent field: making a model reason *longer* does not mean it reasons *deeper*. An agent can call tools 200 times in a row, but if it never "remembers" the lessons of the first 100 failures, call 101 is no different from call 1.
The real bottleneck of long-horizon reasoning isn't context window length—it's state management:
- When to persist? The current approach seems to work, but maybe the wall just hasn't appeared yet.
- When to pivot? The approach has failed, but the failure may contain the direction of the correct answer.
- When to admit impossibility? Better to explicitly record "this path is a dead end" than to fabricate a "looks finished" result.
- Control plane: anchors the campaign, schedules tasks
- Execution plane: executes one bounded task
- Record plane: stores what happened, but never decides whether a task is complete
- Startup W1–6: minimal project-specific state
- Mature W19–22: reusable knowledge accumulated
- Tail W23–24: the hardest residual tasks
- 466 (63.7%) invoked the independent Reviewer
- 265 (36.3%) used Engineer self-review
- Reviewer demanded revisions on 43 tasks
- 34 passed official validators after revision
- 22 completed the full "continue → revise → complete" loop
- Forward latency: 0.199ms → 0.168ms (1.18x)
- Forward+backward: 0.900ms → 0.747ms (1.21x)
- All 13 correctness gates passed
- All 14 repo tests passed
- Manager recovered the campaign after a budget failure
- Planner first chose a cheap falsification test, then changed the success criterion from "collect observations" to "produce a proof"
- Engineer retrieved literature, ran executable checks, wrote proofs
- Reviewer vetoed an overstated path, demanded additional checks, and finally accepted a tighter bound
- Division beats unification: Argus's four roles and "small model triage + big model recheck" pipelines are the same principle—specialized roles do specialized jobs.
- Granularity isomorphism: "campaign → mission → round" mirrors trajectory-level optimization—the unit of management should match the unit of behavior, which for agents is a multi-step trajectory, not a single call.
- The evaluation blind-spot law: a task that passed in round one isn't necessarily correct in round two; the Reviewer's revision funnel is the engineering answer.
- Solve at a different layer: rather than training the model to reason, Argus outsources reasoning coordination to the runtime—the model generates, the runtime reviews and accumulates.
- The model can be swapped (GPT-5.5 → GLM-5.2; the runtime keeps running)
- Sessions can break (recover from CHECKPOINT on restart)
- State can be audited (CHECKPOINT is text; humans and Reviewers can read it)
- The startup-vs-mature comparison is observational, not a causal estimate—no frozen-state matched replay
- Reviewer routing is adaptive, not random—no direct causal attribution
- The six papers come from one environment, with overlapping campaign-hours
- GLM-5.2 on Claude Code is still in progress: 70.94% with no matched Direct baseline
- Chip results stop at synthesis and static timing—no place-and-route, power, or tape-out
- The 989-crystal MOF subset scores on the same data used for design, not an independent holdout
- arXiv: https://arxiv.org/abs/2608.05144
- Full HTML: https://arxiv.org/html/2608.05144v1
- Upstream merge: FLA PR #1045
These are three decisions, but fundamentally one problem: an agent needs a memory layer more durable than model weights—without that layer degenerating into an unaudited garbage dump.
Argus's Answer: Four Roles + Three Planes + Verification Gating
Argus's architecture in one sentence: model weights stay frozen; runtime state evolves.
Four-Role Division
| Role | Responsibility | Authority | |------|----------------|-----------| | Manager | Goal management across the campaign | Only role that can change phases | | Planner | Turns current state into the next bounded task | Owns task definition | | Engineer | Executes tasks, produces artifacts | May self-review low-risk tasks | | Reviewer | Independent inspection, revision, or veto | Final gate for high-risk tasks |
The key isn't "four roles beat one." It's the asymmetric permission design: the Engineer can declare small tasks done, but any phase closure, vertical strategy change, or Engineer-requested help forces Reviewer involvement. And Reviewer and Engineer share the same artifact state—the Reviewer reads the Engineer's actual output, not a summary of it.
It's like a construction inspector who doesn't read the work log, but goes and measures the wall thickness directly.
Three-Plane Separation
The record plane has no completion authority—a seemingly redundant design that is actually critical. It prevents collusion between "the recorder" and "the executor." A record is a record; it doesn't become "complete" because the Engineer says so.
Verification Gating
This is Argus's core concept. A candidate update—a memory, a skill, a verification rule, a rejected path—is never adopted merely because some role produced it. It must pass:
1. Task-native evidence checks (tests, validators, formal checks) 2. Submission by an authorized role (Engineer self-review or independent Reviewer audit) 3. Retrieval and reuse in a subsequent task
Only after this "submit–reuse" path counts as runtime self-evolution.
Key Benchmark Results: Seven Arenas
Argus ran seven benchmarks. Because the metrics differ (accuracy, ranking, bits-per-byte, time), the authors explicitly refuse to average them into one "universal score."
| Benchmark | Argus | Reference | |-----------|-------|-----------| | SWE-Bench Pro | ~78% | 59% (Direct Copilot) | | AARRI-Bench | 76.8% | — | | Math data synthesis | 28.0-point gap | — | | GPU kernel optimization | Competitive | — | | Language model training | Competitive | — | | Research assistant tasks | Competitive | — | | Data synthesis | Competitive | — |
The SWE-Bench Pro comparison is the most direct: 78% vs 59%, a 19-point gain at 1.41x token cost. But where did those tokens go? Into planning, execution, and review—the very steps that produced the 19-point gain.
Evidence of Runtime Self-Evolution
A longitudinal analysis split 731 SWE-Bench Pro tasks into execution-order windows:
Mature windows used 21% fewer solve tokens and 15% less active time per task than startup. The same model on similar tasks became more efficient—not because the model got stronger, but because the runtime remembered which paths not to take.
The authors are honest: the curve is not monotonic. W13–18 had the lowest token usage but longer execution times—token efficiency and execution latency are not the same thing. W23–24 metrics rebound, meaning hard tasks don't get easier just because the runtime matured.
The Reviewer's Repair Funnel
Of 731 tasks:
Reviewer-routed tasks consumed 2.75x tokens and 1.80x active time on average—routing concentrates independent review on harder tasks rather than spreading it randomly.
This shows the Reviewer isn't a post-hoc commentator but a correction channel: it blocks deficient solutions, demands rework, and 79.1% of reworked solutions passed official validation.
RWKV6 Kernel: A Real Contribution Merged by Human Review
Argus didn't just chase benchmark scores. It optimized a TileLang RWKV6 kernel and submitted it to the Flash Linear Attention repo (fla-org). A Moonshot AI collaborator reviewed the generated CUDA code, found a long-sequence numerical stability issue, and required block-local exponent centering. Argus fixed it, re-ran the validation suite, and the PR was merged into main on July 20, 2026.
This is human-reviewed, upstream-accepted—not Argus grading its own homework.
The Math Campaign: Keeping a Rejected Path
Beyond benchmarks, Argus ran a multi-day Erdős–Gyárfás number theory campaign. Its record is not a linear "theorem–proof" narrative but a trace of four roles:
The final record preserves one rejected path and six proven frontier updates. The rejected path isn't a failure—it became reusable knowledge ("this road is closed"), letting later tasks skip it outright.
Like a lab's failed-experiment log: if recorded well, failure is worth more than success.
Six Papers: 254 Tasks, 16 Rollbacks
Argus also ran six complete research projects spanning evaluation reliability, vision-language matching, test-time adaptation, GUI agents, multimodal hallucination, and model quantization. All six reached the submission stage.
The point isn't "six papers written." It's that not one went through in a single pass. 286 Reviewer revision verdicts, 89 session switches, 16 phase rollbacks—real research is not a straight line but a curve of repeated detours through review and rollback.
The multimodal hallucination project illustrates this best. In a 12-hour intensive search window, seven rollback decisions rejected method paths with incomplete baselines, paths identical to baselines, and paths missing pre-registered signals. Then the Planner proposed reframing "positive mitigation methods" into "a diagnostic negative-results study," the Manager accepted the redefinition, the Engineer delivered a 5-method × 3-benchmark matrix with 4,500 lines of official scoring data, and the Reviewer bound "ineffective" and "degraded" conclusions to those outputs.
Failures are preserved as information, and only reviewed state controls the next step.
Engineering Insight: Why "Frozen Model" Is Stronger
Argus's most counterintuitive conclusion: you don't necessarily need a bigger model for better long-horizon reasoning. You need a better runtime.
CHECKPOINT.md: The Most Modest, Most Critical Design
Every Engineer and Reviewer invocation uses a fresh provider session. Cross-session continuity comes from an ordinary CHECKPOINT.md file holding persistent state, evidence references, open questions, and next steps.
The elegance: memory is taken out of model context and put into the filesystem. The model doesn't need to remember history—it just reads a file. This means:
Don't let the context window become an ever-lengthening tail—make it a projection that can be rebuilt at any time.
Honest Limitations
The paper's limitations section deserves highlighting. The authors explicitly list:
This honesty is itself verification gating: never claim what the validators don't cover.
Personal Take: The Runtime Is the New "Operating System"
Argus strengthens a conviction: in the agent era, the "operating system" isn't the model—it's the runtime.
The model is the CPU—it executes instructions but doesn't schedule. The runtime is the OS—it manages processes, memory, the filesystem, and permissions. Just as you wouldn't expect a CPU to handle context switching itself, you shouldn't expect a model to manage long-horizon state transitions itself.
Argus's three planes map to process scheduling/execution/logging; the four roles map to process/thread/file/permission managers; verification gating maps to permission checks; CHECKPOINT.md maps to persistent storage.
This analogy isn't decorative. It points to a concrete engineering direction: an agent's competitiveness lies not in parameter count but in runtime design quality. An 8B model with a good runtime might beat a 70B model with a poor one—because the latter keeps repeating past mistakes while the former doesn't.
Two threads point to the same future: lightweight, persistent, auditable runtimes are the next main battlefield of agent engineering.
Paper Links
*Argus is the hundred-eyed giant of Greek myth—some eyes always open, even in sleep. The name is precise: a runtime that never fully sleeps, watching its every step with a hundred eyes.*