Introducing NexBench: MindFort's Internal Model Evaluation
Today, we're introducing NexBench, our internal benchmark for measuring which models can lead an offensive-security harness while balancing validated findings, token efficiency, and cost across real-world environments.
Written by
Akul Gupta
In a time where 0-days can be found and exploited faster by attackers, it's more important than ever to run continuous pen-testing, against all attack surfaces that change often. With rapid advancements in model performance, this process has gotten faster, but running those same agents has also become token and cost inefficient, as they are running for 8-16 hours at a time, sometimes every day. There now becomes a disparity between the security risk of attackers finding these 0-days and the remediation needed to fix them. Efficient, performant, and abundant security became our end goal while creating MindFort.
This led us to become interested in how efficient agents were when executing offensive security tasks. For us to be able to create these offensive security agents, we needed them to be capable of running for multiple hours at a time, continuously through the year, which led us to create an internal benchmark measuring models' ability to balance token efficiency and performance.
Current evals for cybersecurity have a fatal flaw: they are boxed in. Real world environments are messy, ambiguous, and contain layered vulnerabilities that can be chained together in different ways. They also have various deployment and authentication shapes, as well as various sizes which make it challenging for agents to actually navigate through, which is half the battle. That is why we created our own, modeled off the thousands of real world environments we have observed our agents navigate through.
Introducing, NexBench. NexBench demonstrates the real world environments that agents find themselves in. By running our agents on NexBench, we aim to understand which models can find the most validated vulnerabilities, have the best price to performance ratios, and exhibit long running coherence and ability.
Our eval provides signals of a model's ability to write, reason and execute real exploits against a target, while measuring their price to performance ratio and how well the harness handles the complex environment. In our research, we have found that evaluations of agents in existing benchmarks far outperform the same models/agents in real world environments.
Setup
Our setup for NexBench uses a modified version of our harness that allows for our agent system to be more portable. The full test range is spun up in an isolated container, and the agents have full access to it, mimicking a web accessible environment.
Agents are scored on their ability to discover vulnerabilities in the following 3 severity levels: low, medium, and high. We dropped critical as its own tier as high vs. critical judgments became subjective and inconsistent over time, so we folded both into high and scored coarsely. Each finding was then re-validated by a separate judge agent, which scored the finding consistently via CVSS, and then re-exploited to confirm that the agent finding held. The vulnerabilities in the test range varied from trivial and low severity, to highly complex multi-stage vulnerabilities in atypical locations. One interesting observation that our bench captures is reviewing how an agent weaves vulnerabilities together. Since the benchmark does not have a concept of “100%” completion but rather non-deterministic scoring that follows a predictable trajectory, we are able to see how effective and how creative agents are in surprising us with newer and better ways to exploit multiple vulnerabilities together. Again, mirroring closely how in the wild agents would interact with complex environments.
Because of this, we score non-deterministically, and take the best score across multiple runs at every reasoning effort available for each model capped at a 5 hour runtime, per agent. We chose a cap time of 5 hours, as it marks a reasonable amount of time for daily pentesting.
We report 4 metrics: findings, validated findings, tokens used, and estimated token cost:
- A finding is validated if the judge agent is able to successfully reproduce the exploit, or fails otherwise.
- A model's score is a sum of all validated findings across a single run of the model in the harness.
Results
Accepted findings by severity
Validator-accepted findings per model, sorted by total volume. Each model keeps its own hue; darker shades are higher-severity findings. Hover any bar for the exact low / medium / high breakdown.
On raw performance, GPT-5.6 performed best with 87 validated findings on its best run. Opus 4.8 came in second with 68 total findings (Figs. 1 and 2).
Note: The leaderboards below rank all eleven models by the highlighted column, each shown at its best run across every reasoning effort. No model or effort is dropped from the evaluation. Click any column header to re-sort.
Leaderboard, sorted by accepted findings
All 11 models, ranked by total validator-accepted findings summed across every run. The sorted column is highlighted in orange; click any header to re-sort.
| Model | Best-run effort | ||||||||
|---|---|---|---|---|---|---|---|---|---|
| GPT-5.6 Sol | X-High | 61 | 2h 19m | 87 | 40 | $1,093 | 224.5M | 0.080 | 0.387 |
| Claude Opus 4.8 | Max | 45 | 1h 50m | 68 | 38 | $380 | 77.8M | 0.179 | 0.875 |
| Claude Sonnet 5 | Max | 34 | 4h 30m | 54 | 31 | $374 | 173.1M | 0.144 | 0.312 |
| Grok 4.5 | High | 52 | 5h 3m | 51 | 26 | $122 | 49.6M | 0.419 | 1.028 |
| GPT-5.6 Terra | X-High | 36 | 1h 6m | 49 | 19 | $215 | 80.3M | 0.228 | 0.610 |
| GPT-5.6 Luna | X-High | 43 | 1h 59m | 47 | 21 | $158 | 127.8M | 0.297 | 0.368 |
| GPT-5.5 | X-High | 41 | 1h 19m | 45 | 19 | $120 | 88.0M | 0.375 | 0.511 |
| Kimi K3 | Default | 42 | 49m | 41 | 22 | $47 | 40.0M | 0.872 | 1.025 |
| GLM-5.2 | X-High | 34 | 1h 40m | 31 | 12 | $38 | 42.7M | 0.821 | 0.726 |
| Nemotron 3 Ultra | High | 18 | 5h 3m | 16 | 2 | $92 | 261.5M | 0.173 | 0.061 |
| Kimi K2.7 | Default | 24 | 2h 32m | 14 | 2 | $14 | 17.3M | 1.005 | 0.809 |
Where it starts getting interesting is when we start to implement scoring, assigned based on severity of the finding. We assigned a score of 1 to low findings, 2 for medium findings, and 3 for high/critical findings. In general, critical and high findings were harder to find, since they required chaining multiple vulnerabilities together, which makes this metric a showcase of overall performance in offensive security workflows. Each score was calculated as shown below and the greatest score out of 3 runs per model was used.
(3 * #_of_high_vulnerabilities) + (2 * #_of_medium_vulnerabilities) + (1 * #_of_low_vulnerabilities)When weighting severity against each finding, Grok 4.5 did impressively well, scoring just below GPT-5.6 Sol, beating out Opus 4.8. It is important to note that Grok did take the full runtime to be able to produce these results, more than double of Opus, Luna, Sol, etc, but given a reasonable amount of time where a pentest should have been completed, was able to outperform most models at a very efficient token rate. Another highly time efficient model was Kimi K3, scoring a 42 in 49 minutes (Fig. 3).
Leaderboard, sorted by best score
All 11 models, ranked by best severity-weighted score — each model's strongest single run across all reasoning efforts. The sorted column is highlighted in orange; click any header to re-sort.
| Model | Best-run effort | ||||||||
|---|---|---|---|---|---|---|---|---|---|
| GPT-5.6 Sol | X-High | 61 | 2h 19m | 87 | 40 | $1,093 | 224.5M | 0.080 | 0.387 |
| Grok 4.5 | High | 52 | 5h 3m | 51 | 26 | $122 | 49.6M | 0.419 | 1.028 |
| Claude Opus 4.8 | Max | 45 | 1h 50m | 68 | 38 | $380 | 77.8M | 0.179 | 0.875 |
| GPT-5.6 Luna | X-High | 43 | 1h 59m | 47 | 21 | $158 | 127.8M | 0.297 | 0.368 |
| Kimi K3 | Default | 42 | 49m | 41 | 22 | $47 | 40.0M | 0.872 | 1.025 |
| GPT-5.5 | X-High | 41 | 1h 19m | 45 | 19 | $120 | 88.0M | 0.375 | 0.511 |
| GPT-5.6 Terra | X-High | 36 | 1h 6m | 49 | 19 | $215 | 80.3M | 0.228 | 0.610 |
| GLM-5.2 | X-High | 34 | 1h 40m | 31 | 12 | $38 | 42.7M | 0.821 | 0.726 |
| Claude Sonnet 5 | Max | 34 | 4h 30m | 54 | 31 | $374 | 173.1M | 0.144 | 0.312 |
| Kimi K2.7 | Default | 24 | 2h 32m | 14 | 2 | $14 | 17.3M | 1.005 | 0.809 |
| Nemotron 3 Ultra | High | 18 | 5h 3m | 16 | 2 | $92 | 261.5M | 0.173 | 0.061 |
Cost per accepted finding
Total standard cost divided by accepted findings, cheapest model first. Hover a bar for the calculation.
GPT-5.6 Sol also scored as the most expensive model when looking at cost to accepted finding in our evals, with Sonnet coming in second (Fig. 4). Surprisingly, Kimi K2.7, K3, and GLM-5.2 all scored the best in terms of cost per finding, which we will explore later in regards to overall efficiency.
Looking at token and cost efficiency, we can then deduce which models were able to make the most of token and dollar cost. Our x-axis measures validated points per USD, cost efficiency as a ratio, with our y-axis measuring performance per token, token efficiency. Kimi K2.7 ended up having the best dollar to finding ratio, but token use inefficiency ended up weighing down overall results (Fig. 5). Grok 4.5 performed in the inverse, with the best token efficiency, but was more expensive than Kimi K2.7, along with GLM-5.2.
Kimi K3 ended up scoring similarly to Grok 4.5 in terms of token efficiency (1.03 findings per 1M tokens vs 1.02 findings per 1M tokens) but scored significantly better in terms of dollar efficiency, at more than double the findings per USD, making it a really cost efficient choice.
Cost vs. token efficiency
Accepted findings per dollar (x) against accepted findings per million tokens (y), one point per model. Upper-right is best, hover any point for details.
Modeling score to cost in dollars, we can model the pareto frontier of the above models, based on available budgets. Grok on high ended up scoring best, with an additional $300 in spend needed by Sol on high effort to surpass Grok's performance on total points discovered (Fig. 6).
Score vs. standard cost
Every model-effort cell. The dashed orange line marks the Pareto frontier, the highest score reached at or below each cost.
A similar pattern can be observed when modeling the pareto frontier of token cost to findings, with each Grok model appearing along the frontier, no matter the reasoning effort. Additionally, K3 scored on the pareto frontier for both cost and token efficiency (Fig. 7).
Score vs. total tokens
The same model-effort cells on a log-scale x-axis, token spend ranges from roughly 1.4M to over 150M across runs.
Conclusion
As more software gets shipped, teams need to start thinking about how software can become self-securing. Long-running agents are the way forward, and to power these agents, we need to think about which models can execute tasks at an efficient cost while balancing the greatest performance. We're already seeing open source models quickly gain on closed source models like Opus, GPT, etc, and with powerful models getting cheaper, means that attackers get access to stronger weapons. Defenders must start using these same resources, to continuously catch vulnerabilities before attackers get a chance to exploit these vulnerabilities.
About the author

Akul Gupta
Co-Founder & CTO · MindFort
AI researcher focusing on LLMs in cybersecurity. Red-teamed models for OpenAI and Anthropic as part of their safety programs. Published multiple conference papers. M.S. Computer Science, UIUC.