Lagrange Integrates DeepProve into the Anduril Lattice SDK Environment

Modern defense systems cannot rely on autonomy alone, nor can they afford verification processes that compromise speed. The next generation of defense software will require both: autonomy with rapid verification. Lagrange has been testing this hypothesis by integrating DeepProve into the Anduril Lattice SDK™ to demonstrate verifiable AI decision-making in an autonomous reconnaissance environment. (Anduril Lattice™ and Lattice SDK™ are properties of Anduril™.) View the full demo of the integration on Github and YouTube.

By extending Anduril’s open-source auto-recon example, we integrated trained machine learning models with DeepProve, enabling live, zero-knowledge verified AI decisions inside a simulated defense environment. The result is a working demonstration of how autonomous reconnaissance pipelines can synchronize operational tasking with cryptographic assurance, delivering rapid, model-driven reasoning that remains transparent, reproducible, and privacy-preserving.

System Overview

In this prototype, as live assets and tracked entities stream into the Lattice SDK environment, the application executes a three-stage decision process using verifiable ML inference:

1. Proximity Detection:
   
   • A lightweight ONNX model determines whether a nearby track (friendly, hostile, or suspicious) falls within a range requiring further analysis.
2. Tactical Decision:
   
   • A tactical decision network classifies the proper response: EVADE, INTERCEPT, or SURVEILLANCE.
3. Movement Calculation:
   
   • A movement_calculation model translates the decision into actionable vectors (bearing, distance, urgency), while a surveillance_position model computes persistent observation points when applicable.

Each inference layer is wrapped with DeepProve, which generates a zero-knowledge proof alongside the model’s output. The proof confirms that the model executed correctly on authorized data without revealing the model’s internal parameters or the sensitive inputs that produced the result.

Verifiable Inference in Action

DeepProve operates within the Lattice SDK pipeline, emitting proofs in real time as each model processes incoming tracks. This ensures that every autonomous action—from proximity classification to movement decision—can be independently verified by external systems, operators, or oversight processes.

The demo validates this flow against six canonical reconnaissance scenarios, configured to test all proximity categories and entity types:

1. EVADE as too close to Hostile track
2. SURVEILLANCE as medium distance from Hostile track
3. INTERCEPT as far from Hostile track
4. EVADE as too close to Suspicious track
5. SURVEILLANCE as medium distance from Suspicious track
6. INTERCEPT for investigation as far from Suspicious track

Across these configurations, the system demonstrates how verifiable inference enables predictable tactical behavior under uncertainty: every inference logged, every proof linked, and every decision traceable.

Technical Implementation

• Environment: Anduril Lattice SDK™ (auto-recon example extended)
• Model Stack:
  
  • within_range.onnx — proximity detection
  • tactical_decision.onnx — EVADE / INTERCEPT / SURVEILLANCE classification
  • movement_calculation.onnx — bearing and distance vector generation
  • surveillance_position.onnx — observation point refinement
• Proof Layer: DeepProve integrated at model inference boundary, generating zk-proofs per decision output
• Data Flow: Assets → Tracks → Inference → Proof → Action → Record

This architecture provides a full chain of verifiable inferences, from perception through decision and movement, without exposing proprietary model weights or input telemetry.

Why It Matters

Autonomous systems are moving toward higher levels of operational independence. But as autonomy increases, assurance becomes mission-critical. By embedding cryptographic proofs directly into AI inference, this demonstration shows that autonomy and accountability can coexist: operators gain faster responses and stronger confidence that each decision follows authorized logic, executed on authentic data.

The Lattice SDK environment provided an ideal sandbox to illustrate how verifiable reasoning can integrate with tactical AI workflows, paving the path toward transparent autonomy that strengthens both performance and trust.

‍