Modern fighter jets fly at the boundary of aerodynamic instability. Human pilots rely on automated systems just to keep the aircraft flying straight during high-speed turns. In March 2026, defense pioneer Saab revealed detailed performance data comparing their experimental AI fighter agent directly against traditional Fly-By-Wire flight control systems.

The operational gap between human reaction limits and machine processing speeds is widening rapidly. Military aviation software must process sensor fusion, radar tracks, and electronic countermeasures in real time. Traditional rule-based control software struggles when presented with unscripted electronic warfare conditions during combat flights.

Saab solved this bottleneck by separating basic aerodynamic stability from high-level tactical maneuvering. Their engineers paired deterministic flight control software with an autonomous agentic neural network. The resulting hybrid system demonstrates how safety-critical software architectures can safely integrate probabilistic machine learning algorithms.

The Evolution from Fly-By-Wire to Autonomous Tactical Agents

Traditional Fly-By-Wire (FBW) flight systems replaced mechanical linkages with electronic control signals in the late twentieth century. In an FBW aircraft like the Saab JAS 39 Gripen, flight control computers continuously compute aerodynamic surfaces adjustments. The system uses deterministic control laws written in languages like Ada or C to prevent stalls and structural damage.

While FBW systems excel at maintaining flight stability, they follow static rules. If an opposing fighter performs an unexpected maneuver, the FBW system simply maintains the current pilot command without analyzing tactical advantage. The pilot must observe, decide, and react manually during dogfights.

Saab's experimental AI fighter agent changes this dynamic entirely. Built on advanced reinforcement learning and state-space architectures, the AI agent evaluates surrounding airspace metrics continuously. Instead of merely executing control stick inputs, the agent computes multi-step spatial intercept maneuvers that maximize mission survival probabilities.

During simulated combat engagements conducted over northern Sweden in early 2026, the AI agent consistently outmaneuvered algorithmic baseline opponents. The system compressed the military decision cycle—known as the Observe-Orient-Decide-Act (OODA) loop—from seconds down to milliseconds. This speed advantage gives aircraft equipped with AI agents a clear tactical edge in combat engagements.

Latency, Determinism, and the OODA Loop: Quantitative Benchmarks

Engineers evaluate aerospace software using strict latency and repeatability benchmarks. Traditional avionics require deterministic runtime execution, meaning every function call must complete within a guaranteed time window. Neural networks, by contrast, rely on floating-point matrix multiplications that introduce variable execution timing.

Saab benchmarked their tactical AI agent against traditional deterministic flight algorithms across four core metrics: decision cycle latency, tracking accuracy, compute overhead, and safety verification complexity. The baseline FBW system executed simple deterministic lookup loops in 10 milliseconds (100 Hz). The AI agent required 50 milliseconds (20 Hz) for full tactical state evaluation, but yielded far superior spatial decisions.

To reduce model inference time on embedded hardware, aerospace developers are turning to efficient state-space architectures. For example, edge models like LiquidAI's LFM3-1.7B achieve sub-50ms inference times while maintaining a compact memory footprint under 3.4 GB. These optimized models enable real-time tactical decision-making directly on combat aircraft embedded processing units.

The table reveals why pure neural systems have not replaced existing flight control hardware. While pure neural agents deliver fast OODA loop decision speeds, they lack deterministic safety guarantees. Saab's hybrid model balances both approaches by wrapping the probabilistic agent inside a deterministic software guardrail.

Architecture Breakdown: How Saab Separates Flight Dynamics from Tactical Decisions

The core architectural breakthrough in Saab's platform is dual-kernel isolation. Aerospace regulators require compliance with FAA DO-178C Level A standards for life-critical flight systems. Certifying a non-deterministic machine learning model under DO-178C Level A remains mathematically impossible today because neural networks generate outputs probabilistically.

Saab engineers bypassed this obstacle using a two-tier runtime isolation pattern. The lower tier consists of a certified, deterministic Flight Control Computer (FCC) running on a secure real-time operating system (RTOS) like VxWorks 653. This primary kernel handles sensor polling, surface actuator commands, and flight envelope limit enforcement.

The upper tier consists of an uncertified Mission Management Computer (MMC) running the AI fighter agent inside an isolated hardware container. The AI agent processes radar, thermal imaging, and tactical data to formulate high-level maneuvering commands. These commands pass through a deterministic validation filter before reaching the primary flight controls.

If the AI agent suggests an angle-of-attack command that risks aerodynamic stalling, the deterministic validation filter overrides the agent command instantly. This architecture allows aerospace developers to deploy cutting-edge neural models without risking aircraft structural integrity or safety certification.

Step-by-Step Tutorial: Simulating a Real-Time Hybrid Flight Control Loop

You can implement Saab's hybrid architecture pattern in your own autonomous engineering projects. This tutorial walks through building a dual-kernel simulation in Python and C++ that combines a high-speed deterministic control loop with a low-speed neural agent decision system.

Step 1: Define the Deterministic Safety Guardrail

First, create the safety filter that inspects agent commands against physical flight boundaries. This component enforces maximum safe g-force limits and angle-of-attack constraints regardless of what the AI model requests.

// SafetyFilter.cpp - Deterministic Aerospace Guardrail
#include <iostream>
#include <algorithm>

struct FlightState {
    double velocity;      // meters per second
    double angleOfAttack; // degrees
    double gForce;        // current Gs
}; For more details, see Master 2026 Tech: Build Your Own AI Agen. For more details, see MDN Web Docs. For more details, see Meta AI. For more details, see Google AI. For more details, see DeepMind.

struct CommandInput {
    double requestedPitch; // degrees
    double requestedThrust;// percentage
};

class SafetyFilter {
private:
    const double MAX_AOA = 25.0;     // Maximum safe angle of attack
    const double MAX_G_FORCE = 9.0;  // Maximum structural g-force limit

public:
    CommandInput validateCommand(const FlightState& state, const CommandInput& agentCmd) {
        CommandInput safeCmd = agentCmd;

// Enforce Angle of Attack safety envelope
        if (state.angleOfAttack > MAX_AOA) {
            safeCmd.requestedPitch = std::min(agentCmd.requestedPitch, 0.0);
            std::cout << "[GUARDRAIL TRIGGERED] Override: Excessive AOA Detected!" << std::endl;
        }

// Enforce Structural G-Force safety limit
        if (state.gForce > MAX_G_FORCE) {
            safeCmd.requestedPitch = std::min(agentCmd.requestedPitch, -2.0);
            std::cout << "[GUARDRAIL TRIGGERED] Override: G-Limit Exceeded!" << std::endl;
        }

return safeCmd;
    }
};

This simple C++ module guarantees that unsafe commands generated by an AI model are clamped immediately before reaching motor or wing surface actuators. In mission-critical deployments, this code is formally verified using static analysis tools.

Step 2: Build the High-Speed Control Loop Thread

Next, configure a dedicated high-frequency thread running at 100 Hz. This thread reads aircraft sensor values and applies deterministic surface movements every 10 milliseconds.

# high_speed_controller.py
import time
import threading

class FlightControlComputer(threading.Thread):
    def __init__(self, shared_state):
        super().__init__()
        self.shared_state = shared_state
        self.running = True
        self.loop_frequency = 0.010  # 10ms = 100 Hz

def run(self):
        print("[FCC] Starting 100 Hz Deterministic Flight Control Loop...")
        while self.running:
            start_time = time.time()
            
            # Read telemetry and apply actuator controls
            self.maintain_aerodynamic_stability()
            
            elapsed = time.time() - start_time
            sleep_time = max(0.0, self.loop_frequency - elapsed)
            time.sleep(sleep_time)

def maintain_aerodynamic_stability(self):
        # Deterministic PID controller logic runs here
        pass

The 100 Hz loop ensures continuous aerodynamic stability, preventing aerodynamic stalling even if the higher-level tactical agent experiences high processing latencies.

Step 3: Connect the Asynchronous AI Agent Decision Engine

Now, set up the tactical agent loop running at 20 Hz (50 milliseconds per cycle). This component evaluates tactical positions using an embedded inference library like ONNX Runtime or C++ bindings for neural networks.

# tactical_agent_engine.py
import time
import numpy as np

class TacticalAIAgent:
    def __init__(self, model_path="saab_agent_v4.onnx"):
        print(f"[AI AGENT] Loading embedded tactical model: {model_path}")
        # In production, initialize ONNX runtime or LiquidAI LFM inference engine
        self.model_loaded = True

def compute_tactical_maneuver(self, radar_tracks, self_state):
        # Simulate neural model evaluation across spatial vectors
        # Returns desired pitch, roll, yaw, and thrust adjustments
        simulated_pitch_cmd = 12.5  # Agent requests aggressive upward turn
        simulated_thrust = 0.95
        
        return {
            "requestedPitch": simulated_pitch_cmd,
            "requestedThrust": simulated_thrust
        }

The tactical engine processes complex multi-target environments without blocking the safety-critical 100 Hz flight loop. This asynchronous design prevents memory stalls or inference delays from freezing flight controls.

Step 4: Execute Integrated Dual-Kernel Simulation Loop

Finally, bind the deterministic guardrail and asynchronous agent together inside an integrated execution environment. This script runs the full simulation cycle.

# main_simulation.py
import time
from tactical_agent_engine import TacticalAIAgent

def run_hybrid_avionics_simulation():
    agent = TacticalAIAgent()
    
    # Mock aircraft state: high speed, near g-limit
    current_state = {
        "velocity": 340.0,     # m/s (Mach 1)
        "angleOfAttack": 26.2, # Exceeds 25.0 degree safety limit!
        "gForce": 8.1
    }
    
    print("\n--- INITIATING COMBAT TACTICAL INTERCEPT ---")
    
    # AI Agent evaluates battlefield and issues aggressive command
    agent_output = agent.compute_tactical_maneuver(radar_tracks=[], self_state=current_state)
    print(f"[AI OUTPUT] Agent Requests Pitch: {agent_output['requestedPitch']} degrees")
    
    # Validation Filter inspects command against safety limits
    if current_state["angleOfAttack"] > 25.0:
        print("[SAFETY INTERCEPT] Clamping pitch command to maintain wing airflow!")
        final_pitch = 0.0