Deep Research has already let AI search through large volumes of material, organize it, and generate structured reports. But real research work usually only begins after a report is written. The raw input might be dozens of papers, lab records, tables, images, and files in all kinds of specialized formats. Researchers need to clean data, choose methods, write code, run analyses, and interpret results. A single task usually contains multiple interdependent stages, and the plan needs to keep adjusting based on intermediate results. The final conclusion has to read well, but it also has to hold up when checked back against the data, the code, and the evidence.
This is the problem Apodex 1.1 is built to address. At the core of this release is an improvement in the model's reasoning ability itself. Search, file processing, code execution, and tool calling are not capabilities that sit alongside reasoning. They are the means reasoning uses to land in the real world. When reasoning needs data to support a judgment, it reads files and runs code. When reasoning needs to verify a premise, it searches and checks. We rebuilt this whole way of executing around reasoning. Apodex no longer treats producing a report as the finish line. Instead, it aims to be an online workbench that can work through a complex task together with the researcher, start to finish.
Being able to give a correct answer and being able to see a piece of work through to completion, verifiably, are two different capabilities. The latter requires a model to do six things: understand what a goal actually calls for, act inside real file, code, and tool environments, maintain and update its own state across a long chain of tasks, handle new feedback that keeps showing up during execution, recover from failure midway instead of starting over, and make sure the final deliverable can hold up to scrutiny. Together, these six things are what we mean by a complete unit of capability, and they're the capability foundation Apodex 1.1 is trying to build.
In one line: Apodex 1.1 takes reasoning out of the report and puts it into the execution of real tasks.
This release is centered on the Apodex 1.1 model and the online workbench it already powers. Researchers can use files, search, code execution, and Agent Team inside one long-running task, turning reasoning into inspectable and reusable work. We are also extending the same capability into local and open ecosystems. FrontierAgent provides the execution harness for File, Search, Code, and Agent Team, while the 35B Apodex 1.1 mini offers a locally deployable model. The full model represents the complete Apodex 1.1 capability envelope; Mini and the harness let developers run, control, and extend the same complex-work paradigm in their own environments.
We're growing this capability along two complementary paths. One is Environment Scaling, expanding the file, search, code, and other executable environments the model can learn and act in. The other is Agentic Coordination Scaling, expanding a task's ability to be broken down, coordinated, integrated, and reorganized across multiple Agents, branches, and points in time. Behind this is a set of capabilities all organized around reasoning: keeping reasoning running without interruption as it calls tools across complex files and data environments, which is a direct expression of Environment Scaling; letting reasoning split into multiple parallel paths that still stay coordinated as a whole, which is what we call the asynchronous Agent Team, a behavior learned through Agentic Coordination Scaling; letting users step in and redirect at any point during reasoning; keeping every step of the reasoning path and its progress visible; and having key conclusions go through an independent check before reasoning hands them over, which is what we call Statement Review. At the same time, the model's reasoning ability itself has gone through a systematic upgrade, which we cover in the technical section below.
It's also worth noting that pretraining work for the next generation of the model is already underway, and much of the engineering and data work from this release will carry directly into future versions.
Real Research Tasks Need More Than a Report
Traditional deep search products are good at working with web pages and text. But the key evidence in research tasks often lives in CSVs, Excel files, PDFs, images, experimental data, or all sorts of domain-specific formats. Summarizing literature alone can't get these tasks done. The system also needs to understand the relationships between multiple files, choose the right methods for the task, write and run analysis code, check intermediate results and revise the approach when something fails, and finally trace the conclusion back to the original data, the processing steps, and the resulting artifacts.
Apodex 1.1's goal isn't to sidestep complex data by reducing the problem to a Q&A. It's to work through the entire chain from input to deliverable inside a real file environment as much as possible. A representative example is analyzing the prognostic effect of EASIX on overall survival in patients with EBV reactivation after allogeneic transplantation. The task requires reading raw tables and data dictionaries, checking and cleaning the data, choosing the right statistical method, running survival analysis code, generating KM curves and statistical tables, and arriving at a conclusion that can be checked. If missing values, formatting issues, or a broken assumption show up along the way, the system needs to explain how it adjusted its approach and kept going, rather than getting stuck or handing back a vague answer.
Similar scenarios show up in materials science, bioinformatics, and computational drug design, such as indexing and unit cell refinement for powder XRD, batch blind docking between the GLUT3 protein and small molecules, and curve fitting for nanoindentation data in magnesium alloys. What these tasks have in common is that the input itself is specialized data rather than a description, and the model has to genuinely work inside this file-and-code environment rather than circling around the outside and handing back a conclusion.
Users Can Step In at Any Point During Execution
Complex research tasks are hard to fully define in a single instruction up front. New data might overturn the original hypothesis, early results might expose problems with the input itself, and researchers might decide partway through to narrow or widen the scope of analysis. The usual approach in the past was to wait for the final result and then start a fresh round, which gets expensive fast on long tasks.
Apodex 1.1 treats a user's mid-task intervention as part of the task itself. The system needs to understand the new requirement, judge which completed intermediate results are still valid, update the plan going forward, and keep moving from the current state instead of discarding existing work and starting over. The value here isn't just "you can interrupt anytime." What matters more is that researchers keep control over the direction of a long task as it runs, instead of submitting the task and then just waiting.
This capability is especially useful in scenarios that involve multiple files and multiple rounds of review. For example, when working through several contracts or due diligence materials, users often add new files or introduce new review criteria partway through the analysis. In that case, the system needs to preserve the analysis results that still hold, replan the affected parts, and avoid tearing down the whole task and starting fresh.
The Breakdown and Progress of Complex Tasks Stay Clearly Visible
When an Agent needs to run for tens of minutes or longer, a waiting screen with just a loading spinner can't build trust. Users need to know which subtasks the system plans to complete, what it's working on right now, which steps are done and what they produced, which steps failed, retried, or changed direction, and which points need user confirmation.
Making the task process visible doesn't mean dumping the model's raw, lengthy internal thinking onto the screen. It means providing a task state that users can understand and act on: plan, steps, artifacts, dependencies, exceptions, and next steps. This state is maintained continuously in the background by AgentOS, but the plan itself, and when the plan needs to change, is something the model works out on its own during execution, not a fixed workflow template. This matters especially on long tasks, because the completion rate alone doesn't tell the whole story. What also matters is how well the task can recover, how closely the plan matches what actually happened, and how much time users need to locate a problem.
Asynchronous Agent Team Keeps Complex Tasks Moving Forward
In Deep Discover mode, Apodex 1.1 dynamically organizes an asynchronous Agent Team based on the task. This isn't a pre-written orchestration script telling the model what to do. It's a capability trained through Agentic Coordination Scaling: the model itself decides whether a task can be broken down, how to break it down, and how many Subagents to hand it to, and keeps deciding when to consolidate results and when to adjust as execution proceeds. Multiple Subagents explore different subtasks, evidence sources, or candidate hypotheses in parallel, and feed intermediate results back to the main task continuously, rather than waiting for every branch to finish before processing anything.
Complex research tasks often contain parts that can move forward in parallel. For instance, one Agent can focus on checking literature evidence, another can analyze data, and a third can verify methods or look for counterexamples. Traditional synchronous workflows usually need to wait for a stage, or every branch, to finish before continuing. Once one branch takes too long or fails, the whole task tends to get stuck.
The core of the asynchronous Agent Team isn't just running more Agents at once. It's keeping results, feedback, and decisions flowing continuously through the task. Multiple independent subtasks moving forward at the same time can meaningfully cut down the actual time a complex task takes. Once a Subagent produces a useful finding, the main task can absorb it and update the overall state right away, without waiting for other branches to finish. When new evidence comes in, the system can reorder tasks, add branches, or cut off low-value paths. When a Subagent slows down or fails, the other branches can keep producing results, and the work already done is preserved for future planning. Users can also check progress at any point while the task is running, add files or background information, raise new requirements, or ask the system to go deeper into, pause, or drop a particular path.
Taken together, the asynchronous architecture brings two kinds of value at once. On one hand, parallel collaboration improves the speed and efficiency of the task. On the other, it creates a continuous feedback loop between the model, the Subagents, and the user, so that genuinely time-consuming, complex work stays visible, controllable, and adjustable, rather than becoming a black box you can only wait on after hitting submit.
The main task dynamically spins off multiple Subagents to explore different subtasks in parallel. Intermediate results continuously flow back into a shared task state, and the main task absorbs updates and reorders priorities in real time, without waiting for every branch to finish.
Putting Key Claims Through Independent Review
Not every sentence in an analysis report carries equal weight. What really needs close review are the key claims that shape the final judgment: whether a piece of data genuinely supports a claim of statistical significance, whether a cited paper actually says what the report says it says, whether a computed result matches what the code actually produced, and whether a given inference is a verified fact, a reasonable guess, or something that can't yet be confirmed.
Statement Review keeps generation and review as two distinct steps, so key claims go through an independent check before they reach the user. This doesn't mean the system is always right. It means the chain of evidence, potential conflicts, and uncertainty become easier to see. When the analysis runs into insufficient evidence, a citation that doesn't match, or a computation that conflicts with expectations, the system flags it, shows how the final result was corrected, and keeps a full record of the review.
Generation and review are kept as distinct steps, and key claims go through an independent check before delivery. When evidence is insufficient or a computation conflicts, the result is sent back for correction rather than passed through.
A Common Harness Connects Both Scaling Dimensions
Behind the improvement in reasoning and the execution changes described above are two complementary scaling paths and the common execution foundation that supports both.
The first path is Task Pipeline and Environment Scaling built around real Agent scenarios. The improvement isn't just about adding more coding data. What matters more is that we systematically built a richer, higher-quality set of training tasks around real scenarios like complex file processing, code execution, tool use, and multi-step task progression, spanning multiple environment categories including search, file processing, and tool use, at a scale of tens of millions of tasks. This drove overall improvement across general Agent capability, Science, Coding, and multi-Agent collaboration. Along the way, we also kept expanding the coverage of our local retrieval engine and knowledge graph, giving research tasks that need to work across papers and data sources a sturdier foundation to build on.
The second path is Agentic Coordination Scaling, the Agent Team capability described above: the model learns to decompose tasks, organize Subagents, and continually absorb and integrate results across branches.
Environment Scaling and Agentic Coordination Scaling both need to run on the same execution foundation to actually work. We call this foundation AgentOS. AgentOS maintains tool calls, file state, and task progress during a single task's execution. It manages the creation, scheduling, and lifecycle of Subagents, and provides a unified verification mechanism. The two Scaling paths aren't two separate features bolted together. They share the same underlying runtime, which is also why the capability gains in file environments and the coordination gains in Agent Team can be pushed forward together in the same training and evaluation system.
Reinforcement Learning for Long-Horizon Tasks
All these reasoning-centered capabilities ultimately depend on the model's reasoning ability holding up on long-horizon tasks. Environment Scaling and Agentic Coordination Scaling provide richer environments and task structures, but turning these into the model's own behavior is what training does. We use SFT together with agentic RL: SFT gives the model the basic shape of behaviors like tool calling, task decomposition, and multi-Agent coordination, and agentic RL then keeps refining these on real execution and coordination trajectories, so tool use, failure recovery, task delivery, and Agent Team coordination all become behaviors the model has learned, rather than effects produced by external orchestration. Apodex 1.1's reinforcement learning is built for long-trajectory Agentic Tasks, and its main focus is improving the model's ability to keep reasoning and keep working inside file, code, and search environments.
File, Code, Search, and multi-Agent coordination each involve different interaction patterns, execution costs, trajectory lengths, and failure modes, and a single successful task often needs to combine several of these capabilities at once. The central algorithmic problem is therefore how to concentrate learning on the decisions that actually change the course of a long trajectory when its final outcome provides only coarse supervision. PIVOT-RL is our primary method for addressing this problem: it shifts training from treating a trajectory uniformly to learning around the consequential decisions that change the course of the task.
Terminal outcomes on long trajectories tend to provide only coarse supervision. A successful trajectory can still contain inefficient or weakly grounded intermediate decisions, and a failed one can still contain a lot of genuinely useful early work. PIVOT-RL uses Hindsight-Guided Trajectory Localization, running retrospective analysis over a training corpus of hundreds of thousands of trajectories and questions to identify the consequential decision points, the pivots, where the model starts following an unproductive strategy, relies on insufficient evidence, misuses a tool, or fails to revise a wrong assumption. At each pivot, we preserve the prefix that was already working and construct a localized continuation task with a short corrective hint. This hint only provides directional guidance during training, is never a prediction target, and is absent at inference time. For stateful tasks, we also restore the corresponding executable environment state. These localized continuations are mixed with full, unhinted tasks during training, so the model learns efficiently at the points where it's genuinely prone to error while retaining the ability to solve a complete task on its own.
These localized trajectories, together with full, unprompted tasks, make up the RL Recipe. This lets the model learn key failure patterns more efficiently while still being able to complete a full task independently at inference time. PIVOT-RL turns coarse outcomes over long trajectories into localized learning signals around consequential decisions, improving the model's Working Capability in complex, executable environments. The corresponding scaling trends are presented with the results below, while further training details will be described in subsequent technical material.
AI4AI: Letting the Model Take Part in Training Other Models
The sustained execution, file processing, and tool-use abilities in Apodex 1.1 aren't just for completing research tasks users hand it. They can also be turned back on model training itself. One case is having Apodex 1.1 act as a Teacher: with no human involvement in data collection, labeling, or quality control, and without relying on any other strong model, it automatically generates questions, filters correct trajectories, runs evaluations, and iterates, helping a smaller model pick up a new capability.
We used this pipeline to train Qwen3.5-0.8B to use search tools and authoritative databases on agentic tasks. The evaluation covers three task types, clinical trial and drug information retrieval, protein structure database lookup, and protein sequence and function annotation lookup, totaling 200 questions. After 10 rounds of automated iteration, this small model's overall score rose from 51.0% to 56.0%. Throughout the process, Apodex 1.1 acted as the question writer, the trajectory filter, and the evaluator of training progress all at once, forming a capability improvement loop that runs on its own without human labeling. This is another way to think about Working Capability: a model with sustained working ability doesn't just complete tasks on people's behalf, it can also turn that ability into a productive force for training other models.
Apodex 1.1 Model: An Online Workbench for Complex Work
The primary release is the full Apodex 1.1 model and the online complex-work workbench it powers. Users can bring papers, datasets, spreadsheets, images, or code into one long-running task and let the model search, manipulate files, execute code, revise the plan, coordinate an Agent Team, and deliver inspectable artifacts. The workbench is therefore not a separate product story around the model; it is how the main model's Working Capability becomes usable through Environment Scaling, Agentic Coordination Scaling, and a common harness.
The main figure summarizes the level reached by this full model-and-system stack. Apodex 1.1 enters the leading band of current agentic systems on complex professional work, finance, and scientific research, while retaining broad coverage across general reasoning, deep search, mathematics, and coding. ReAct already exposes a strong underlying working policy, and Agent Team repeatedly converts additional organized computation into further gains: the main model sustains the task, while the coordination system organizes more work when the task demands it.
Apodex 1.1 Mini: High Capability Density, Locally Deployable
Apodex 1.1 mini is the clearest model-efficiency result in this release. It reaches the performance band of selected frontier systems across professional work, finance, and scientific research, improves markedly over Apodex 1.0 mini on directly overlapping tasks, and gains further from Agent Team coordination. Because several proprietary systems do not publish parameter counts, we avoid unsupported size comparisons. The important result is that a model with a disclosed 35B scale can compete in the same complex-work tables as frontier systems.
Underlying ReAct capability and the additional gain from Agent Team for the 35B Mini.
This result is directly connected to the open release. Apodex 1.1 mini can run with the FrontierAgent harness as a local ReAct or Agent Team system, keeping files, search, code execution, task state, and delivered artifacts in one workflow. Results in mathematics, coding, and deep search further indicate that this is not a narrow optimization for a few professional benchmarks, but a working policy that composes across task families.
We have also built FrontierSearchBench and FrontierResearchBench for structured evidence acquisition and end-to-end scientific delivery. A dedicated Benchmark Release Blog will present the tasks, methodology, baselines, and open-release plan.
From Reasoning to a Complete Task
Continuous work inside file and data environments, mid-task intervention, clearly visible task breakdown, the asynchronous Agent Team, and Statement Review are not separate features sitting next to reasoning. They're the same thing showing up at different points, all expressions of reasoning extending outward into real tasks. For the model's reasoning to work through a complex chain of files and data, it needs to keep calling tools without interruption. When the reasoning path runs long, researchers need to see clearly where it stands and be able to step in and redirect at any time. When a reasoning task can split into multiple parallel paths explored at once, that's the asynchronous Agent Team at work. And before a reasoning conclusion reaches the user, it still needs to go through the independent check of Statement Review. Put together, this is the complete loop of a complex task from start to delivery.
Try It Now
Apodex 1.1 is now live on the web. The online workbench is powered by the full Apodex 1.1 model and is built for complex tasks that require files, search, code execution, Agent Team coordination, and sustained delivery. Bare-model access will also roll out through major API platforms. In parallel, the 35B Mini and the open-source FrontierAgent provide a local path: developers can run ReAct or Agent Team in their own environments and integrate the same complex-work capability into existing systems. Model weights, the technical report, and developer documentation are also in progress.
Real research work has never been something search alone can solve. It requires working through enormous amounts of literature and data, following a long reasoning chain to the end, and producing evidence that holds up under scrutiny. Apodex 1.1 is a step we're taking in this direction, and we'll keep investing in file environments, tool chains, and Agent collaboration to make this online research workbench more complete. We'd also like to invite more researchers and professional users to bring their real tasks and try it out. Your feedback will feed directly into our next round of iteration.
Beyond the web app, we've also open sourced an agent framework and terminal product, FrontierAgent (https://github.com/ApodexAI/FrontierAgent). It comes with a native command-line TUI and supports two modes: ReAct, where a single agent runs research and file tasks sequentially, and Agent Team, where a coordinator breaks the task down and dispatches multiple sub-agents in parallel. On both macOS and Linux, it runs with a single command out of the box, with no need to preinstall anything or depend on Docker. When Docker is available it uses containers for stronger execution isolation, and when it isn't, it automatically falls back to a native local runtime and still works smoothly. We hope this single-machine, ready-to-run harness lets more people put Apodex's reasoning ability to work right in their own terminal.
Real-World Use Cases
Use Case 1: Law - Preference Liability Assessment
In a corporate bankruptcy clawback case, the core question was: of the six payments the company made to a creditor before filing for bankruptcy, how much could the trustee actually recover, and what defenses could the creditor raise to reduce that amount? After reading the case materials, Apodex 1.1 reconstructed the timing, payment terms, and collection history of each payment one by one, weighed the interaction between the ordinary-course, contemporaneous-exchange, and subsequent-new-value rules, and arrived at a net exposure of $550K, matching the reference answer. The model went further, providing a settlement range of 175K–350K, the key negotiating facts, and a client-ready legal memo, completing the full chain from fact-finding and legal reasoning to dollar calculation, negotiation advice, and final delivery.
Response：
https://www.apodex.ai/share/152fc4c0-0546-4042-8f92-4788c18ab77e
Sable_Orion_Preference_Memo.docx
Use Case 2: Finance - Complex Financial Instruments and Accounting Judgment
In a cross-border FX risk management task, the core question was: facing exchange-rate volatility, which option or collar structure should the company choose to manage risk, what does each structure cost, at what exchange rates does it gain or lose money, and can a more favorable hedge-accounting treatment be obtained? Apodex 1.1 not only correctly worked out the option premiums under different structures, the payoff across five settlement exchange rates, the $7.6M net collar cost, and the 1.1172 breakeven rate, but also identified that the CFO's underlying assumption about accounting treatment was itself wrong. Rather than following that flawed assumption through the calculation, the model re-derived the accounting impact of all three structures under ASC 815 and explained the effects on P&L, OCI, CTA, and subsequent reclassification risk. The model delivered a professional memo in 199 words, demonstrating the full arc from financial calculation and accounting judgment to catching a false premise and delivering in a constrained format.
Response：
https://www.apodex.ai/share/e84cd0a2-8cf9-4982-a713-180e4e91a40a
Use Case 3: Research-level Question
In a molecular dynamics modeling task, the core goal was: starting from a real three-dimensional protein structure, automatically build a computational system ready for downstream simulation. After reading the 7M6J protein structure, Apodex 1.1 chose the Martini 3 coarse-grained method to convert the structure and generate force-field topologies, then further replicated three copies of the protein and added water and physiological-concentration salt ions to build a complete GROMACS simulation system. During execution, the model had to keep the protein chains, topology files, molecule counts, and coordinate ordering all consistent with each other, and adjust the energy-minimization parameters based on actual run results. It ultimately produced a system with 69,652 simulation sites and completed energy minimization, with all resulting input files, structure files, logs, and visualizations directly usable for downstream simulation. What this task demonstrates isn't "explaining a simulation method," but actually turning a protein structure into a computational research environment that can be run, checked, and reused.
Response：
All output files are available at:
https://www.apodex.ai/share/52484ad2-134d-4167-8612-826973688fb1
Looking further ahead, what we want to build is a Heavy-Duty Solver (HDS): a system that can take on increasingly complex, long-horizon work while delivering results that remain verifiable end to end. Apodex 1.1 is one step on that path. Those capabilities — sustained tool use, self-repair, weighing alternatives, long-horizon coherence, and evidence-grounded reasoning — are hard to instill through post-training alone. That's why, next, we will build Apodex 2.0 from the pretraining stage up: a pretrained, end-to-end model purpose-built for Heavy-Duty Solver capabilities, tracked against TRACES, our benchmark for discoverative AI. More details are coming soon.
TRACES Benchmark · Full Technical Report · Github · Hugging Face · Apodex-1.0 · Contact