Apodex 1.1 gains from agent coordination, but full research runs still fail

When an LLM is no longer enough

Ask a model to write an email, answer a question, even solve a coding problem, and everything looks fine. But the moment a task runs for an hour — reading files, running code, hunting for sources, surviving failures, and finally handing back something you can check — most systems start falling apart.

That is what the paper Apodex 1.1: Scaling Agentic Intelligence for Complex Work is about. The authors argue for treating AI as a system whose job is to carry work through to the end. It has to move toward a goal step by step, hold state, not lose progress, and hand over a result somebody can verify.

The model race increasingly comes down to one question: can you hand a system a long task from real work.

What work capability means

The paper's key new term is work capability. By it the authors mean neither knowledge nor writing quality, but the ability to move toward a real goal over a long stretch, verifiably.

Put plainly, a good system here has to be able to:

🟠 understand the task and what exactly counts as a finished result

🟠 work with files, search and executable code

🟠 hold state across steps

🟠 fix errors without losing what is already done

🟠 deliver artifacts that can be checked and used downstream

This is where the line runs between a clever chatbot and a working AI agent. One idea repeats throughout the paper: the unit of measurement is completed work, not an answer.

Two axes of scaling

The authors build Apodex 1.1 around two ideas.

The first is environment scaling. The model is trained not on abstract prompts but in environments that have files, search tools, repositories, tests, time limits and acceptance criteria.

The second is coordination scaling. The system learns to break a long task into parts, hand subtasks to other agents, collect intermediate results, revise the plan and shut down branches that lead nowhere.

Simplified, the logic goes like this:

🟣 one axis governs what world the agent learns to work in

🟣 the other governs how it organizes work over time and across agents

This is not another round of giving the model more tools. Here tools, state, verification and coordination all become part of one trainable system.

What is inside the system

At the center sits the model itself. Around it, a shared execution harness and a layer called AgentOS. It holds the working state: files, sources that have been found, code-run outputs, artifacts, the dependencies between them and the status of each task.

The paper spends a lot of time on why long work cannot live in the conversation alone. Context gets compacted, chunks of the history get lost — but the task's external world stays: files change, code produces new data, some results have been checked and some have not. So the authors move all of it into separate, persistent state.

Several design decisions follow from that:

🟠 separate spaces for input files, the working area and final results

🟠 an explicit task board for multi-agent coordination

🟠 a provenance log for artifacts: where each one came from and what backs it up

🟠 a separate gate on publishing final files, so the agent cannot ship an empty stub or a stale version

For anyone building AI agents, this is one of the most practical parts of the paper. The reminder it carries: a long task is a problem of state and execution, not only of reasoning.

How the multi-agent side works

Apodex 1.1 uses an Agent Team mode. There is a lead agent. It looks at the task as a whole, decomposes it into subtasks and spawns specialized subagents as needed.

What is interesting is the specific set of behaviors the authors train into the system:

🟣 writing the plan down explicitly on the task board

🟣 accepting user intervention mid-run

🟣 checking claims through separate, narrow verifications

🟣 redirecting compute only to the contested or important spots

Three planes of coordination: the lead agent with its task board, subagent sessions in a shared workspace, and a publication layer where the result is checked against a list of files declared in advance.

The asymmetric verification mode is the most curious piece. Instead of telling a second agent to solve the whole thing over again, the system hands it a narrow question: check this number, this fact, this conclusion, this formatting requirement. That lowers the risk of the checker simply reproducing the errors of the main solution.

In many agent systems verification exists in name only: the model rereads itself and agrees with itself. Here the authors try to make the check more independent and more concrete.

How the system was trained

Training comes in two large parts.

First, supervised fine-tuning on a mixed set of trajectories: reasoning, tool use, search, files, code, coordination, error recovery, delivery of the result.

Then reinforcement learning on long agentic tasks. Here the authors address the problem of diffuse reward signals head-on. In a long task, a failure at the end does not tell you which step ruined it.

Their approach amounts to a local edit of the trajectory: find the pivot points where the agent took a wrong turn, keep the useful prefix, and fine-tune the continuation with a short corrective prompt. At inference time that prompt is gone.

It reads as a practical idea: rather than penalizing the entire long chain, teach the agent to act better at the points where the decisions that matter are actually made.

Quality on three held-out task sets rises along with the amount of reinforcement learning: the thin line is raw measurements, the thick one smoothed.

What the results showed

The paper's central claim: Apodex 1.1 lands in the leading group on a set of hard benchmarks, even though the model itself is smaller than many frontier competitors.

The comparison runs in two modes:

🟠 ReAct — close to the bare model, with minimal scaffolding

🟠 Agent Team — the same model, but with multi-agent coordination and additional organized compute

That makes it possible to see what the model contributes and what the coordination contributes.

Six benchmarks: blue is Apodex 1.1 in Agent Team and ReAct modes, pale blue is version 1.0, gray is other models. Coordination helps almost everywhere.

On professional and applied tasks the numbers look like this:

🟣 APEX-Agents: 34.4 in ReAct and 38.5 in Agent Team

🟣 GDPVal: 69.5 in ReAct and 78.8 in Agent Team

🟣 FrontierFinance: 48.7 in ReAct and 54.3 in Agent Team

🟣 FrontierScience-Research: 55.0 in ReAct and 63.3 in Agent Team

The results in short:

🟠 the Agent Team gain over ReAct holds across different classes of tasks

🟠 it is most visible in finance, research and professional pipelines

🟠 the compact 35B-parameter version improves as well

The picture is clear: coordination helps almost everywhere, but ReAct on its own is already noticeably stronger than the previous Apodex 1.0. That means the authors improved the underlying working policy, not just the external scaffolding.

Why the compact version matters

The paper gives separate billing to Apodex 1.1 Mini at 35B parameters. For the market this is arguably more interesting than the big model's records.

Mini scores:

🟣 40.0 on FrontierFinance in ReAct and 50.2 in Agent Team

🟣 45.0 on FrontierScience-Research in ReAct and 51.7 in Agent Team

🟣 24.2 on APEX-Agents in ReAct and 27.7 in Agent Team

The point the authors are trying to prove: work capability is not the exclusive property of a giant closed model. If that reproduces, locally deployed systems for companies and labs become far more realistic.

How they score the process, not just the outcome

One of the most useful pieces of the paper is the HDS6 framework. It exists to score not just the final number but how the agent got to the result.

It covers six capability groups:

🟠 state consistency over a long trajectory

🟠 care in handling evidence

🟠 hypothesis management

🟠 reasoning about limits and failures

🟠 tool use and execution state

🟠 self-correction after verification

HDS6 in outline: six capability groups, 24 rubric items and a separate filter for process-integrity violations.

There is also a hard filter: if the agent invents a tool call or cites an action that never happened, the whole trajectory scores zero. That rule is written for an era in which plenty of systems narrate work they never did, convincingly.

On HDS6, Apodex 1.1's biggest gains are in initial task decomposition and final verification. The system got better both at planning and at not shipping half-finished output.

The same six capability groups before and after: the blue outline is version 1.0, the orange one 1.1. The gain shows up in all three operating configurations.

The case studies are the best part

The appendix contains long case studies. They show what this project is really about better than anything else in the paper.

One is preparing an input bundle for a molecular simulation. The agent has to assemble 18 linked files, fix format incompatibilities, get the simulator to accept the inputs, and deliver the complete set.

Another is microscopy image analysis. Two agents measure the same images under different rules and arrive at opposite conclusions. A third agent arbitrates and picks the definition that fits the task better and holds up when the thresholds change.

A third is a WGCNA analysis on pig RNA-seq data: 20 required files plus several supporting ones.

This is where it becomes clear why the authors talk so much about artifact delivery. A real long task rarely ends with a sentence in a chat window. Usually you are waiting on tables, charts, code, an archive, a compute log and a reproducible result.

Where the limits are

Good numbers aside, the paper is honest about its limitations.

On the internal FrontierResearchBench, which requires running a scientific pipeline end to end and delivering every artifact, everyone scores low. Apodex 1.1 with Agent Team gets 12.4% full passes. The best external systems in that table get 20.6%.

That matters. Even the best agent systems still routinely fail to carry a long scientific task through without losses. They can do plenty of the pieces separately, but a full reproducible research cycle remains a hard target.

Why this matters

The paper pins down something simple: the next big competition in AI is over getting work done, not over answer quality.

If you are building AI agents for analytics, science, enterprise documents, finance or coding, a few ideas here are worth taking:

🟣 a long task should be designed around state, not around the chat

🟣 the training environment matters as much as model size

🟣 coordination between agents should be learned behavior, not a set of rigid scripts

🟣 verification should be narrow, independent and tied to artifacts

🟣 the final result should be formally checkable

The takeaway

Apodex 1.1 pushes the conversation about AI agents toward something more practical. Instead of asking whether a model can reason, the authors ask: can the system work toward a goal through weeks, files, code and checks, and hand over a result.

The answer so far is partial. On many benchmarks the system already looks like a member of the leading group. Multi-agent coordination gives a noticeable boost. The compact 35B version shows that work capability carries over to a smaller scale. But on genuinely long scientific pipelines, the failures are still frequent.

If you want reliable AI agents for real work, you have to train and measure completed work trajectories, not answers.