🤖 AI

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

Argus is a general-purpose, fixed-weight agentic runtime that achieves superior long-horizon reasoning performance across diverse benchmarks by utilizing a persistent, self-evolving state managed by specialized roles to autonomously verify, recover, and refine mission trajectories.

Original authors: Boxiu Li, Zimo Wen, Yijia Fan, Junxiang Lei, Sufeng Guo, Jiaao Wu, Ruize Tang, Mukai Li, Yifei Shen, Xiaoyu Chen, Wanbo Zhang, Runjing Gu, Yifei Gao, Yuheng Wu, Xuyao Huang, Zelong Zhao, Jiachen Zhang

Published 2026-08-06

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Boxiu Li, Zimo Wen, Yijia Fan, Junxiang Lei, Sufeng Guo, Jiaao Wu, Ruize Tang, Mukai Li, Yifei Shen, Xiaoyu Chen, Wanbo Zhang, Runjing Gu, Yifei Gao, Yuheng Wu, Xuyao Huang, Zelong Zhao, Jiachen Zhang, Shibo Hu, Hangxi Guo, Yilin Chen, Yuzhe Zhang, Fan Yang, Chuan Wen, Xian Zhang, Xuanhe Zhou, Zhijie Deng

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Long-Haul Detective: Why AI Needs a Memory and a Coach

Imagine you are trying to solve a massive, multi-day mystery, like figuring out how to build a working robot from scratch or writing a novel that actually makes sense. If you were a computer program from a few years ago, you might have tried to solve it by reading the instructions, taking a guess, and then immediately forgetting everything you just did before trying again. This is how many early AI "agents" worked: they were like a detective who solves one clue, then suffers total amnesia, and has to start the whole investigation over from the beginning every single time they hit a dead end. They were fast at reading, but terrible at learning from their own mistakes over a long period.

The field of "long-horizon reasoning" is all about fixing this. It asks: How can an AI keep a plan going for days or weeks, remember what it tried yesterday, and change its strategy when it realizes it's going the wrong way? The key idea here is that being smart isn't just about having a big brain (a powerful model); it's about having a good notebook (persistent memory) and a strict coach (verification) who stops you from lying to yourself when you get stuck. This paper tackles the problem of how to build an AI system that doesn't just run in circles but actually evolves its own methods over time, getting better at solving hard problems without needing to be retrained from scratch.

Meet Argus: The AI That Learns to Pivot

Meet Argus, a new kind of AI "runtime" (think of it as the operating system or the engine that runs the AI's brain). The researchers behind Argus, a team from Microsoft and several top universities, realized that for an AI to tackle truly hard, long-term projects, it can't just march forward blindly. If the AI is trying to fix a bug in a giant software codebase or prove a complex math theorem, it might spend hours going down a path that turns out to be a dead end. A normal AI might just keep pushing, wasting time and energy. Argus is different: it's designed to pivot.

Think of Argus like a highly organized research team working in a shared office, rather than a single person working alone. This team has four distinct roles, and they never mix up their jobs:

The Manager: The boss who holds the big picture. They make sure the team stays focused on the original goal (like "build a robot") even if the daily plan changes.
The Planner: The strategist who breaks the big goal into small, doable tasks for the day.
The Engineer: The builder who actually writes the code, runs the experiments, or does the math.
The Reviewer: The strict quality control inspector. Their job is to look at what the Engineer built and say, "This is good," "This needs fixing," or "Stop, this path is a dead end."

The magic of Argus is that it treats failure as data. When the Engineer tries a method and it fails, the Reviewer doesn't just say "oops." They record exactly why it failed. This record is saved in a permanent "project state" (the team's shared notebook). Later, if the team tries to go down that same dead-end path again, the system remembers, "Hey, we tried this yesterday and it didn't work," and pivots to a new idea. This is called verification-guided persistence. The system only "learns" (updates its memory) if the Reviewer verifies that the new information is actually true and useful.

What They Found: Better at Fixing Code and Writing Papers

The team tested Argus on some incredibly difficult challenges to see if this "team with a memory" approach actually works.

1. The Code Fixing Test (SWE-Bench Pro)
They gave Argus 731 real-world software bugs to fix. This is like giving a programmer a messy, broken codebase and asking them to fix it without human help.

The Result: Argus successfully fixed about 78% of the bugs.
The Comparison: A standard AI tool (Direct Copilot) managed to fix only 59% of them.
The Cost: Argus used about 1.41 times more computer "tokens" (the basic units of thinking) than the standard tool.
The Takeaway: Argus was significantly more accurate, even though it thought a bit more. It proved that taking the time to check work and remember past mistakes pays off.

2. The "Getting Smarter" Test (Self-Evolution)
Here's the coolest part. The researchers watched Argus over time. They didn't change the AI's brain (the model weights stayed exactly the same). Instead, they just let the system build up its "notebook" of skills and memories.

The Result: As the system ran more tasks and filled its notebook with verified skills, it got faster and cheaper. In the later stages of the test, Argus used 21% fewer tokens and 15% less time per task compared to when it was just starting out.
The Meaning: The AI didn't need to be retrained to get better; it just needed to remember what it learned. It evolved its own "runtime state," becoming a more efficient worker without changing its fundamental brain.

3. The "Don't Lie to Yourself" Test (Reviewer Intervention)
The team tracked how often the Reviewer stepped in. Out of 731 tasks, the Reviewer was called in for 466 of them.

The Rescue: In 43 cases, the Reviewer said, "This isn't done yet, try again." After the Engineer tried again, 34 of those tasks were successfully fixed, and 22 were fixed so well that they passed a second, stricter review.
The Block: The Reviewer also stopped the system from claiming victory on 35 tasks that were actually impossible or broken. This is huge: it means the system learned to say "I can't do this" instead of hallucinating a fake solution.

Beyond Code: Math, Chips, and Papers

Argus didn't just stop at fixing code. The team showed it could handle other "long-horizon" tasks:

Math Research: In a campaign to prove a complex math theorem, Argus kept a record of one path that was proven false (a "falsified route"). Instead of deleting it, it kept it as a "do not enter" sign. This helped the system avoid that dead end later and successfully strengthen the theorem's boundaries.
Writing Papers: They ran six different research projects to write scientific papers. The system handled 254 missions, survived 16 major rollbacks (where it had to go back and change its whole plan), and still managed to finish all six papers. One project even turned a failed idea into a successful "negative results" study, proving that sometimes finding out what doesn't work is a valid scientific discovery.
Designing Chips: In a scary test, Argus designed a computer chip (ACE-2). The system wrote the code, checked the timing, and the final design passed all the strict hardware checks. The system even knew exactly what it didn't check (like whether the chip would work in real life), and it listed those limits clearly.

The Bottom Line

Argus shows that for AI to do real, long-term work, it needs more than just a big brain. It needs a system that separates the "boss" from the "worker," keeps a permanent record of what worked and what didn't, and has a strict "reviewer" to stop it from making up answers.

The paper suggests that by using this "verification-gated" approach, AI can solve harder problems, get more efficient over time without needing to be retrained, and even admit when it's stuck. It's not a magic wand that solves everything instantly, but it's a massive step toward AI that can actually work with us on long, complex projects without getting lost or lying about its progress. As the authors note, this isn't just about getting a higher score on a test; it's about building a system that can persist, pivot, and evolve its own methods to tackle the messy, long-term challenges of the real world.

Technical Summary: Argus – A General-Purpose Agentic Runtime for Long-Horizon Reasoning

1. Problem Statement

Long-horizon reasoning tasks (e.g., software repair, mathematical proof, scientific discovery) are not merely races to execute a fixed plan for more steps. In practice, standing user intent often remains stable while the operational objective, constraints, and verification criteria must be refined as evidence accumulates. Current agent systems face a critical ambiguity: a system that abandons its stated target may have discovered the target was misspecified, or it may have failed and rationalized the failure. Without a mechanism to distinguish these, systems suffer from "goal drift," where objectives degrade to whatever the executor can finish.

Existing approaches typically remove this choice by fixing the objective and optimizing execution toward it, or they rely on session-limited transcripts that lose continuity when contexts are compacted. This leads to three failures in long-running agents:

Continuity Failure: Evidence motivating a revision is lost when transcripts are dropped.
Acceptance Failure: The component performing the work also declares it complete, creating a conflict of interest.
Experience Failure: Only final artifacts survive, preventing refuted routes from serving as evidence for future pivots.

2. Methodology: The Argus Runtime

Argus is a persistent, self-evolving agentic runtime designed to permit and safely manage "verified pivoting." It separates the model's fixed parameters from a mutable, durable runtime state.

2.1 Core Architecture

The system operates on a durable project state divided into bounded missions. It employs four model-driven roles with distinct authorities:

Manager: Anchors the standing user intent ( $\iota$ ), campaign state, and stage transitions. It admits material refinements to the operational contract.
Planner: Decomposes the current state into bounded tasks and dependencies.
Engineer: Implements tasks, invokes tools, and runs experiments. It may perform self-review on low-risk, bounded work.
Reviewer: Independently inspects artifacts and execution records. It issues completion verdicts (done, continue, blocked) when required by policy or request.

These roles operate across three planes: Control (scheduling), Execution (work), and Records (immutable history).

2.2 Verification-Gated Persistence and Self-Evolution

Argus introduces a verification-gated admission mechanism. The runtime state ( $H_t$ ) includes memory, skills, tools, verifiers, and routing policies.

Fixed-Model Evolution: The underlying model weights ( $\theta$ ) remain fixed. Evolution occurs only in the persistent state and control policy.
Admission Protocol: Candidate updates (memories, skills, rejected routes) become reusable only after:
1. Generation by a role (e.g., Engineer).
2. Review against task-native evidence and artifacts.
3. Commitment by an authorized owner (e.g., Reviewer or Manager).
Contract Refinement: The working contract is modeled as $K_t = (\iota, o_t, c_t, v_t)$ , representing standing intent, operational objective, constraints, and verification criteria. Refinements are admitted via a ManagerAdmit operator that requires evidence ( $e_t$ ) and authority ( $u_t$ ), ensuring that pivots are distinguishable from drift.

2.3 Process-to-Capability Theory

The system treats the process trajectory as a superset of the final artifact. It defines Dense-Intelligence Density ( $\rho_I$ ) as the rate of relevant reasoning, effective action, and valid verification per unit time. It posits that retaining the full process record (including failed branches) provides a decision-theoretic advantage (Blackwell information ordering) over the final artifact alone, allowing future missions to avoid dead ends and leverage verified exclusions.

3. Key Contributions

The paper outlines seven specific contributions:

Formalization: A contract model ( $K_t$ ) and ManagerAdmit operator for verified pivoting over long horizons.
Runtime Design: A system where contract refinement is role-owned and logged, separating stable intent from operational changes.
Reviewer Routing Metrics: Empirical data showing that independent Reviewers are invoked for 63.7% of SWE-Bench Pro tasks, with specific recovery rates for revision requests.
Paper Production Case Study: A six-project campaign spanning 640 hours and 254 missions, demonstrating end-to-end research lifecycle management including rollbacks and negative-result pivots.
Mathematical Trace: A role-resolved reconstruction of a mathematical campaign retaining one falsified route and six proof-backed updates.
Benchmark Performance: A unified evaluation across seven arenas, establishing a capability floor without sacrificing end-task performance.
Upstream Adoption: An Argus-optimized RWKV6 kernel merged into the upstream Flash Linear Attention repository.

4. Results

4.1 Benchmark Performance

Argus was evaluated across seven heterogeneous arenas:

SWE-Bench Pro: Achieved ~78% accuracy compared to 59% for Direct Copilot, using 1.41× aggregate Tokens.
AARRI-Bench: Reached 76.8% on research-intern tasks (vs. 68.3% reference).
Math-Reasoning Data Synthesis: Achieved a 28.0 gap (pass@4 - pass@1), outperforming references (Arbor: 20.83, Claude: 8.33).
GPU & Training: Achieved competitive results on B200/H100 nanochat training (0.9636 BPB vs. human best 0.9646) and nanoGPT speedruns (79.77s vs. human 80.18s).
MLE-Bench Lite: Secured 9 medals (3 Gold, 3 Silver, 3 Bronze) across competitions with external verification.

4.2 Longitudinal Efficiency (Self-Evolution)

In the SWE-Bench Pro run (731 tasks), the system demonstrated verification-gated runtime self-evolution:

Mature vs. Startup: Mature waves (W19–22) used 21% fewer solve input Tokens and 15% less active workflow time per task compared to startup waves (W1–6).
Reviewer Recovery: Of 43 tasks where the Reviewer requested revision, 34 (79.1%) later passed the official verifier, and 22 (51.2%) completed a strict review-loop rescue.
Non-Monotonicity: The trajectory was not monotone; difficult task waves (W23–24) showed resource rebounds, and the system recorded 34 verifier recoveries and 22 strict rescues, proving the system's ability to recover from initial failures.

4.3 Vertical Case Studies

Mathematical Campaign: Retained a falsified route and six theorem-frontier updates. The system successfully pivoted from a failed reduction to a proof-backed bound strengthening.
Paper Production: Six projects reached submission completion. One campaign pivoted from a positive method claim to a 4,500-row negative-results diagnostic study after seven "no-go" rollbacks.
Hardware (ACE-2): The runtime designed an inference accelerator (Qwen2.5-0.5B W4A8) certified for a specific scope (mapped synthesis, static timing) with explicit exclusions (no power signoff, no silicon validation).
Materials Science: The runtime simplified a published MOF generation method by identifying and removing a confound in the original comparison, resulting in a simpler, more effective method.

5. Significance and Claims

The paper claims that Argus demonstrates a general, self-evolving harness capable of revising, recovering, and accumulating verified approaches without forcing every long-horizon trajectory into a success claim.

Distinction from Drift: By requiring evidence-backed, role-gated admission for state changes, the system distinguishes rational pivoting from failure rationalization.
Process as Data: The retained trajectories form structured data for future supervised and reinforcement learning, connecting model outputs to concrete states, tools, and review decisions.
Modest Scope: The authors explicitly state that the "self-evolution" is fixed-model (state-based, not weight-based) and that the results are observational. They do not claim the system has achieved general artificial intelligence or that it can replace human researchers entirely. The system is presented as a tool that "stops" when objectives are underspecified, surfacing constraints the user may have missed, rather than blindly optimizing toward a potentially flawed goal.

The report concludes that the runtime successfully combines broad task capability, verified accumulation across missions, and sustained research delivery, providing a new paradigm for long-horizon agentic systems where persistence and pivoting are managed through verification rather than fixed planning.