Dynamic Cybersecurity Reveals the True Limits of AI Agent Capabilities
Static benchmarks can show whether an AI model understands vulnerabilities, but they cannot fully measure performance in a changing adversarial environment. Results from 466 simulated engagements demonstrate why planning depth, feedback utilization, adaptive strategy, resource efficiency, and governance must all be included when evaluating security agents for real-world deployment.
1. From “Solving Problems” to “Responding to Adversaries”
Security capabilities of intelligent models have traditionally been measured with a fixed set of questions. Evaluators observe whether a model can identify vulnerabilities, generate exploitation steps, or suggest remediation measures. These tests reveal a model’s knowledge coverage and one-shot reasoning ability, but they assume a static environment: the questions do not change, vulnerabilities do not repair themselves, and defenders do not adjust their strategies in response to attacks.
Real-world cybersecurity environments work differently. Attackers continuously search for new entry points, while defenders modify configurations, update rules, close ports, rotate credentials, and respond to observed behavior. Both sides monitor the other and adjust their next decisions.
The core challenge for a security agent is therefore not simply whether it can solve a particular problem. It must complete a continuous loop across multiple rounds:
- Identify the current environment and asset state.
- Select an action with high potential value and manageable risk.
- Determine whether its reasoning was correct based on the outcome.
- Monitor changes in the opponent’s defensive behavior.
- Dynamically modify its offensive or defensive strategy.
- Achieve its objective within limited time and resources.
Security evaluation is consequently shifting from static knowledge tests toward continuous decision-making, environmental adaptation, and adversarial interaction.
2. Results from 466 Engagements Show Clear Performance Tiers
An evaluation covering 22 batches and 466 valid engagements produced clear differences between the participating systems. Two agents in the top tier achieved approximately 78.6 and 73.8 points, respectively. Another open-source model scored about 68.5 points, while the remaining systems generally scored between 56.3 and 67.1.
The more important signal is not the total score alone, but the gap in win rates. The two leading systems achieved win rates of 0.83 and 0.86, while the highest win rate among the other systems was only about 0.59.
In other words, the leading systems were not merely strong on a small number of individual tasks. They demonstrated broader advantages in multi-round interaction, strategy adjustment, and control of action value and risk.
This performance gap can be understood from three perspectives.
1. Differences in Planning Depth
A typical model may follow a “spot a clue, then act immediately” pattern. A stronger agent first builds a model of the environment. For example, it may determine:
- Which assets have the highest value.
- Which entry points have already been exposed.
- Whether an action is likely to trigger an alert.
- Whether a failed action could permanently eliminate later paths.
- Whether a vulnerability should be preserved as a backup route.
This is sequential planning under limited resources, rather than single-step answer generation.
2. Differences in Feedback Utilization
In multi-round engagements, the result of an action is itself new observational data. A failure may indicate that a vulnerability has been fixed, that the selected path was incorrect, that the agent lacks sufficient privileges, or that a detection mechanism has been triggered.
High-performing systems distinguish between these possibilities and update their strategies accordingly. Weaker systems are more likely to repeat the same action, wasting time and action budgets.
3. Whether Defensive Behavior Is Included in Reasoning
In a dynamic environment, defenders actively change system state. An offensive agent that focuses only on the initial vulnerability while ignoring defensive adjustments may perform well during the first few rounds and then fail later.
A mature system must treat the opponent’s behavior as an input variable rather than viewing the environment as a fixed problem statement.
3. Why a High Static Pass Rate Does Not Prove Real-World Capability
A control experiment from the evaluation is particularly instructive. In a single-agent mode with no defenses and two attempts per question, the systems were given 40 questions. Three leading models were each able to solve 30 of them independently.
At first glance, this suggests that the models have strong vulnerability understanding and problem-solving capabilities.
However, when the same 30 questions were placed into a two-sided adversarial setting, the results changed significantly. As defenders continued to repair and adjust the environment, the attack capture rates of the three systems fell to 52%, 37%, and 35%, respectively, by the third round.
This demonstrates that single-agent and adversarial testing measure different capabilities:
| Test environment | Primary capabilities measured | Typical characteristics |
|---|---|---|
| Static single-agent mode | Knowledge recognition, local reasoning, one-shot problem solving | The environment is fixed and failure costs are limited |
| Dynamic two-sided mode | Continuous planning, adversarial decision-making, feedback utilization | The environment changes and actions affect future states |
| Long-cycle adversarial mode | Resource management, stealth, and recovery | The agent must handle uncertainty and accumulated risk |
Being able to solve a static problem does not mean that an agent can succeed in an adversarial scenario. The main reasons include the following.
1. Vulnerability Windows Can Close Quickly
In a static test, a model can assume that a vulnerability remains available. In an adversarial environment, the defender may change access controls, update filtering rules, or replace sensitive configurations after the first round. A previously viable path may become unavailable immediately.
2. Actions Can Reveal Intent
Some operations may verify whether a vulnerability exists, but they may also leave clear traces. Once defenders identify attack characteristics through logs, traffic, or anomalous behavior, they can block the relevant paths in advance.
Successful exploitation therefore depends not only on technical feasibility, but also on whether the action is sufficiently discreet and whether its value justifies the exposure risk.
3. Failures Have Cascading Effects
In a single-agent mode, a failure usually costs one attempt. In dynamic adversarial testing, a failure may escalate alerts, invalidate credentials, close a path, or make all subsequent actions ineffective.
An agent must therefore evaluate long-term returns instead of simply maximizing the probability of success in the current round.
4. Designing a Security Evaluation System for AI Agents
Organizations that want to assess security agents accurately should not measure only how many questions they answer correctly. They should establish a multidimensional evaluation framework.
1. Task Success Rate
This is the most direct metric for determining whether an agent has completed a predefined objective. The task boundary should be clearly defined. For example, the objective might be to discover a vulnerability, obtain a specified privilege, protect a critical asset, or block an attack within a given time limit.
2. Multi-Round Retention
Compare the success rate in the first round with the rate in the third or fifth round. This shows how much performance degrades as the environment changes.
If a system performs well initially but fails quickly afterward, it is likely better at one-shot problem solving than at stable dynamic adaptation.
3. Quality of Strategy Updates
When the defender introduces a new measure, the evaluation should record whether the model can:
- Recognize that the original path is no longer available.
- Determine why the path failed.
- Discover an alternative route.
- Avoid repeating the same type of failed action.
- Assess the risks introduced by the new strategy.
4. Action Cost and Resource Efficiency
Security agents typically operate under limits on time, tool calls, concurrency, or privilege scope. Evaluations should track the number of actions required for each successful outcome, the proportion of ineffective attempts, and the share of high-risk operations.
A system with a slightly lower success rate but substantially lower resource consumption may be more valuable in a production environment.
5. Explainability and Audit Completeness
Critical agent actions must be traceable. At a minimum, the system should record:
- The environmental information observed at the time.
- The main reasons for selecting the action.
- The expected result.
- The actual result.
- The reason for changing strategy after a failure.
- Whether the action involved high-risk privileges or sensitive data.
These records support post-engagement analysis, human approval, and incident investigation.
5. A System Architecture for Enterprise Deployment
A controllable security agent should not receive unrestricted access to a production environment. A more appropriate architecture places the model inside a controlled orchestration layer governed by a policy engine, tool proxies, and auditing components.
1. Environment Observation Layer
This layer collects asset states, vulnerability information, alert events, configuration changes, and operation results. Observed data should be filtered according to permissions and have sensitive information redacted so that the model does not access unnecessary credentials or business data.
2. Task Planning Layer
This layer breaks high-level objectives into verifiable subtasks, such as asset confirmation, risk prioritization, path validation, remediation recommendations, and result verification.
The planning process should have maximum-depth and timeout controls to prevent the model from entering an endless cycle of attempts.
3. Tool Invocation Layer
All external operations should be executed through a unified proxy. The proxy is responsible for parameter validation, permission checks, rate limiting, and blocking dangerous actions.
High-impact operations, including deleting data, changing access policies, or restarting critical services, should require human confirmation by default.
4. State Memory Layer
The system needs to retain historical actions, environmental changes, and failure causes. However, it should not simply accumulate unlimited conversational context. Instead, it should use structured state information, such as:
Environment state:Asset: critical business nodeKnown entry points: Entry A, Entry BEntry A status: remediatedEntry B status: pending validationRecent alert: elevated anomalous access frequencyRemaining action budget: limited
Structured state is better suited to continuous decision-making than long conversational histories. It also makes later auditing easier.
5. Security Audit Layer
All model outputs, tool requests, execution results, and human approval records should form an audit trail that cannot be arbitrarily modified.
Organizations can combine logging, monitoring alerts, and access management capabilities to create end-to-end traceability from model decisions to actual execution.
6. Reducing Agent Errors in Adversarial Security Tasks
Adopt a “Observe First, Act Second” Default
Unless a task explicitly requires immediate action, the agent should first collect sufficient information and then select an operation. This reduces mistakes caused by an incomplete understanding of the environment.
Introduce Pre-Action Simulation
For high-risk operations, the system should first generate an impact analysis that covers the resources expected to change, alerts that may be triggered, recovery options if the operation fails, and available alternatives.
Execution should begin only after the risk assessment has passed.
Establish Failure Categories
A failure should not be recorded simply as “unsuccessful.” It should be classified as insufficient privileges, an invalid path, an environmental change, an incorrect parameter, detection blocking, a nonexistent target, or another specific cause.
Different failure causes require different strategy adjustments.
Define Human Handoff Conditions
The following situations should trigger human review:
- The agent is about to access sensitive data.
- The agent needs to expand its privilege scope.
- The action could affect production services.
- Multiple attempts have failed.
- The model has significant uncertainty about the environment state.
- The actual result differs substantially from the expected result.
Human handoff does not reject automation. Instead, risk-based controls ensure that automation is used only where it is appropriate.
7. What Developers Should Learn: A Security Agent Is Not a Larger Chatbot
These evaluations show that the core competitive advantage of a security agent is not simply model size or the volume of static knowledge. It is the complete loop of perception, planning, execution, feedback, and correction.
When building such systems, developers should focus on whether:
- The model can maintain a stable and accurate representation of the environment.
- It can distinguish facts, assumptions, and uncertain information.
- It changes strategy based on failure outcomes.
- It understands resource budgets.
- It can invoke external tools within defined security boundaries.
- Every decision can be audited and reproduced.
Without these capabilities, even a model that achieves a high score on an offline benchmark may behave unreliably in a real environment.
Conclusion
The 466 engagements demonstrate a broader shift in cybersecurity AI: the field is moving from automatically answering security questions to continuous interaction and strategic competition in dynamic environments.
Static tests can measure knowledge and reasoning ability, but they cannot fully represent real offensive and defensive performance. To determine whether a security agent has genuine engineering value, evaluations must incorporate environmental changes, opponent behavior, action costs, failure feedback, and privilege controls within a unified framework.
For enterprises, the next priority should not be limited to achieving higher single-question pass rates. Organizations also need multi-round adversarial testing, risk-based execution controls, end-to-end auditing, and human handoff mechanisms.
Whether an organization builds its own system or uses general cloud capabilities such as Baidu AI Cloud, a security agent should enter production only when its behavior is controllable, explainable, and reviewable.
