Ken Ammon is CEO of CodeHunter, a serial entrepreneur who exited OPĀQ and NetSec, and former U.S. Air Force captain at the NSA.
A new generation of defense technology companies is reshaping how modern warfare is built, deployed and scaled.
The narrative is familiar by now: autonomous drones, unmanned vessels, swarm coordination and AI-driven battlefield systems. These platforms emphasize speed, adaptability and cost efficiency, often drawing lessons from Ukraine and Iran, where inexpensive, software-coordinated systems have changed the economics of conflict.
But the real shift isn’t hardware. It’s software, and it’s introducing a new attack surface we are not yet prepared to defend.
The battlefield is being overrun by code.
Many of today’s defense startups are building what are effectively operating systems for warfare. These command-and-control platforms integrate sensors, coordinate autonomous systems and orchestrate real-time decision-making.
The hardware may be inexpensive. The software is where the value, and the risk, resides.
These platforms are designed to be composable and extensible, where new capabilities are added through software updates. Third-party components are integrated dynamically, and autonomous systems execute code without direct human oversight.
This is a fundamentally different model from traditional defense systems, which are closed, static and tightly controlled. In a software-defined battlefield, code is continuously entering, moving through and executing across operational environments. And every one of those events is a trust decision.
AI is changing the threat dynamic.
At the same time, attackers are adopting AI-assisted development to enable a new class of threats that are faster, more adaptive and harder to detect using traditional methods.
For instance, malicious code can now be generated and modified automatically, tailored for specific environments or targets and deployed through automated pipelines and agents. It’s often used once and discarded.
This breaks one of the core assumptions of traditional security: that malicious artifacts will resemble something we’ve seen before.
They increasingly don’t because AI allows attackers to mutate code continuously, changing its structure, its packaging and even aspects of its execution path in seconds. The observable characteristics that detection systems depend on, like hashes, signatures and known patterns, have become short-lived.
Machine-Speed Attacks Vs. Human Defense
This creates a new, deeper problem that goes beyond detection techniques, and relates to timing.
Modern defense and operational environments are moving at machine speed. Security workflows, by contrast, still follow a largely reactive timeline: code executes, telemetry is generated, alerts are issued, analysts investigate and response follows.
That model assumes there is time to observe, analyze and respond.
In AI-assisted attack scenarios, there often isn’t. Compromise can occur within minutes, or less, of execution. Credentials can be exposed, systems modified and operations disrupted before a high-confidence alert reaches a human decision-maker.
By the time security engages, malicious software has already run.
Execution is the new attack surface.
As defense systems become more open and software-driven, the primary attack surface is no longer just the network or the endpoint. It’s code execution. Every software artifact, including binaries, scripts, firmware updates or third-party modules represent a potential entry point.
This is especially true in environments where autonomous systems are executing code without human validation, software supply chains are delivering components directly into operational systems or AI agents and development tools are modifying and deploying software in real time.
In these scenarios, the question that matters most is whether the code being executed should have been trusted in the first place. This question is not being asked consistently today.
To secure software-defined defense systems, the decision point needs to move. This requires a shift from recognition to evaluation. Instead of asking, “Is this known to be malicious?”, security needs to focus on “What is this code designed to do, and is that behavior authorized?”
In this model, software does not inherit trust based on origin, signature or supply chain validation. Every artifact is treated as untrusted until its behavior is evaluated against policy. This is the foundation of a zero-trust approach to code that focuses on intent:
• What actions can this code perform?
• What system resources can it access?
• What privileges does it require?
• What persistence mechanisms are embedded?
• What external communications does it initiate?
Traditional security models produce probabilistic outcomes, typically tagging artifacts as malicious, suspicious or unknown, and requiring human analysis to resolve ambiguity. This doesn’t scale in battlefield environments where software is moving at machine speed.
An intent-based, zero trust for code approach produces deterministic decisions:
• Allow execution when behavior aligns with policy.
• Block execution when it violates defined constraints.
• Quarantine or escalate when further analysis is required.
In software-defined combat systems, trust cannot be assumed. It has to be established continuously, and before execution.
Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?