One-sentence Summary

Developed by the Apodex Team, Apodex 1.1 advances agentic working capability through Environment Scaling and Agentic Coordination Scaling, enabling sustained, verifiable task completion across professional work, finance, research, math, coding, and search, while its 35B-parameter Mini model retains strong performance locally, outperforming many larger frontier systems.

Key Contributions

• Apodex 1.1 develops working capability through Environment Scaling, which expands executable file, search, and code environments, and Agentic Coordination Scaling, which trains agents to decompose, delegate, integrate, and replan across long-horizon tasks.
• A shared execution harness and AgentOS maintain task state and provenance, combine environment, artifact, and statement-level verification, and convert environment trajectories and coordination traces into reliable behavior via training.
• Across professional work, finance, scientific research, mathematics, coding, and search, Apodex 1.1 reaches the leading performance band with a substantially smaller model, and the 35B Apodex 1.1 Mini retains strong working capability in a locally deployable form while gaining from trained agent team coordination.

Introduction

General-purpose language models have become much stronger at isolated knowledge, reasoning, mathematics, and coding, but many professional and scientific workflows still require sustained long-horizon execution: finding and interpreting evidence, operating on heterogeneous files, writing and debugging code, maintaining plans, recovering from failure, and producing inspectable artifacts. Prior reasoning-and-acting, tool-use, and interactive agent evaluations have shown that answer quality alone does not reliably translate into action, and existing multi-agent systems often improve coordination without fully addressing the challenge of turning reasoning into verifiable work inside a changing environment. The authors introduce Apodex 1.1 as a general-purpose model and execution system centered on working capability. Its main contributions are Environment Scaling, which expands executable file, search, and code worlds for learning, and Agentic Coordination Scaling, which improves how work is decomposed, delegated, integrated, and revised across agents and time, both connected through a common execution harness and trained with supervised fine-tuning and agentic reinforcement learning.

Dataset

The authors use executable environment families as the core data generation and evaluation substrate. The three families share one task contract and can be composed within a single trajectory.

• File worlds

  • Source and composition: Constructed from an underlying business state, authority relationships, derivation logic, and delivery requirements, then projected into a workspace.
  • Scale: A profession-conditioned registry spans 33 domains, 318 occupations, and 1,208 deliverable clusters, with an angle layer producing distinct tasks within occupations.
  • Schema: The initial workspace $W_0$W0​ contains supplied files and an initialized runtime. Agent actions include inspection, parsing, computation, and writing. Trajectory state persists edits and executable state. Observations expose only the content requested by an action.
  • Filtering and verification: Tasks are admitted only when independent derivations agree, not because a generated answer looks plausible. Graded quantities must be re-derived by code from an authoritative source or connected through recorded provenance to an actual document.
  • Processing details: Difficulty is controlled by varying contributing systems and their history, the length of the business-logic chain, and how much of the delivery contract must be inferred from context. File count alone does not increase difficulty.

• Search worlds

  • Source and composition: Model open-web research as discovery, acquisition, and evidence synthesis.
  • Agent interaction: The agent uses structured search and fetch to inspect selected pages, with a constrained shell path for information that ordinary search and fetch cannot recover.
  • Metadata and gold object: The gold object is richer than a final answer and includes the relevant source set, claim-to-evidence alignment, and explicit uncertainty where sources conflict.
  • Verification: Retrieval provenance remains exact. Semantic support can involve bounded model-based review.
  • Processing details: Scaling changes the structure of the acquisition problem rather than merely increasing corpus size. Evidence may be distributed across sources, separated from the initial query, mixed with plausible non-authoritative candidates, or exposed through heterogeneous access paths.

• Code worlds

  • Source and composition: Combine harvested worlds grounded in real pull requests with synthesized worlds that extend beyond repository distributions.
  • Synthesized task construction: Tasks expand from verified seeds through composition, abstraction shifts, request variation, and adversarial input changes.
  • Filtering rule: Verifier hardening precedes task perturbation because transformations can invalidate an existing grader. Without this, the result is a corrupted task rather than a new executable world.
  • Verification: Uses sandboxed execution. For harvested worlds, fail-to-pass tests must fail on the base state and pass after the reference change. Pass-to-pass tests must succeed in both states.
  • Reward-hacking defense: Synthesized worlds have no external oracle, so passing the reference solution is not enough. The authors test whether a solver can obtain reward without completing the task. Only attacks that succeed in the sandbox are treated as verifier failures. Scoring is isolated from the solver.
  • Failure diagnostics: Tests passing before the fix indicate incorrect test selection. Tests failing after the fix indicate problems in the container, dependencies, or run command.

• Training and rollout usage

  • The provided excerpts do not specify explicit training split or mixture ratios. Training use is described through rollout eligibility, isolation, and replay filtering.
  • Each rollout receives an immutable world manifest and a fresh mutable sandbox. The harness materializes the initial state, preserves it during the session, and reclaims the sandbox on close or idle timeout.
  • The learning service constructs dialogue and reward, while the harness owns physical execution. Solver observations, hidden verifier state, and post-hoc labels remain separated.
  • A trajectory is retained only if its initial state can be reconstructed, tool execution is isolated, and the verifier can be replayed.
  • The replay record includes the world seed and generator version, tool versions, action/observation sequence, file deltas, verifier version, and termination reason.
  • The construction principle is “forward cheap, inverse expensive”: a generator uses latent state or a reference program to construct and solve a world cheaply, while the agent sees only the rendered workspace and must recover the relevant path under constraints.

• FrontierResearchBench

  • Source and scale: Internal FrontierChallenge benchmark collection with 97 executable tasks across materials science, chemistry, chemical engineering, life science, bioinformatics, medical imaging, environmental analysis, computational chemistry, molecular simulation, and physical modeling.
  • Task setup: Each task has a fixed objective and input data in a task-specific Docker environment. The agent must deliver a mutually consistent set of research artifacts, such as executable code, structured data, figures, domain-specific files, and a written report.
  • Grading: Each task has a custom Grader that checks required files, numerical results, formats, executable outputs, and cross-artifact consistency. Deterministic rules are combined with rubric-defined semantic judgments from GPT-5.6-Sol when qualitative scientific assessment is required. The final outcome is computed by the task Grader, not the Judge model.
  • Metric: Pass Rate is the fraction of tasks receiving the full task score. Any unmet requirement results in a non-pass.

No separate image-style cropping or shared preprocessing stage is described. Processing and assurance are family-specific and tied to each environment’s verification mechanism.

Method

The authors design Apodex 1.1 around the core observation that high-quality reasoning is necessary but insufficient for complex, long-horizon work. Scaling agentic intelligence requires a model to act in an environment, preserve authoritative state, turn intermediate results into better decisions, recover without losing valid progress, and satisfy a checkable delivery objective. The system is organized around a unified task contract defined as $\mathcal{E} = (\mathcal{W}, W_0, q, \mathcal{A}, \mathcal{T}, \Omega, \boldsymbol{B}, D, V_D)$E=(W,W0​,q,A,T,Ω,B,D,VD​). Here, $W$W represents the workspace-state space, $q$q is the objective, $\mathcal{A}$A is the set of available actions, $\mathcal{T}$T is the state-transition operator, $\Omega$Ω is the observation interface, $\boldsymbol{B}$B is the resource-budget vector, $D$D is the delivery contract, and $V_D$VD​ is the task-level verifier. This formulation ensures that success requires both a useful result and a defensible path from input to delivery.

To build a Heavy-Duty Solver, the authors introduce two primary scaling dimensions: Environment Scaling and Agentic Coordination Scaling. Environment Scaling expands the distribution of executable task contracts across file, search, and code worlds. File environments teach the model to inspect, transform, and preserve heterogeneous artifacts. Search environments focus on evidence acquisition and reconciliation under incomplete information. Code environments teach executable transformation, testing, and recovery. Agentic Coordination Scaling addresses the decomposition, delegation, result integration, and replanning required for long-horizon work. This joint training-and-runtime paradigm scales the organization of work across agents, task branches, and time.

The authors leverage a controlled capability-development loop to convert these scaling dimensions into model capability. Environment Scaling produces executable trajectories with explicit state transitions and verifiers, while Agentic Coordination Scaling produces traces of decomposition, delegation, staged return, integration, replanning, and recovery. A unified supervised fine-tuning (SFT) mixture establishes common task-execution and coordination behavior, and agentic reinforcement learning (RL) improves long-horizon decisions over both trajectory families. Runtime failures and benchmark errors determine where the next environments and coordination examples should be built, ensuring training reallocates effort toward identified capability gaps.

The execution substrate for this system is AgentOS, which maintains persistent workspace and tool state. The workspace is instantiated as $W_t = (F_t, Q_t, C_t, I_t, G_t, K_t)$Wt​=(Ft​,Qt​,Ct​,It​,Gt​,Kt​), where $F_t$Ft​ is file state, $Q_t$Qt​ is retrieved evidence, $C_t$Ct​ is executable state and logs, $I_t$It​ is the artifact index, $G_t$Gt​ is the dependency graph, and $K_t$Kt​ is optional runtime control state. Long-horizon execution requires stable names and explicit visibility rules. Each run receives three filesystem namespaces: /inputs for read-only task-supplied files, /workspace for intermediate calculations and candidate artifacts, and /outputs as the collection root for final deliverables.

The Agent Team architecture builds an explicit coordination layer on top of this shared substrate. The main agent reasons over the problem globally and decomposes it into researchable subproblems, writing its decomposition to an external Task Board. This board stores coordinator-owned resolution state outside the model message history, while the Agent Bus exposes runtime execution state for asynchronous fan-out and fan-in. Agents read immutable inputs and an optional cross-run document library, produce candidates in backend-dependent workspaces, and publish a declared manifest through a single authorized assignment. This design supports asynchronous human intervention, where user messages can update the live task board without discarding causally valid completed work.

To ensure reliability, the system employs asymmetric verification. Instead of reproducing the entire solution, a verifier receives a specific claim, its supporting evidence, and the applicable delivery constraint. Its task is to attack that claim by searching for counterexamples or checking atomic details. This produces actionable feedback that the main agent can use to reopen specific board items and dispatch focused follow-ups. Furthermore, the system utilizes Adaptive Max Team Effort, where the main agent assigns additional, independently scoped investigations only to weak, contested, or load-bearing claims. Finally, an evidence-grounded synthesis stage consumes the terminal task board and subagent reports to construct a claim-evidence graph, ensuring the final deliverable preserves decisive details and provenance.

The training process begins with an SFT stage that provides a behavioral cold start. The mixture spans general reasoning, agentic tool use, search, file interaction, coding, and multi-agent coordination. Filtering prioritizes behavioral validity by removing trajectories with invalid tool interactions or inconsistent state. To balance specialization with general capability, the authors train SFT variants over major capability domains and combine them through model-soup merging.

The reinforcement learning stage targets sustained progress over long-horizon agentic tasks. The primary algorithmic challenge is assigning useful credit within trajectories where terminal outcomes reveal little about which intermediate decisions should change. The authors introduce PIVOT-RL, which uses hindsight-guided trajectory localization. Retrospective analysis identifies consequential decision points, or pivots, where the model begins to follow an unproductive strategy. At each pivot, the useful prefix is preserved, and a localized continuation task is constructed with a short corrective hint. This converts fragment-level credit assignment into targeted policy optimization. Completed trajectories enter optimization asynchronously to handle the irregular rollout stream of long-horizon tasks.

The resulting RL training dynamics demonstrate consistent improvement across search, knowledge, and science tasks as reinforcement learning compute scales. This approach allows the model to learn from the worlds and coordination structures expanded by the environment and agentic coordination scaling dimensions, moving from a capable language model toward a robust Heavy-Duty Solver.

Experiment

The evaluation compares Apodex 1.1 under a minimal ReAct scaffold and an Agent Team mode with dynamic subagents, coordinated verification, and task decomposition. Public benchmarks and capability analyses validate breadth across professional work, scientific research, reasoning and search, mathematics, and software engineering, where Agent Team consistently improves over ReAct and the 35B mini model shows frontier-band efficiency. Internal evaluations separately validate structured search delivery and end-to-end scientific workflows with executable cross-artifact checks, while HDS6 confirms process-level gains in decomposition, verification, evidence fidelity, and hypothesis management.

Three environment families share one task contract and can be composed within the same trajectory, but emphasize different bottlenecks. File worlds center authority and transformation with verification via code-derived values or recorded provenance, search worlds center discovery and evidence alignment with provenance plus claim review, and code worlds center executable transformation with tests and artifact checks. Exact assurance means evidence is code-derived or independently reconciled, not accepted solely from a language-model judge. File worlds center authority and transformation, with verification tied to code-derived values or recorded provenance. Search worlds center discovery and evidence alignment, requiring both provenance and claim review. Code worlds center executable transformation, verified through tests and artifact checks.

AgentOS 1.1 adds runtime mechanisms that target specific failure modes across workspace state, reference integrity, coordination, live intervention, context pressure, budget enforcement, and shared delivery. The design emphasizes explicit ownership, fail-closed boundaries, and reconciliation so intermediate and final artifacts remain auditable. Shared delivery is governed by a single-publisher lease, exact manifests, scoped writes, and baseline reconciliation rather than by convention. A stable three-region namespace with explicit private and shared topology reduces ambiguous workspace ownership and backend-dependent visibility. Read-only /shares mounts prevent durable user documents from being mutated by agents. External task boards, periodic re-injection, and a finalization gate keep plan and completion state from disappearing during compaction. Message-addressable queues, interruptible waits, delivery acknowledgement, and lease renewal enable live intervention without long fan-in blocking or report races. Shared delivery blocks concurrent, undeclared, stale, or incomplete output files through a single-publisher lease, exact manifest, scoped write policy, and baseline reconciliation.

Apodex 1.1 shows consistent gains when moving from ReAct to Agent Team across scientific-research and agentic evaluations, with especially notable improvements on biomedical and frontier-science tasks. The 35B mini configuration already reaches or approaches larger frontier references on selected benchmarks and improves further with agentic coordination, indicating model-scale efficiency. Among the listed general-reasoning and deep-search reference models, scores are tightly clustered, with Kimi-K2.6 highest on Humanity's Last Exam and GPT-5.5 highest on DeepSearchQA. Agent Team improves over ReAct on FrontierScience-Research and BioMysteryBench, with particularly large gains on biomedical tasks. The 35B mini model with ReAct alone reaches competitive scores on FrontierFinance, FrontierScience-Research, and APEX-Agents, and Agent Team adds further gains. Within the reported reference rows, Kimi-K2.6 ranks highest on Humanity's Last Exam, while GPT-5.5 ranks highest on DeepSearchQA.

The 35B Apodex mini model with ReAct already reaches a strong working policy on FrontierFinance, FrontierScience-Research, and APEX-Agents, improving over the prior mini model on overlapping evaluations. Adding Agent Team coordination yields further gains, with the largest improvement on FrontierFinance. The resulting system leads the selected FrontierFinance comparison, approaches a frontier reference on FrontierScience-Research, and matches the performance band of an open-weight reference on APEX-Agents. ReAct alone improves over Apodex 1.0 mini on FrontierFinance and APEX-Agents. Agent Team produces the largest gain on FrontierFinance and lifts the 35B system above the strongest selected proprietary reference. The 35B model remains competitive with larger reference systems, leading FrontierFinance, approaching a frontier reference on FrontierScience-Research, and matching an open-weight performance band on APEX-Agents.

Apodex 1.1 with Agent Team shows a large generational improvement over Apodex 1.0 with Agent Team on competition-level proof tasks, moving from below to above the stated reference thresholds on all three evaluated competition sets. Within Apodex 1.1, Agent Team also consistently outperforms ReAct across the competition sets and IMO-ProofBench, with the largest relative gains on the more advanced proof benchmark. Agent Team lifts Apodex 1.1 above the reference thresholds on all three competition sets, whereas Apodex 1.0 with Agent Team scores well below them. On IMO-ProofBench, Apodex 1.1 with Agent Team reaches near-perfect Basic performance and substantially higher Advanced performance than ReAct. The switch from ReAct to Agent Team within Apodex 1.1 yields consistent gains on both competition-level proof tasks and proof benchmarks.

Three environment families (file, search, code) define a shared task contract while emphasizing different verification bottlenecks, with exact assurance requiring code-derived or reconciled evidence. AgentOS 1.1 introduces runtime mechanisms that enforce explicit ownership, fail-closed boundaries, and single-publisher shared delivery, keeping intermediate artifacts auditable. Across scientific, agentic, and proof benchmarks, Apodex 1.1 with Agent Team coordination consistently outperforms ReAct and prior versions, often matching or exceeding larger frontier models, with particularly large gains on biomedical, finance, and competition-level proof tasks.