AgentForesight: A 7B Auditor That Catches Multi-Agent Errors While the Task Is Still Running

Researchers from Rutgers University, the University of Texas at Austin and Purdue University have presented AgentForesight: a 7B-parameter model that monitors a multi-agent system in real time and tries to spot the critical error before the task fails. The work has been accepted at NeurIPS 2026. The idea is simple to state and hard to execute: move from a post-mortem to auditing on the fly.

An Error That Doesn't Look Like an Error

In multi-agent systems, a failure rarely comes with an exception or a red message in the log. Most of the time everything looks routine. One agent states a wrong premise: it misreads the task conditions, treats an unverified fact as established, or picks the wrong approach. The other agents don't know the foundation is shaky. They read its message as input and carry on diligently. The system stays busy, tokens are consumed, and steps follow one after another. The final result turns out wrong, and the cause is buried somewhere at the start of the chain.

The authors identify exactly this scenario as the core problem. The error does not show up where it occurs. It multiplies through the trust between agents.

From Attribution to Auditing

Until now, most attention has gone to post-hoc failure attribution. The task has failed, a full log exists, and a model or a human tries to determine which agent ruined things and at which step. This kind of analysis helps with debugging and improving the system, but it can no longer save the run in question. The money and time are already spent.

AgentForesight moves the check into the process itself. A small auditor receives the trajectory as it grows and must signal when a critical slip appears in it. The 7B size looks like a deliberate choice. A supervisor that costs as much as the agent system itself makes no economic sense. A lightweight model running alongside remains an acceptable surcharge on the cost of a run.

What Is Known So Far

The available excerpt of the material contains no benchmark results, no description of the training data and no comparison with baseline methods. So what follows covers only what is confirmed.

• System type: an auditor for multi-agent pipelines
• Model size: 7B parameters
• Mode of operation: online, while the task is running
• Goal: identify the critical error before the whole task fails
• Authors: Rutgers, UT Austin, Purdue
• Venue: NeurIPS 2026
• Not disclosed in the source: accuracy metrics, latency, composition of the test sets, license and weight availability

Nearly all practical evaluation depends on this missing data. For an online auditor, accuracy is not the only thing that matters. The balance between false alarms and misses matters too. If it raises flags too often, the team will start ignoring it. If it is too cautious, there is no point in having it. Another critical parameter is how early the auditor notices the problem. A warning one step before the end is almost useless, while a warning five or six steps ahead already allows a branch to be restarted.

How to Apply This

Even without numbers from the paper, the direction is clear, and teams building agent systems should prepare in advance.

• Log full trajectories, recording which agent passed what along and on what basis. Without this, you can neither train nor test any auditor.
• Label the critical steps in your own failed runs. Such a dataset will be useful both for evaluating third-party solutions like AgentForesight and for your own fine-tuning.
• Decide what the system does when the auditor raises a signal: roll back a step, re-query the agent, bring in a human, or simply stop. A detector without a response mechanism adds little.
• Wait for the full paper and code to be published before building the method into production. The main questions are how it behaves on your tasks rather than on test ones, and how much latency it adds.

If the results prove convincing, agent oversight will become a separate layer of infrastructure with its own models and metrics.