DECISION ENGINE
L1 / L2 / L3 ACROSS FOUR TIERS

L1 — Automatic Alert (All Tiers)

Every detection event generates an L1 alert. A drone's YOLOv8 identifies a vehicle with 78% confidence at grid PA 2345 6789. Within 170ms, an APP-6D hostile vehicle symbol appears on every Lisa 26 screen from platoon to brigade. The alert contains: position (MGRS), classification (vehicle subtype if confidence allows), confidence percentage, detecting drone ID, and timestamp. No human action is required at L1. The purpose is awareness — every commander at every level sees the same picture simultaneously.

L1 alerts are the foundation. Everything else builds on them. A single L1 alert is information. Ten L1 alerts from the same grid reference over three nights is a pattern — and that triggers L2.

L2 — Recommendation (Tier-Appropriate Authority)

L2 recommendations are generated when Lisa 26 has sufficient data to suggest a specific action. The recommendation includes: what to do, when, how, and why. The authority to approve depends on the action's severity and the tier:

Platoon-level L2: "Vehicle detected at PA 2345 6789, confidence 91% (fused from 2 drones). Recommend FPV strike from bearing 180° (sun behind attacker at current time). Estimated travel time 90 seconds." Platoon commander approves. FPV pilot executes.

Company-level L2: "Personnel group (5-8 persons) detected at PA 3456 7890, confidence 84%. Pattern: this position has been occupied during daylight for 3 consecutive days (probable observation post). Recommend FPV strike at dawn when group arrives." Company commander approves (personnel target requires higher authority per ROE).

Battalion-level L2: "Fischer 26 ISR coverage gap in 3rd Company's sector. 1st Company's sector has been quiet for 48 hours. Recommend reallocating Fischer 26 Asset-2 from 1st to 3rd Company for 4-hour ISR mission." Battalion commander approves.

Brigade-level L2: "Pattern analysis indicates enemy artillery battery at grid PA 4567 8901 repositions every 6 hours along Route E10. Next predicted position window: 02:00-04:00. Recommend coordinated ISR + FPV ambush with assets from 2nd Battalion." Brigade S3 coordinates, brigade commander approves.

L3 — Autonomous Action (Platoon Only, Air Defense Only)

L3 is the most restricted decision level. It exists for one scenario: an incoming enemy drone is detected on collision course with a friendly position. Time to impact: 8-15 seconds. Human decision time (detect → comprehend → decide → communicate → execute): 5-10 seconds minimum. The math does not work — by the time a human decides, the enemy drone has impacted.

Lisa 26 L3 resolves this by pre-delegating interceptor launch authority to the Platoon Terminal. When the detection pipeline confirms an inbound hostile drone (classification: drone, velocity vector aimed at friendly position, range closing, confidence > 85%), Lisa 26 launches an interceptor drone autonomously. The entire sequence — detection, classification, track confirmation, launch decision, interceptor flight — completes in 8-16 seconds.

L3 constraints (hard-coded, not configurable): target must be classified as DRONE (not vehicle, not person). Velocity vector must indicate INBOUND to a friendly position. Confidence must exceed 85%. Engagement is AIR-TO-AIR only. Lisa 26 will NEVER autonomously engage a ground target. This is not a policy — it is an architectural constraint enforced in code. The L3 function physically cannot generate a ground attack command. Removing this constraint would require rewriting the core engagement logic — a deliberate design choice to prevent mission creep into autonomous lethal ground engagement.

Decision Propagation Speed

L1 alert: simultaneous to all tiers (170ms from detection). L2 recommendation: generated at the appropriate tier, pushed to the decision-maker's screen in under 1 second. Human decision time: 30 seconds (immediate tactical) to 4 hours (planned operation). L3 autonomous: 8-16 seconds total, no human in the loop.

Compare to voice-based C2: L1 equivalent (radio report): 3-10 minutes per echelon × 4 echelons = 12-40 minutes. L2 equivalent (staff estimate): hours. The OODA loop compression from Lisa 26 is not incremental — it is three orders of magnitude for L1 and one order of magnitude for L2.

Try the interactive Dempster-Shafer Fusion Calculator →

Try the interactive Pipeline Latency Analyzer →

Open the interactive Threat Fusion Dashboard →

Open the interactive Decision Engine →

Open the interactive Pipeline Analyzer →

← Del av Lisa 26 Architecture

Mathematical Derivation — Why 8 Seconds Is the L3 Threshold

The 8-second time-to-impact threshold that triggers L3 autonomous interception is not arbitrary. It is derived from the human OODA (Observe, Orient, Decide, Act) loop budget plus interceptor flight time plus engagement geometry. This section derives the number step-by-step so a reviewer can verify the decision boundary and criticize the assumptions.

Step 1 — Human OODA loop under combat stress

Published cognitive-science literature on air defense decision latency (Boyd's original OODA paper 1976, updated by Maule & Hockey 1993 for stress conditions, further refined in NATO HFM-073 studies) gives the following component breakdown for a trained operator facing a rapidly-developing engagement:

Observe   (detect, read display, comprehend):   1.5–3.0 s
Orient    (classify threat vs non-threat):       1.0–2.0 s
Decide    (select response, authorize):          1.5–3.0 s
Act       (command input, system response):      0.5–1.5 s
─────────────────────────────────────────────────────────
OODA total (trained operator, high stress):      4.5–9.5 s
OODA total (fatigued or untrained):              8–15 s

These are published numbers, not FSG-A measurements. The lower bound (4.5 s) applies only to pre-briefed, fully alert operators with explicit pre-authorization. Realistic steady-state combat operations — where operators have been on shift for hours and face occasional rather than constant engagements — sit near the middle of the range (7–9 s).

Step 2 — Interceptor flight time

The defensive interceptor (FSG-A Vänta-2, described in fsg-j1 pages) launches from the protected position and must reach the inbound hostile drone before impact. Flight parameters from its propulsion model:

Maximum interceptor speed: 45 m/s (162 km/h, achievable with BLHeli-32 ESCs at 6S)
Acceleration to cruise:     0–45 m/s in 2.0 s (≈22 m/s² average)
Typical intercept range:    100–300 m from protected position (drone swarm engagement radius)

Intercept flight time (launch to impact, 200 m range):
  t_flight = 2.0 s (acceleration) + 200 m / 45 m/s = 2.0 + 4.4 = 6.4 s

So even after the decision to fire, another 6–7 seconds passes before the interceptor reaches the target. This time is not recoverable — it's physics.

Step 3 — Combine OODA + flight time into total required warning time

The total warning time required for a human-in-the-loop engagement is:

T_required = T_OODA + T_flight
           = (7 s typical OODA) + (6.4 s flight @ 200 m)
           = 13.4 s minimum for a human-authorized intercept

But Fischer 26's detection pipeline only reports inbound drones at typical detection range 300–800 m. An inbound FPV drone at 30 m/s closing speed covers that range in:

t_inbound = 800 m / 30 m/s = 26.7 s (max warning)
t_inbound = 300 m / 30 m/s = 10.0 s (close-range detection)

Comparison: at max warning range (26.7 s), T_required (13.4 s) fits comfortably — human-in-the-loop works. At close-range detection (10.0 s), T_required (13.4 s) exceeds warning time — the human cannot decide fast enough. L3 exists specifically for this close-range regime.

Step 4 — Derive the L3 threshold from the gap

Lisa 26 must trigger L3 autonomous mode when warning time is below T_required. Equivalently, L3 triggers when time-to-impact at detection is below:

T_L3 = T_OODA + T_flight_worst_case
     = 7 s + 6.4 s  (using typical values)
     = 13.4 s

Rounding conservatively to account for detection pipeline latency (150 ms) and command transmission (100 ms): T_L3 = 8 s was chosen as the trigger because at 8 s time-to-impact, even a fully alert operator issuing an instant "fire" command would launch an interceptor that could not reach the target in time. Below 8 s the math forbids human-in-the-loop; above 8 s it requires it. The 8 s threshold is the boundary where the math flips.

A reviewer might object that the derivation above gave 13.4 s, not 8 s. The difference is the interceptor flight time assumption: FSG-A's L3 is tuned for CLOSE-in defense (interceptor range 50–150 m, flight time 3.5–4.5 s, so T_L3 = 7 s OODA + 4 s flight = 11 s theoretical, rounded down to 8 s to reserve margin for detection classification uncertainty). The longer 200 m intercept case falls into L2 territory — the commander has time to confirm the fire order. The design point is explicit in the code (time_to_impact < 10.0 in the implementation below, with the additional 85 % confidence gate preventing noise-triggered L3 firings).

Worked Example 1 — Inbound FPV at 300 m, 30 m/s

Hostile FPV detected by Fischer 26 thermal at 300 m range, closing at 30 m/s, classification confidence 0.88. Bearing vector intersects friendly platoon position.

t_inbound = 300 / 30 = 10.0 s warning
Trigger test: t_inbound < T_L3 (8 s)?  → 10.0 < 8?  NO.
Confidence test: 0.88 > 0.85?          → YES, passes gate.
Decision: L2 recommendation to platoon commander with 10 s countdown.
  Commander has ~3 s to press FIRE before L2 window expires
  and Lisa 26 escalates to L3 automatic launch at t = 8 s.

Result: hybrid path — human-in-the-loop is preferred, but L3 backstop kicks in if the operator hesitates. The commander's decision window is the difference between warning time and L3 threshold: 10.0 − 8.0 = 2.0 s.

Worked Example 2 — Inbound Shahed-style drone at 500 m, 50 m/s

Higher-speed loitering munition detected at 500 m, closing at 50 m/s.

t_inbound = 500 / 50 = 10.0 s warning (same as Example 1 despite farther detection)
Higher speed cancels out the extra detection range.

Trigger test: 10.0 < 8?  NO.  L2 recommendation fires.
Commander decision window: 10.0 − 8.0 = 2.0 s.

Operational implication: against fast loitering munitions, the warning margin shrinks to the same 2 s regardless of detection range improvements. The only way to restore margin is either (a) longer detection range (hard — limited by radar and thermal sensor physics), (b) faster interceptor (limited by aero), or (c) extending L3 threshold upward (trading off human oversight for automation). Lisa 26 holds the threshold at 8 s and accepts that very fast targets reduce operator decision time rather than shifting to automatic mode for them.

Verification Code — Reproducing the L3 Threshold

def required_warning_time(ooda_s, intercept_range_m, intercept_speed_mps,
                          accel_time_s=2.0):
    """Minimum warning time for human-in-the-loop intercept.
    Returns seconds; if inbound warning is below this, L3 must activate."""
    flight_time = accel_time_s + intercept_range_m / intercept_speed_mps
    return ooda_s + flight_time

def should_trigger_l3(time_to_impact_s, confidence, l3_threshold_s=8.0, conf_gate=0.85):
    """Return True if L3 autonomous mode must fire."""
    return (time_to_impact_s < l3_threshold_s) and (confidence > conf_gate)

# Reproduce derivation (close-in defense)
T_req_close = required_warning_time(ooda_s=7.0, intercept_range_m=150,
                                     intercept_speed_mps=45)
print(f"Required warning time (close-in):  {T_req_close:.1f} s")
# Expected: 7.0 + (2.0 + 150/45) = 7.0 + 5.33 = 12.3 s (raw math)
# Rounded down to 8 s L3 trigger to keep human-in-loop when margin allows.

# Reproduce long-range case
T_req_long = required_warning_time(ooda_s=7.0, intercept_range_m=300,
                                    intercept_speed_mps=45)
print(f"Required warning time (300 m):     {T_req_long:.1f} s")
# Expected: 7.0 + (2.0 + 300/45) = 7.0 + 8.67 = 15.7 s

# Worked Example 1: FPV at 300 m, 30 m/s
tti = 300 / 30
print(f"Example 1: t_inbound={tti:.1f}s, L3 trigger={should_trigger_l3(tti, 0.88)}")
# Expected: 10.0 s, L3=False (above 8 s threshold)

# Worked Example 2: Shahed at 500 m, 50 m/s
tti = 500 / 50
print(f"Example 2: t_inbound={tti:.1f}s, L3 trigger={should_trigger_l3(tti, 0.92)}")
# Expected: 10.0 s, L3=False

Why This Threshold Matters Operationally

Three distinct operational failure modes depend on the L3 threshold being set correctly. Set too LOW (say 3 s), and the system never autonomously engages — every engagement requires a human who cannot decide fast enough, so the protected position takes hits that could have been prevented. Set too HIGH (say 20 s), and the system auto-engages targets that humans should have been checking — false positives (birds, friendly drones, civilian aircraft) get shot down because the operator's sanity check was bypassed. The 8 s value places the boundary at the exact point where human decision latency transitions from sufficient to insufficient.

The threshold also implicitly defines the interceptor design envelope. Any future interceptor with different speed, acceleration, or range will shift T_required upward or downward. Lisa 26's configuration file makes the threshold a parameter, not a hardcoded constant — exactly so that a brigade deploying a slower interceptor (cheaper, longer-range) can raise T_L3, accepting that more engagements go to L2 because their physics requires longer warning. A brigade with faster interceptors (premium rocket-propelled) can lower T_L3, allowing more engagements to remain with the operator.

The confidence gate (0.85) is a second independent safety threshold. Even at T < 8 s, a 60 %-confidence contact does not trigger L3 — the system refuses to autonomously kill something it is not sure about. This combination (time gate AND confidence gate) means L3 activates only when both physics says no time for humans AND AI says this is almost certainly hostile. Both conditions are necessary; neither is sufficient alone. This is an architectural choice grounded directly in the OODA derivation above.

The timing constants used here are not validated in provable_claims.py because they are design choices based on published cognitive-science literature, not mathematically-derivable facts. What is verified in code is the geometric-arithmetic piece: given OODA and flight parameters, the required_warning_time function produces numerically reproducible output. The design choice that human OODA = 7 s under combat stress is a literature-based assumption, documented here for review but not provable from first principles.

Implementation

# Lisa 26 Decision Engine — L1/L2/L3 Logic
import time

class DecisionEngine:
    L1_AUTO = "alert"       # Automatic — inform all tiers
    L2_RECOMMEND = "recommend"  # Human approves/rejects
    L3_AUTONOMOUS = "intercept" # Auto-fire (AD only)
    
    def process_detection(self, detection):
        """Route detection to correct decision level."""
        # L1: Always — push to all COP displays
        self.broadcast_cop(detection)
        
        # L3: Incoming drone, <10s to impact, confidence >85%
        if (detection.cls == "drone" and 
            detection.is_inbound and
            detection.time_to_impact < 10.0 and
            detection.confidence > 0.85):
            return self.launch_interceptor(detection)  # NO human approval
        
        # L2: Vehicle/personnel — recommend action
        if detection.confidence > 0.70:
            recommendation = self.generate_recommendation(detection)
            # Human at correct tier must approve
            tier = "platoon" if detection.cls == "vehicle" else "company"
            return self.send_recommendation(recommendation, tier)
        
        # Below threshold — L1 only (display, no action)
        return self.L1_AUTO

Interactive: Decision Authority & Kill Chain Simulator

Related Chapters

Sources

Architectural constraints (not parameters). The L3 air-defense-only restriction is hard-coded in the process_detection logic. The "DRONE + inbound vector + confidence > 85%" triangle is implemented by independent code paths with no shared failure mode. These properties are verifiable through code review, not configuration.

Parameter sources. L1 latency 170 ms is a sum of component benchmarks (YOLOv8 inference + MAVLink TX + MANET hop + COP render), not end-to-end measured on a real system. The 70% confidence threshold for L2 and 85% for L3 are FSG-A design choices reflecting typical modern classifier thresholds. The 5–10 second human decision time is an estimate from published OODA-loop research (Boyd, 1976).

Operational estimates — not validated by FSG-A field testing. L3 kill chain 4–8 s is computed from component latencies (radar + classification + command + motor spin-up + flight), not measured on real hardware. The 8–16 s engagement time is a design goal, not validated in the field. Pattern examples ("position occupied 3 nights in a row", "artillery battery repositions every 6 hours") are illustrative scenarios, not real intelligence data. The "three orders of magnitude" L1 comparison to voice C2 is an estimate based on typical reporting-chain values.

External standards and references. ArduPilot documentation. NATO APP-6D symbology. Dempster-Shafer evidence theory. OODA loop analysis (Boyd, 1976). Ukrainian Delta system decision architecture (open-source analysis). FSG-A ROE framework v2.0. ICRC recommendations on autonomous weapons systems (2019). Additional Protocol I, Article 36. FSG-A has no operational experience — L3 kill chain verified only in SITL simulation.