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

Core Idea§

Argus is a general-purpose agentic runtime designed for long-horizon reasoning tasks. Unlike fixed-pipeline or stateless agent frameworks, Argus maintains a durable project state that persists across missions. The runtime separates stable user intent from operational objectives, constraints, and verification criteria. It employs four specialized roles—Manager, Planner, Engineer, and Reviewer—that execute bounded missions while jointly deciding what to remember, reuse, or reject.

Runtime Architecture§

Argus treats all runtime artifacts (memories, skills, procedures, verifiers, routing decisions, and even rejected routes) as first-class objects. Each artifact is admitted into persistent state only after a role-owned review and, when available, a task-native verification step. This prevents low-quality or unverified information from accumulating. The model weights remain fixed throughout; self-evolution emerges purely from the persistent runtime state and the control policy that schedules the roles. Autonomous execution continues between operator-owned escalation points, allowing the system to persist when evidence supports the current approach and pivot when measurements reveal failure, hidden constraints, or a misspecified objective.

At each decision point, a candidate artifact $x$ (e.g., a new memory or route) is committed only if:

$$ \text{commit}(x) = \mathbb{1}[\text{Reviewer}_{\text{role}}(x) = 1 \wedge (V_{\text{native}}(x) = 1 \text{ if available})] $$

Verification-Gated Self-Evolution§

Self-evolution is driven by a verification gate that controls which experiences become permanent. Over multiple benchmark waves, Argus accumulates verified skills and procedures, and prunes ineffective routes. This leads to measurable efficiency improvements. For example, mature SWE-Bench waves use $21\%$ fewer solve-input tokens and $15\%$ less active workflow time per task than startup waves:

$$ \Delta_{\text{tokens}} = \frac{T_{\text{startup}} - T_{\text{mature}}}{T_{\text{startup}}} = 0.21 $$

During these waves, the runtime recorded 34 verifier recoveries (capturing mistakes via native verification) and 22 strict review-loop rescues (where Reviewer overruled a faulty plan). This demonstrates that the fixed-weight harness can revise, recover, and accumulate verified approaches without gradient updates.

Results§

On SWE-Bench Pro, Argus achieves 78% versus 59% for Direct Copilot while using 1.41 times the aggregate tokens. It 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.

Code Sketch§

The runtime loop can be sketched as follows:

class ArgusRuntime:
    def __init__(self, roles, state):
        self.roles = roles  # Manager, Planner, Engineer, Reviewer
        self.state = state  # durable project state

    def run_mission(self, mission):
        plan = self.roles['Planner'].plan(mission, self.state)
        for step in plan:
            result = self.roles['Engineer'].execute(step)
            review = self.roles['Reviewer'].review(result, mission)
            if review.fail:
                self.state.rejected_routes.append(step.route)
                return self._recover(mission)  # pivot
            # verification gate
            if step.native_verifier and not step.native_verifier(result):
                self.state.verifier_recoveries += 1
                return self._recover(mission)
        # admit verified memories/procedures
        self.state.memories.append(self._verified(result))
        return result

This illustrates the fixed-weight, state-evolving design that separates execution from verification and enables long-horizon autonomy.