Apodex 1.1: Scaling Agentic Intelligence for Complex Work

B. An, B. Li, B. Wang, B. Zhang, B. L. Wang, C. Feng, C. Wei, C. Xue, C. Zhang, D. Ng, D. Ye, E. Min, F. Chen, F. Liu, F. Yang, F. Ye, G. Sun, H. Ji, H. Xu, H. Yang, H. Ye, H. Zhang, H. Zhao, J. Li, J. Lin, J. Xia, K. Jin, K. Wang, K. Yang, L. Bing, L. Lei, L. Su, Le. Wang, Lu. Wang, N. Wang, Q. Ren, Q. Yang, R. Li, S. Bai, S. Du, S. Li, S. Lin, S. Nie, S. Wang, S. Zhang, S. Z. Wang, T. Ge, Ta. Q. Fang, Ti. Q. Fang, W. Fang, W. Li, W. Zhang, X. Chen, X. Li, X. Tang, X. Wang, X. Xu, X. Zhang, X. Q. Wang, X. Y. Wang

Apodex 1.1 scales agentic intelligence by treating long-horizon work as a verifiable, stateful execution problem.

How can we scale agentic systems to reliably complete complex, long-horizon professional tasks that require file manipulation, code execution, and multi-agent coordination?

General-purpose models often fail at complex work because they treat tasks as isolated prompts rather than long-horizon projects requiring persistent state, tool use, and failure recovery. Apodex 1.1 addresses this by scaling two dimensions: environments that provide diverse, verifiable worlds for the model to act in, and coordination behaviors that allow agents to decompose, delegate, and replan work across time. Across professional, scientific, and coding benchmarks, Apodex 1.1 achieves frontier-level performance while using a significantly smaller model footprint than many competing systems.

Paper Primer

The core mechanism is a unified execution harness that binds the model to persistent workspaces, file systems, and code environments. By training on trajectories that include explicit state transitions, recovery steps, and multi-agent coordination, the model learns to treat "completed work" as the primary unit of intelligence rather than just generating plausible text.

The system uses an "Agent Team" architecture where a lead agent decomposes objectives onto an explicit, shared task board. This board acts as a persistent control surface: subagents read their scope from it, attach results back to it, and the lead agent uses it to reconcile evidence or revise plans when observations change the problem.

Apodex 1.1 reaches frontier-level performance across finance, science, and coding tasks.

System-level evaluation on FrontierFinance and FrontierScience-Research benchmarks compared against existing frontier systems. Competitive with leading systems despite using a 35B-parameter "Mini" variant that is locally deployable.

Environment scaling improves task execution reliability.

Training on diverse, verifiable file, search, and code trajectories rather than static prompt-answer pairs. Marked improvement over Apodex 1.0 Mini on overlapping tasks.

Why is "working capability" a better metric than standard reasoning benchmarks?

Standard benchmarks often measure answer quality in isolation, whereas working capability measures the ability to sustain progress, recover from failures, and deliver verifiable artifacts over long horizons.

How does this system handle user interventions during a long-running task?

The harness accepts asynchronous user messages that update the live task board, allowing the model to revise its plan or priorities while preserving valid, previously completed work.

For researchers and builders, this paper shifts the focus from increasing model context windows to building persistent, verifiable execution environments where agents can manage state and coordinate parallel work.

Introduction: The Challenge of Complex Work

We expose why reasoning alone fails for long‑horizon work and outline Apodex 1.1’s two scaling dimensions.

General‑purpose language models excel at isolated reasoning, yet real‑world tasks demand continuous interaction with files, code, and external tools, plus robust state management and failure recovery; this mismatch defines the core problem this paper tackles.

High‑quality reasoning is necessary but not sufficient; the missing piece is the ability to turn reasoning into sustained, verifiable work that progresses toward a concrete objective.

We broaden the set of executable worlds—files, search engines, and code sandboxes—so the model learns from richer, verifiable interactions.

Beyond a single agent, we let multiple agents cooperate, delegate subtasks, and merge asynchronous results, enabling larger chunks of work to be completed in parallel.

**Figure 1.** Apodex 1.1 reaches the leading performance band across professional work, finance, scientific research, and general reasoning.

The key shift is from pure reasoning to an agentic workflow that completes verifiable work over time.

Design Principles for Agentic Scaling

Design the loop that turns observed gaps into coordinated, trainable work.

Reasoning alone stalls on long‑horizon work because the model loses track of intermediate artifacts, cannot recover from failures, and cannot allocate fresh computation where it matters. The design therefore centers on a loop that turns observed capability gaps into coordinated, trainable trajectories.

The loop treats each uncovered shortfall as a fresh task, scales both the environment and the coordination machinery, trains on the resulting trajectories, and feeds the evaluation signal back to generate the next shortfall.

Gap 1 triggers a Task Pipeline that creates an Environment‑Scaling trajectory: a search sub‑agent retrieves citation metadata, producing a “bibliography file” artifact.

Simultaneously, a Coordination‑Scaling trajectory spawns a code‑generation sub‑agent that writes a test fix.

The harness merges the new bibliography and patched test into the workspace, preserving the original source files.

SFT trains on the combined trace (search + code actions) while RL rewards the successful reduction of the verification loss.

Evaluation runs the verifier $V_D$, which reports that the bibliography gap is closed but a new performance regression appears, defining Gap 3.

The loop isolates independent gaps, lets different scaling surfaces solve them in parallel, and guarantees that progress on one gap never overwrites valid work on another.

How does the Capability‑Development Loop differ from a standard reinforcement‑learning episode?

An RL episode optimizes a single reward signal over a fixed horizon, whereas the loop explicitly separates (i) gap detection, (ii) parallel environment and coordination scaling, and (iii) a verifier that decides which new gap to address next. The verifier’s outcome $S_D$ can spawn a brand‑new task contract rather than merely continuing the same episode.

**Figure 2.** The controlled capability-development loop. Environment Scaling and Agentic Coordination Scaling create the executable trajectories used by training; evaluation, real failures, and human feedback determine which capability gaps the next Task Pipeline should target.

These six principles—defining completed work, scaling environments, scaling coordination, a common harness, joint training, and aligned evaluation—constitute the core insight that lets Apodex 1.1 grow from a reasoning engine into a Heavy‑Duty Solver.

The Multi-Plane Architecture

Apodex 1.1 introduces a three‑plane architecture that separates coordination, execution, and publication to scale agentic work.

Complex, long‑horizon work often collapses because an agent cannot keep persistent state, recover from tool failures, or coordinate parallel subtasks.

The system is split into three horizontal planes—coordination, execution, and publication—so that each concern can be scaled and reasoned about independently.

How does this three‑plane design differ from a conventional single‑plane agent that mixes coordination and execution?

In a single‑plane design the policy must both decide what to do and perform the work in the same step, entangling planning with side‑effects. The Multi‑Plane Architecture isolates planning (Coordination Plane) from side‑effects (Execution Plane) and from the final output (Publication Plane), allowing each to be optimized, replayed, or inspected without disturbing the others.

The Coordination Plane creates a task board entry “Compute sum”, records the file path, and assigns a subagent ID.

The Execution Workspace Plane spawns Subagent A, which reads `data.csv`, computes the sum 42, and writes a temporary file `tmp.txt`.

Subagent A reports the artifact back to the task board; the board marks the step completed.

The Publication Plane moves `tmp.txt` to the final location `sum.txt` after passing the manifest gate.

The user can now retrieve `sum.txt`; the Coordination Plane retains the full history for replay.

This walk‑through shows that planning, computation, and publishing are independent stages—if the execution fails, the coordination record remains intact and can be retried without re‑issuing the whole plan.

Externalizing the task board: a minimal coordination loop.

The three planes correspond to the three rows in Figure 3: the top row (Run‑Scoped Coordination Plane) routes user messages and maintains the live task board; the middle row (Execution Workspace Plane) hosts subagent sessions and their temporary workspaces; the bottom row (Filesystem Publication Plane) controls the input, share, and output directories that constitute the final deliverable.

**Figure.** The architecture diagram illustrates a multi-plane system for agentic task coordination, execution, and file management. The system is divided into three horizontal planes: the Run-Scoped Coordination Plane (top), the Execution Workspace Plane (middle), and the Filesystem Publication Plane (bottom). The Coordination Plane manages task state and agent communication, the Workspace Plane handles active agent sessions and artifact generation, and the Publication Plane manages input/output data and final artifact publishing. Arrows indicate the flow of coordination, data, publication, and user inputs between these components.

Table 1 categorizes the three “world families” (File, Search, Code) that the architecture can host, each with its own construction, verification boundary, and role.

The table categorizes different "worlds" based on their construction, verification boundary, and role. It includes three rows: "File worlds," "Search worlds," and "Code worlds."

Agent Team Coordination

Apodex 1.1 decouples coordination from execution to keep work alive across interventions.

Long‑running agentic work is frequently interrupted: new information arrives, users ask follow‑up questions, or budgets run out. Naïvely appending every message forces the model to recompute everything and discards valuable intermediate results. Apodex 1.1 therefore introduces a set of mechanisms that keep the already‑produced state alive while still allowing focused updates.

Instead of re‑generating an entire answer, a verifier receives a single claim, its evidence, and a delivery constraint, then searches for counter‑examples or format violations.

The verifier scans the claim for numeric values and locates the cited table.

It checks the dataset name against a known registry and finds no citation entry.

It returns the judgment “Missing dataset citation” together with the line number in the draft where the claim appears.

Targeted verification isolates the error source, allowing the generator to patch only the missing citation while preserving all other computed results.

How does asymmetric verification differ from a full‑re‑generation verifier?

Full re‑generation re‑runs the entire reasoning pipeline, recreating every intermediate artifact and thus re‑introducing all prior errors. Asymmetric verification limits the scope to a single claim and its evidence, so it cannot corrupt unrelated work and runs orders of magnitude faster.

The system scales inference compute only for weak or contested claims, leaving settled parts untouched.

Why not simply allocate a fixed number of agents to every task?

A fixed allocation wastes compute on claims that are already resolved and can cause unnecessary context growth. Adaptive effort concentrates resources on the few ambiguous items, keeping the overall token budget low while still improving answer quality where it counts.

After the team finishes execution and verification, a dedicated synthesis stage builds a claim‑evidence graph and lets a writer agent produce the final report.

How does the evidence graph prevent the writer from hallucinating unsupported statements?

The writer can only emit a claim if the graph contains a reachable node with a concrete evidence edge. If no such edge exists, the system either asks the lead agent to produce the missing evidence or drops the claim, guaranteeing traceability.

AgentOS exposes a stable, multi‑component workspace $W_t = (F_t, Q_t, C_t, I_t, G_t, K_t)$ that survives across turns and across subagents.

A subagent writes “draft paragraph” to /workspace/notes.txt, updating $F_t$.

The same subagent calls a search tool; the result is stored in $Q_t$ and linked to the new artifact #2 in $I_t$.

$G_t$ records edges (search → artifact #2) and (notes.txt → artifact #1).

The coordinator reads $G_t$ to decide which artifacts are needed for the next verification step.

The workspace’s explicit components let the system reason about what has been produced, what is still missing, and how to route new tool calls without losing provenance.

What would happen if a subagent wrote directly to /outputs instead of /workspace?

Writes to /outputs bypass the lease mechanism and are rejected unless the subagent holds the publishing lease. This prevents premature or accidental finalization of intermediate artifacts.

The coordinator maintains a run‑scoped Task Board outside the LLM context, tracking items with stable identifiers, owners, dependencies, and resolution states.

How does the Task Board differ from using the message history as a plan?

The message history is a linear, mutable text that gets compacted and loses stable identifiers. The Task Board preserves explicit, stable references to items and their provenance, enabling reliable dependency tracking and asynchronous updates.

A run‑scoped message queue lets users inject follow‑up directives that become model‑visible inputs without discarding existing workspace state.

What occurs when the token limit is reached during a long trajectory?

Tiered compaction evicts bodies of older tool observations first; if still over the limit, a second tier summarizes the middle of the trajectory with an LLM, ensuring the most recent context remains intact.

Publishing an artifact requires an explicit manifest and a lease that grants exclusive write authority to a single session.

Why is a lease needed for the /outputs namespace?

Without a lease, multiple subagents could write conflicting final files, making it impossible to guarantee which version the user receives. The lease enforces a single authoritative writer at any time.

This table outlines various concerns, their associated failure modes, and the corresponding mechanisms to address them.

Benchmarking Agentic Performance

Apodex 1.1 outperforms ReAct baselines across professional, finance, and scientific benchmarks.

The central claim—decoupling coordination from execution lets Apodex 1.1 reach frontier‑band results, and this section quantifies that advantage over the simpler ReAct loop.

ReAct runs a single model in a loop that alternates reasoning, tool use, and observation, without any extra orchestration.

How does ReAct differ from the classic “think‑act‑observe” loops in earlier agents?

Earlier agents often interleave planning stages or maintain separate memory modules. ReAct collapses all control into a single forward pass of the language model, so every step is just another token generation conditioned on the latest observation.

GDPVal measures how well a model’s output matches professional‑level work across 44 occupations, reporting a win‑rate percentage.

Why is a win‑rate a meaningful metric for professional work?

Professional tasks often have binary success criteria (e.g., a report passes review). Reporting the proportion of successful runs captures reliability, which is crucial when models are deployed to produce real‑world artifacts.

Apodex 1.1 with Agent Team raises the GDPVal win‑rate on professional work by +10.2 points over the ReAct baseline.

ReAct achieves 79.2 % (Table 3) while Agent Team reaches 89.4 % on the same benchmark.

**Figure 4.** Scaling trends on three held-out agentic evaluations as RL compute increases.

Apodex 1.1’s Agent Team adds double‑digit gains over ReAct across all major professional and scientific benchmarks.

Detailed Performance Analysis

Comprehensive benchmark results highlight the gains from Agent Team coordination.

We evaluate Apodex 1.1 across professional, financial, scientific, mathematical, coding, and internal benchmarks, focusing on the lift provided by the Agent Team coordination layer.

Apodex 1.1 with Agent Team attains an average score of 69.1 on FrontierSearchBench, a 12.1‑point gain over the ReAct variant and the highest among all baselines.

Table 8 reports 69.1 for the Agent Team configuration versus 57.0 for ReAct; all proprietary systems fall below 67.4.

The table compares the performance of different model configurations (Apodex 1.0 w/ Agent Team, Apodex 1.1 w/ ReAct, and Apodex 1.1 w/ Agent Team) across five benchmarks: IMO 2025, IMO 2026, USAMO 2026, ProofBench Basic, and ProofBench Advanced. A "Reference threshold" is provided for the IMO and USAMO sets.

The table presents performance scores for various AI models across two benchmarks: Terminal-Bench 2.1 and SWE-bench Verified.

**Table 8.** Results on FrontierSearchBench.

The table lists various AI models, their associated harness, and their corresponding Pass Rate (%).

Across the remaining public suites—APEX‑Agents, FrontierFinance, FrontierScience‑Research, BioMysteryBench, Humanity’s Last Exam, and DeepSearchQA—Agent Team consistently adds 3–10 percentage points over ReAct, confirming that coordinated multi‑agent computation improves both artifact quality and task completion.

Case Studies: Real-World Artifact Generation

Three real‑world runs illustrate how each architectural component impacts success.

The three case studies expose how each plane of the Apodex architecture contributes to end‑to‑end reliability: a molecular‑dynamics preparation, an image‑based apoptosis assay, and a transcriptomic network analysis.

**Figure 8.** **Top:** every file the run produced. **Bottom:** active window per agent, tool-call count at right. Agent Team Mode, Apodex 1.1; 24.7 min wall-clock; 324 recorded steps = 151 reasoning + 166 tool calls + 7 agent returns; board 7/7 resolved. **`img_measure_a`** and **`img_measure_b`** ran concurrently on the same images under different measurement definitions; **`local_verifier`** was dispatched to arbitrate rather than to re-check a single result.

Removing the `box_builder` component forces the system to fetch missing force‑field files, adding 56 bash calls.

`box_builder` attempted to build the simulation box, failed, and then retrieved four official Martini files via `web_fetch`, resulting in 56 bash calls.

Without the `gmx_installer` component the GROMACS binary cannot be obtained, requiring an extra 100 bash calls to unpack a conda‑forge build.

`gmx_installer` performed 100 bash calls to unpack the wrapper, verify subcommands, and expose a working GROMACS 2024.5 path.

Omitting the `cg_modeler` repair pass leaves file defects uncorrected, leading to an additional 105 bash calls for manual fixing.

`cg_modeler` executed 105 bash calls during a repair pass that corrected CRYST1 units, solvent bead positions, and missing `epsilon_r` in em.mdp.

Including the alternative measurement definition (`img_measure_b`) reveals a 2.4× group difference with Cohen’s $d$ = 2.88, whereas the original definition (`img_measure_a`) shows only $d$ = 0.25.

`measure_b`.csv reports 114.12 ± 31.50 vs 47.42 ± 9.09 (Welch $P$ = 0.0574, $d$ = 2.88); `measure_a`.csv reports 84.17 ± 21.98 vs 88.39 ± 8.43 (Welch $P$ = 0.78, $d$ = 0.25).

Adding the `local_verifier` arbitration step stabilises the effect size around $d$ ≈ 2.70 across ROI thresholds, preventing reversal of the group comparison.

`local_verifier` reproduced both measurement scripts, then applied its own thresholds and consistently obtained $d$ = 2.70–2.88, selecting the shared‑ROI definition as the final arbiter.

The soft‑threshold power selection in the WGCNA pipeline fails the $R^{2}\ge0.85$ criterion, achieving only $R^{2}=0.8486$ at the fallback power 20.

Power 20 yields $R^{2}=0.8486$, slope −1.917, mean gene connectivity 4.13, which is below the prescribed threshold.

Table 10 records the GROMACS simulation statistics that underpin Case 1, confirming 255 minimisation steps, a maximum force of $9.029\times10^{2}$ kJ mol⁻¹ nm⁻¹, and a potential energy of $-1.77496\times10^{6}$ kJ mol⁻¹.

Read the original paper

Open the simplified reader on Paperglide

Browse all simplified papers