CLARA: Composable Learned Assured Reasoning Architecture Demonstration Suite for DARPA TA1 Assured Reasoning


The Problem

AI systems deployed in safety-critical domains -- military targeting, autonomous vehicles, medical diagnostics, critical infrastructure -- need more than accuracy. They need formal assurance guarantees that certain behaviors will never occur, regardless of what the learned model predicts. A 99.9% accurate targeting system that occasionally authorizes strikes on protected sites is not an acceptable system. It is a liability.

Traditional machine learning provides statistical accuracy but offers no hard safety guarantees. A deep neural network can classify targets with high precision, but nothing in its architecture prevents it from producing catastrophically wrong outputs on adversarial or out-of-distribution inputs. Conversely, traditional rule-based systems provide formal safety properties -- if the rules are correct, the system is safe -- but they cannot learn from data, generalize to novel situations, or improve with experience.

The gap is architectural: how do you compose a learned ML model with a formal safety rule system such that the safety guarantees are provably preserved regardless of ML quality? This is not a matter of adding a filter after the fact. The composition must be structural, auditable, and domain-independent.

The CLARA Approach

CLARA solves this through constraint-objective separation. Safety constraints (Levels 1-4: Law of Armed Conflict, No-Strike Lists, Rules of Engagement, Collateral Damage Estimation) are encoded as immutable, write-protected rules in a directed acyclic graph (DAG). Mission objectives (Levels 5-6: tactical priorities, user preferences) are encoded as separate, mutable rules that can adapt to operational context. The architecture guarantees that no objective can override a constraint -- this is enforced structurally, not by convention.

The rule DAG uses namespace isolation to prevent interference between rule categories. Each namespace (e.g., loac, nsl, roe, cde) is independently verifiable, and the composition engine proves non-interference at every decision point. SHA-256 hash verification confirms that constraint rules remain invariant across all mission profiles and operational modes.

Critically, CLARA is ML-agnostic. Any classifier -- a convolutional neural network, logistic regression, or an ensemble -- composes through the same DAG with the same safety guarantees. A bad classifier does not produce unsafe decisions; it produces conservative decisions (more targets held for human review). The same rules engine that enforces constraints at inference time also produces the cost matrix used during ML training, closing the loop between assurance and learning.


Demonstration Suite

Assurance Dashboard

Quality gates, audit trails, and composition certificates for the full CLARA pipeline. The top-level view of what CLARA guarantees and how those guarantees are verified.

0 violations Quality gates
Proves: end-to-end audit trail from ML input to verified decision

Kill Web -- Doctrine (Flagship)

Full-scale engagement pipeline with 94 rules across 13 namespaces, 5 mission profiles, 3 ML classifiers, and formal proof certificates for all 1,179 targets. The most comprehensive demonstration of constraint-objective separation.

94 rules / 13 namespaces 0 violations 98.8% composite acc 1,179 targets
Proves: ML-agnostic safety, constraint-objective separation, AR-governed training

Kill Web -- OODA (Closed-Loop)

Closed-loop engagement with AR-governed OODA decision cycles. BDA feedback drives re-observation and re-engagement. AR rules control loop termination -- when to stop is itself a verified logic program.

109 rules / 16 namespaces 0 violations across all cycles Avg 1.6 cycles, 29% ESTV reduction
Proves: AR governs decision cycles (not just decisions), BDA-driven re-engagement, loop termination verification

Kill Web -- Static

Baseline engagement authorization with 25 rules across 4 namespaces. Demonstrates that even simple rule composition eliminates all ML-caused safety violations while preserving classification accuracy.

25 rules / 4 namespaces 78 → 0 violations 8 comparison systems
Proves: basic rule composition eliminates violations CNN-only cannot prevent

Kill Web -- Dynamic

Multi-target engagement with weapon-target assignment, cross-target resource coupling, and threat imminence modeling. Extends rule composition to dynamic operational scenarios.

Dynamic assignment Resource coupling
Proves: composition handles dynamic multi-target scenarios with resource constraints

Fleet Dispatch (SCFDP)

Scalable constraint satisfaction for vehicle routing using CVRPLIB benchmark instances. Demonstrates that the same composition architecture works in logistics -- capacity, routing, and time window constraints with non-interference proofs.

Constraint satisfaction Non-interference proofs CVRPLIB instances
Proves: CLARA is domain-independent -- same engine, different domain

Key Results

Capability Demonstrated Evidence
Zero violations across all ML models YES CNN, LR, and Composite classifiers all produce 0 constraint violations across 40 scenarios
Constraint-objective separation YES SHA-256 constraint hash a326fadc... identical across 5 mission profiles
ML-agnostic composition YES 3 classifiers (78-99% accuracy) compose through same DAG with same safety guarantees
AR-governed training YES 25% doctrine error reduction (3.2 to 2.4) using AR-derived cost matrix
Triage priority reordering YES Kendall's tau -0.0962 between opposing mission profiles; 20-26% of ENGAGE targets reordered
Formal proof certificates YES 1,179 verified proof certificates per classifier, per scenario run
Domain independence YES Same composition engine used for military kill web AND civilian fleet dispatch
Scalable rule architecture YES 94 rules, 13 namespaces, 40-D features, pipeline runtime <3s per scenario

For reviewers: Each demo page includes a "Try it" link to the live interactive demo and a documentation link with detailed methodology, results, and the specific DARPA TA1 concerns each capability addresses. Start with the Kill Web Doctrine deep dive for the most comprehensive treatment.