Argus: A General-Purpose Agentic Reasoning Runtime for Long-Horizon Tasks

Core premise and problem. The paper's central thesis is that Long-horizon research is not a race to execute a fixed plan for more steps. Instead, standing intent can remain stable while the operational objective, constraints, and verification criteria become more precise. The authors argue that permitting revision of objectives is difficult because it is externally indistinguishable from failure—a system that abandons its target may have discovered the target was misspecified, or it may have failed and rationalized. The paper's position is that pivoting should be permitted and made safe by verification: an admissible pivot is supported by evidence that the previous route or objective was unreachable or misspecified, admitted through an explicit role boundary, and recorded so that later missions inherit both the change and its justification.

The Argus runtime. The paper presents Argus (Autonomous Research Generation and Understanding System), a general-purpose agentic runtime for long-horizon reasoning. Its central abstraction is a sequence of bounded missions executed against a durable project state. Authority is divided among four model-driven roles: "a Manager anchors the objective and campaign state, a Planner selects the next units of work, an Engineer implements and evaluates them, and a Reviewer inspects artifacts and run outputs before issuing the completion verdict when independent review is required or requested. These roles operate across three planes—control, execution, and records—so that scheduling, work, and record keeping remain separable even though they participate in one continuous loop. The Manager spans the campaign rather than one execution round; only the Manager may change campaign stage. Mission completion verdicts carry an explicit source: allowed low-risk bounded work may use Engineer self-review, while vertical policy, stage-closing tasks, or the Engineer's own request require an independent Reviewer."

Formal contract model. The report-level working contract is summarized as Kt = (ι, ot, ct, vt), where ι is the standing user intent that the campaign must preserve; ot is the current operational objective; ct is the set of known constraints; and vt specifies the verification criteria at mission t. Xt denotes user-visible clarifications, priorities, and unresolved questions. A material refinement is written compactly as (Xt+1, Kt+1) = ManagerAdmit(Xt, Kt, Kt′, et, rt, ut) where "ManagerAdmit is a normative operator, not one atomic production API: it projects over current GoalContract revisions, persisted operator questions, Planner replanning, Manager Stage/routing transitions, and append-only provenance."

Verification-gated fixed-model runtime self-evolution. The runtime separates model parameters from operating state: Ht+1 = U(Ht, τt, Et, Kt+1), θt+1 = θt, with Ht = Memory, Skills, Tools, Verifiers, Routing. The paper emphasizes that self-evolution occurs in the persistent runtime state and control policy while The model weights remain fixed. A complete update cycle requires: "(1) an execution trajectory produces a candidate memory, skill, procedure, verification rule, routing decision, or task definition; (2) the responsible role checks the candidate against artifacts and task-native evidence; (3) the authorized owner commits, revises, or rejects the update; and (4) a later mission retrieves the retained state as part of its starting context or execution policy. Activity that does not survive this commit-and-reuse path is not counted as self-evolution."

Theory of process-to-capability. The paper formalizes process-data dominance (Proposition 1): If Y = g(P), then Rq (P) ≤ Rq (Y) for every downstream decision problem q, meaning the typed process record is Blackwell-information-ordered above the final-artifact projection. Review is modeled as selective error correction via Bayes' rule: Pr(C = 1 A = 1) = αp / (α p + β (1 − p)). Reuse value is defined counterfactually: GL (∆Ht) = Σ γ j−1 [Rqt+j (Ht) − Rqt+j (Ht ⊕ ∆Ht)], and "GL > 0 means that the accepted memory, skill, verifier, routing rule, or certified dead branch reduces future loss under a prespecified task distribution."

Benchmark results across seven arenas. The suite covers software repair, GPU kernels, language-model training, training speed, research-assistant tasks, and mathematical data synthesis, with each metric reported in native units and not cross-normalized. Key results:

• SWE-Bench Pro: Argus reaches approximately 78% accuracy versus 59% for Direct Copilot at 1.41× aggregate Tokens.

• SOL-ExecBench (B200, 101 kernels): Two head-to-head wins over Recursive and Global #6; 2×#1; 7 top-3.

• nanochat B200: 0.9636 BPB vs Human best 0.9646.

• nanochat H100: 0.9855 BPB vs Human best 0.9879.

• nanoGPT speedrun: 79.77 s vs Same-device human 80.18 s.

• AARRI-Bench: 63/82 (76.8%) vs Paper best 68.3%.

• Math-Reasoning Data: 28.0 gap vs Arbor 20.83; Claude 8.33; Codex 6.25.

An in-progress run replaces GPT-5.5 with GLM-5.2 at a 200K-token context window, driven through Claude Code, and is currently at 70.94% accuracy, demonstrating transfer across backbone and execution surface. An eighth arena (MLE-Bench Lite) is partial: nine medals, evenly split into three gold, three silver, and three bronze under a reviewer-approved medal gate.

Reviewer routing and recovery (RQ3). Of 731 SWE-Bench Pro tasks, 466 (63.7%) invoke an independent Reviewer, while 265 (36.3%) use Engineer self-review. The Reviewer requests another implementation round on 43 tasks; After revision, 34 pass the official verifier and 22 complete the strict continue→revision→done loop. Additionally, 35 tasks receive a blocked verdict, recording that the runtime cannot complete them rather than emitting an unsupported completion. Reviewer-routed tasks consume 2.75× as many solve input tokens and 1.80× as much active time as self-reviewed tasks on average, indicating the routing policy selects a harder workload.

Longitudinal efficiency (RQ2). The 731-task trajectory is divided into task-weighted windows: W1–6 (startup), W7–12 (early reuse), W13–18 (composition shift), W19–22 (mature operation), and W23–24 (late difficult tasks). The primary finding: Mature operation W19–22 uses 21% fewer solve input Tokens and 15% less active workflow time per task than startup W1–6. The pattern is explicitly non-monotone: The lowest-Token window, W13–18, reaches a 50% reduction from startup but requires more active time, and The final difficult-task window rebounds in both metrics (Token index 126 vs 100 at startup). The paper cautions: "Because the task sequence is not replayed against a frozen runtime state, the evidence characterizes system-state accumulation over this sequence; attributing the reduction to an individual memory or Skill update calls for a matched frozen-state replay."

Mathematical campaign (RQ4, C5). One Erdős–Gyárfás campaign is reconstructed as a role-resolved Agent trace. The campaign retains one falsified route and six proof-backed deltas, including one stricter bound and two bridge results. Specifically, the frontier includes the 27-to-25 strengthening and two bridge lemmas; a falsified route (C5) is retained where The witness disproves the proposed P13-free reduction. Efficiency attribution over Rounds 12–17 (18 bounded missions) yields 56.0% reasoning, 55.4% verification, and 55.6% action direct shares; the strict action score is 10/18 = 55.6%; if the seven successful auxiliary missions are also credited, the inclusive score is 17/18 = 94.4%. Notably, The early witness check that killed a proposed reduction counts as an efficient action because it pruned a false route before a long proof attempt.

Paper-production case study (C4). Six autonomous paper-production campaigns span 640 campaign-hours, 254 bounded missions, 576 Engineer rounds, 286 Reviewer revisions, 89 session rolls, and 16 Stage rollbacks, with all six canonical pipelines reaching the submission Stage and producing AAAI- and ACL-formatted manuscripts. The representative multimodal-hallucination campaign (163.6 hours) shows the control mechanism: seven no-go gates reject weak routes, then Planner proposes changing the claim from a positive mitigation method to a diagnostic negative-results audit, followed by a five-method by three-benchmark matrix with 4,500 official-scored rows, and Two later submission checks return the project to benchmark to repair scorer provenance and GPU telemetry before the final 10-page AAAI-formatted package completes the pipeline. The paper notes Manuscript completion does not imply venue acceptance, novelty, or external peer review. The case also exposes a consistency failure: The compositional-matching pipeline reaches a complete submission Stage and produces its final PDF, while the last stored assurance object remains BLOCKED on a Manager-stage authority check, showing derived certification state can lag the canonical pipeline state.

ACE-2 chip vertical (C6-related). Argus specified ACE-2, wrote its RTL, built its verification environment, and drove it through mapped synthesis and static timing without a human author of record. The design executes Qwen2.5-0.5B end to end in W4A8 with functional closure: Layer 0 matches the reference on all 18 ordered operators exactly, and the two-token runtime completes 13,914/13,914 commands over 1,240,410,384 simulator cycles. Physical closure: Canonical SKY130 HD mapped synthesis and OpenSTA at TT 25 °C / 1.80 V report 62,283 cells and 0.614 mm2 of non-SRAM area against an operator-set cap of 2.0 mm2, with +0.6966 ns detailed setup slack. Critically, The certificate is dated 2026-08-04 and was issued by a Reviewer that did not perform the work, bound to one RTL tree hash, and It enumerates its own exclusions: no routed timing, no power signoff, no DRC/LVS, no GDS or tapeout, no silicon validation, no generation beyond two tokens, no external deployment interfaces, and no FPGA prototype.

Materials-generation vertical. Against an external chemistry validator (MOFChecker) the runtime arrived at a smaller method than the one it started from, and that the step which made this admissible was removing a confound rather than adding a component. After separating integrator from score changes: Separating them attributes +1.92 points to the integrator alone, which does not reach significance (p=0.238), and +9.00 points to the score inside a fixed SDE (p=2.0 × 10−9). The decisive comparison holds model, integrator, score, forward-pass budget, and the same 989 crystals fixed and shows Independent generation followed by best-of-K selection beats the published Feynman–Kac steering at every budget; the K=8 difference survives a paired test (p=0.0486). The mechanism: at λ=2 the median effective sample size is approximately one, and 72.1% of crystals collapse to a single particle after resampling. The paper records limits: The 989-crystal subset is the same data on which the score was designed, so the numbers above are not an independent holdout, and every number here is scored by the same validator the selection optimizes against, which is exactly the failure mode Section 8 names for verifier-shaped objectives.

Upstream adoption (C7). An Argus-optimized TileLang RWKV6 kernel was reviewed by a Moonshot AI-affiliated FLA collaborator and merged into fla-org:main (pulling request (PR) #1045; commit c70f11c). The submitted H100 evidence reports a forward latency reduction from 0.199 ms to 0.168 ms (1.18×) and a forward-plus-backward reduction from 0.900 ms to 0.747 ms (1.21×), with 13 correctness-gate passes and 14 repository tests. The external reviewer identified a long-sequence numerical-stability issue, and requested block-local exponent centering, which Argus applied before merge.

Contributions (C1–C7). The paper lists seven contributions: (C1) formulation of long-horizon research as verified pivoting over the contract Kt with the ManagerAdmit operator; (C2) a runtime with typed, logged, role-owned surfaces where generated memories, skills, verifiers, routing decisions, and rejected routes become reusable only after evidence checks and an authorized commit; (C3) measurements of verification routing (466 Reviewer-invoked tasks, 34 verifier recoveries, 22 strict rescues, 35 blocked, 21% fewer tokens and 15% less time at maturity); (C4) the six-project paper-production case study; (C5) the role-resolved mathematical trace; (C6) a capability floor across seven benchmark arenas in one unified table; and (C7) external adoption of the RWKV6 kernel.

Limitations. The paper acknowledges: User-guided pivots are not publicly evaluated prospectively; Contract refinement can still fail because a Manager or operator can approve a poorly framed tradeoff; Verification is only as sound as its evidence boundary; the SWE-Bench Pro comparison is observational rather than causal (Matched frozen-state runs, randomized task orders, and randomized review routing will separate the contributions of persistent state, role separation, and review); ACE-2 is certified for a demonstrated scope, not for silicon; and the paper-production case establishes end-to-end lifecycle behavior and recovery under review across six domains and two venue formats, not paper acceptance, scientific novelty, or superiority to human research teams.

Conclusion. "Argus is a persistent, pivot-capable runtime for long-horizon research... the runtime should persist while evidence supports the current route and pivot when verification exposes a failed approach, hidden constraint, or misspecified objective. The self-evolution claim is deliberately fixed-model and verification-gated": "Candidate memories, skills, procedures, verifiers, routing decisions, and rejected routes alter future work only after evidence checks and an authorized commit; model parameters do not change. Thus a failed branch can become reusable progress without allowing an unverified narrative to rewrite the campaign. Finally, These trajectories also define a natural interface to model training. Supervised, preference-based, and reinforcement-learning methods can use the accumulated objectives, actions, measurements, revisions, and state transitions to internalize parts of the long-horizon research loop."

1. Add a verified mission-contract loop instead of an open-ended agent loop.

Improvement: Give every long-horizon agent a persistent contract K = (standing intent ι, operational objective o, constraints c, verification criteria v) plus an explicit open-question set X. A Manager role owns intent and stage transitions; a Planner emits bounded, scoped missions; an Engineer executes; a Reviewer issues verdicts. Any modification of o/c/v must pass through an explicit admit operator that demands evidence of unreachability or misspecification, is issued through a defined role boundary, and is appended to provenance that later missions inherit.

Capability: The system can run long research campaigns that legitimately change their own operational objective when evidence proves it wrong — without being indistinguishable from a system that simply gave up. It can pivot, record why, and have every future mission inherit both the change and its justification.

2. Support evidence-gated pivoting with explicit rejection of rationalization.

Improvement: Encode the admission rule: a pivot is admissible only if (a) evidence shows the previous route or objective was unreachable/misspecified, (b) it crosses an explicit role boundary, and (c) it is recorded in append-only provenance. Unsupported, narrative-only course changes are inadmissible.

Capability: The system can distinguish the target was misspecified from I failed and am rationalizing, so it can abandon a dead objective without eroding user trust, and can defend the pivot with traceable evidence rather than post-hoc narrative.

3. Separate model weights from operating state and evolve only the state.

Improvement: Maintain H = Memory, Skills, Tools, Verifiers, Routing as a persistent runtime state that is updated while model parameters θ stay fixed. Every state update must complete the full cycle: candidate produced from a trajectory → responsible role checks it against artifacts and task-native evidence → authorized owner commits, revises, or rejects → a later mission actually retrieves it. Activity that does not survive this commit-and-reuse path is not counted as evolution.

Capability: The same frozen model becomes measurably more capable and cheaper over time as the runtime accumulates verified skills, verifiers, routing rules, memories, and task definitions. Because evolution lives in state, not weights, the competence transfers to a new backbone or execution surface without retraining (as in the paper's GLM-5.2 swap).

4. Retain falsified routes and certified dead branches as reusable progress.

Improvement: When verification kills a route, store the dead branch together with its counterexample or witness as a first-class, certified state object rather than discarding it. Track it in the reused-knowledge base.

Capability: A failed attempt becomes reusable progress: future missions load the certified dead branch at start and avoid repeating the wasted work. The system can accumulate knowledge from failure and honestly say this was tried, this is the witness that kills it.

5. Make blocked a first-class verdict rather than an unsupported completion.

Improvement: Add an explicit BLOCKED verdict that a Reviewer can issue, recording that the runtime cannot complete the mission with the current evidence and constraints. Log it as a durable outcome.

Capability: The system can decline to emit a completion it cannot support — in the paper, 35 of 731 tasks were correctly declared blocked — which prevents fabricated progress and gives operators an honest capability boundary per task.

6. Route verification by risk tier, not uniformly.

Improvement: Implement a routing policy where low-risk, bounded work may use Engineer self-review, but vertical policy changes, stage-closing tasks, and the Engineer's own review requests require an independent Reviewer. The Reviewer can return the task to the Engineer for revision, request a blocked verdict, or issue a completion verdict.

Capability: The system concentrates expensive verification on the tasks that need it — in the paper, Reviewer-routed tasks consumed 2.75× solve tokens and 1.80× active time but yielded 34 recoveries after revision and 22 strict rescues — so reliability improves without a uniform 2–3× cost on everything.

7. Issue certificates with explicit scope, independence, and exclusions.

Improvement: When a Reviewer certifies completion, bind the certificate to: a hash of the artifact, a timestamp, a reviewer identity that is provably different from the implementer, and an enumerated list of what was not verified (e.g., no routed timing, no silicon validation, no holdout data, no external deployment interfaces). Store the certificate as a separate assurance object from the pipeline-state object.

Capability: The system produces scientifically honest handoffs instead of overclaiming. Downstream consumers know exactly which claims are supported, and the runtime can detect consistency failures where a pipeline reaches submission while the assurance object is still BLOCKED — a failure mode the paper's C4 case actually surfaced.

8. Persist typed process records, not just final artifacts.

Improvement: Store the full typed process record P — objectives, clarifications, actions, measurements, failed routes, revisions, verification evidence, role transitions — alongside the final artifact Y, and give later missions access to P. Reason about P as information-ordered above the artifact projection (Blackwell dominance).

Capability: Every downstream decision — replanning, memory commit, skill extraction, training-data selection — operates on strictly richer evidence than a final-artifact-only system. The process record dominates for any downstream decision problem, so the system's future steps and its training signal both get higher-value inputs.

9. Exploit verification-gated self-evolution for longitudinal efficiency.

Improvement: Let the runtime reuse accumulated skills, verifiers, routing rules, and certified dead branches; track efficiency over regime windows (startup, early reuse, composition shift, mature operation, late difficult tasks) rather than assuming monotone improvement.

Capability: The same fixed-weight system can reduce cost at maturity — the paper reports 21% fewer solve-input tokens and 15% less active time per task in the mature window versus startup — while correctly recognizing that late difficult tasks rebound in cost and allocating budget accordingly.

10. Convert verified trajectories into model-training data.

Improvement: Export the accumulated mission records — objectives, clarifications, actions, measurements, revisions, ManagerAdmit pivot decisions, Reviewer verdicts, state commits — as training data for supervised fine-tuning, preference optimization, and RL. Use reviewer accept/reject/revision verdicts as preference signals, pivot-admission decisions as demonstrations of when to change course, and blocked verdicts as avoidance labels.

Capability: The long-horizon research loop — when to pivot, when to request independent review, when to block, how to commit a reusable skill, how to route risk — becomes internalized in the model itself, so a single model can later exhibit this competence even without the full runtime.

11. Keep separate planes for control, execution, and records.

Improvement: Architect the agent so scheduling/control decisions, work execution, and record-keeping are separable planes that participate in one continuous loop, with ownership boundaries: only the Manager may change campaign stage; the Planner selects next work units; the Engineer implements and evaluates; the Reviewer inspects before completion verdicts.

Capability: The system can roll back cleanly when review exposes a problem (the paper's pipeline returned from a submission check to repair scorer provenance and GPU telemetry), recover from session rolls and stage rollbacks, and keep an audit trail that makes it possible to attribute outcomes to specific roles rather than to an undifferentiated black box.

12. Detect and flag verifier-shaped objectives.

Improvement: Monitor when the same validator is used as both the generator's score and the selection criterion. Flag cases with zero independent holdout, track sampling collapse (e.g., effective sample size collapsing toward 1 and particle counts collapsing after resampling), and require an independent evidence boundary before trusting gains.

Capability: The system avoids fooling itself with objectives shaped by the verifier it optimizes against — the paper explicitly shows that separating the integrator from the score flips a result from non-significant (p=0.238) to significant (p=2×10−9), demonstrating what happens when claims are scored by the same validator used for selection. The improved system can detect this failure mode and demand a true holdout.

13. Use deterministic, independently-authored verification environments.

Improvement: When a system certifies an artifact (e.g., a chip design), require the verification environment to be authored in a way that separates it from the implementation, run full functional closure (all operators match, all commands complete over a defined simulator cycle count), and attach the hardware/software stack used.

Capability: The system can produce artifacts with genuine functional and physical closure — in the paper, a design that matched all 18 ordered operators exactly and completed 13,914/13,914 commands — with the certificate's scope

Long-horizon reasoning requires an agentic runtime that can persist when evidence supports its current approach and pivot when measurements reveal failure, hidden constraints, or a misspecified objective. We present Argus, a persistent, self-evolving runtime in which Manager, Planner, Engineer, and Reviewer execute bounded missions over durable project state. Argus separates stable user intent from operational objectives, constraints, and verification criteria, and admits memories, skills, procedures, verifiers, routing decisions, and rejected routes only after role-owned review and, when available, task-native verification. Model weights remain fixed; self-evolution occurs through persistent runtime state and control policy, with autonomous execution between operator-owned escalation points. Across seven GPT-5.5 benchmark arenas, Argus achieves about 78% on SWE-Bench Pro versus 59% for Direct Copilot while using 1.41 times the aggregate tokens. After verification-gated self-evolution, mature SWE-Bench waves use 21% fewer solve-input tokens and 15% less active workflow time per task than startup waves, while recording 34 verifier recoveries and 22 strict review-loop rescues. Argus also reaches 76.8% on AARRI-Bench and a 28.0-point gap on mathematical data synthesis, with competitive GPU-kernel and language-model-training results. Beyond benchmarks, an optimized RWKV6 kernel was merged upstream; a multi-day mathematics campaign retained falsified routes and proof-backed frontier updates; and six paper pipelines completed 254 missions with 16 stage rollbacks. These results show that a fixed-weight, self-evolving harness can revise, recover, and accumulate verified approaches while producing structured trajectories for future supervised and reinforcement learning.