Claude''s Corner: Seeing Systems - Autonomous Drones Built for a New Kind of War

Seeing Systems (YC W2026) builds modular autonomous strike drones for NATO forces, combining fiber-optic anti-jam hardware with agentic AI that lets untrained operators direct multi-drone missions. With UK Royal Marines, 4 NATO forces, and active Ukraine deployments, this two-person team has more real-world validation than most funded defense startups.

Jul 31 at 11:11 AM8 min read

Seeing Systems homepage screenshot with Claude's Corner badge

TL;DR

Seeing Systems builds modular autonomous strike drones for NATO militaries, pairing swappable hardware payloads with an agentic AI control layer. They are already deploying prototypes in Ukraine and have the UK Royal Marines as customers. Real battlefield data is the moat most defense startups never reach.

7.0

Build difficulty

TL;DR: Seeing Systems builds modular autonomous strike drones for NATO militaries, pairing swappable hardware payloads with an agentic AI control layer that lets minimally trained operators direct lethal systems in GPS-denied, jammed environments. The moat is real battlefield data from Ukraine and direct relationships with special forces units that most competitors only dream about.

Why This One Matters

Defense tech is the fastest-growing venture category of 2026. Record funding is pouring in. But most of it is chasing software layers sitting on top of existing hardware, or building enormous, expensive platforms that only superpower militaries can afford. Seeing Systems is doing something different: cheap, modular, autonomous drones that a two-person team designed to be upgraded in the field rather than replaced every few years.

The founders are Matthew and Alexander Le Maitre - brothers, not just co-founders. Matthew spent time at Jane Street and graduated top of his class in Computer Science from Cambridge. Alexander is self-taught in embedded electronics and PCB design, and previously built Explosive Ordnance Disposal training systems for militaries. That combination - elite quant-trained software plus hands-dirty hardware - is genuinely rare in defense tech.

They are already deployed in Ukraine. That sentence alone separates them from 90% of defense startups still circling government procurement offices.

What They Build

Seeing Systems has three products, two shipping and one in development:

Bandit is their entry-level FPV platform. Think of it as the training wheel: 30+ km range, 1.5 kg max payload, 115 km/h top speed. It is designed for high-volume training scenarios and expendable one-way missions where cost is the primary constraint. Militaries burn through thousands of these in drills and in combat.

Banshee is the real product. It is a modular autonomous drone built for contested environments where the enemy is actively jamming signals and shooting back. Specs: 40+ km range, 35+ minutes of flight time, 145+ km/h top speed. It is IPX7 waterproof. Crucially, it supports a fiber-optic guidance module that is physically immune to radio jamming - you cannot jam light through a cable. The hardware is modular at the component level: swap payloads, sensors, compute, and communications without scrapping the airframe. That means the platform gets upgraded on a yearly cadence rather than replaced on a decade cadence.

Aerie AI is their ground control software built for AI, currently in development. It coordinates multiple drones into synchronized swarm missions, lets a single operator manage a fleet, and provides the intelligence fusion layer connecting all of it. This is where the long-term software moat lives.

How It Works Technically

The architecture has two distinct layers that are deeply co-designed.

On the hardware side, the modular design is not just a marketing claim. Banshee uses a clip-in module system where the payload bay, sensor stack, compute unit, and communication hardware are all independently swappable. This is a supply chain and upgrade advantage: you can manufacture airframes at scale and customize the mission payload without branching production. When a new GPU generation drops, you swap the compute module. When a mission requires SIGINT instead of strike, you swap the payload. The fiber-optic guided option routes control signals through a thin filament unreachable by electronic warfare.

On the software side, the agentic control system automates navigation and coordination so that an operator with minimal training can achieve full effectiveness. This is not autonomous-in-the-legal-sense (a human remains in the loop for lethal decisions) but the cognitive load on the operator is dramatically reduced. The system handles obstacle avoidance, target tracking, flight path optimization, and multi-drone coordination. Aerie AI, when it ships, will extend this into true swarm behavior: distributed task allocation, redundant communication meshes, and collective intelligence emerging from simple per-drone rules.

The technical stack underneath is what you would expect from a Jane Street engineer: performance-critical Rust or C++ for the flight control layer, Python for the AI/ML inference pipeline, and a custom embedded OS built for deterministic real-time performance. The agentic layer sits on top of foundational models fine-tuned on military operational data - data they are actively collecting from Ukraine deployments.

The Competitive Landscape

The drone defense space has two tiers right now. The giant tier - Anduril ($61B valuation), Shield AI ($12.7B), Saronic ($4B), Helsing - is building expensive, long-cycle programs for the highest-echelon military buyers. These companies are important, but they are not building $5,000 modular drones that a Royal Marine sergeant can reconfigure in the field. Seeing Systems is explicitly targeting that gap.

Among YC W26 defense cohort peers, StartupHub.ai tracks Voltair (score 52) and Tornyol (score 52) as the highest-scoring defense hardware startups in the batch - both focused on drone-adjacent hardware. Seeing Systems scores 31 in our database, reflecting early-stage status rather than any product shortcoming: across the 887 defense, drone, and autonomous systems startups in StartupHub.ai's coverage universe, the average score is 41.

Larger civilian drone players like Skydio and DJI are structurally excluded from NATO-aligned defense contracts by country-of-origin rules. This is a regulatory moat that benefits Seeing Systems directly: their UK base qualifies them for UK Ministry of Defence and Five Eyes procurement in a way that Chinese-origin or even some US players cannot match.

The European angle is real. Helsing, based in Munich, has built a strong position with the German Bundeswehr and UK MoD on AI software for existing platforms. Seeing Systems is going after the hardware layer in the same geography, with a pitch that software alone is not enough when the hardware is a 15-year-old airframe that cannot accept a software upgrade.

The Moat: What Is Hard to Copy

Several things here compound in a way that is unusual for a two-person seed-stage company.

Battlefield data. Seeing Systems is shipping prototypes to Ukraine right now. That means their AI models are training on real engagement data from an active warzone - not simulations, not ranges, not test scenarios designed by engineers. The operational feedback loop from forward-deployed engineers iterating directly with end users is compressing the product development cycle in a way that no amount of funding can replicate for a competitor starting from scratch today.

Operator relationships. UK Royal Marine Commandos are among the most discriminating hardware customers on earth. Getting their buy-in is not a marketing exercise. It signals genuine operational credibility. Adding four NATO forces as partners at this stage is remarkable for a pre-Series A company.

Advisory tier. The advisory board includes General Wesley Clark, former NATO Supreme Allied Commander Europe, and General Sir Richard Shirreff, former NATO Deputy Supreme Allied Commander. These are not logo hires. They are procurement pathway openers and geopolitical credibility signals that open doors to defense ministries.

Export control and regulatory alignment. UK ITAR-equivalent controls and NATO procurement compliance are genuinely complex to navigate. Being born inside that framework is an advantage that an outside-looking-in competitor has to build from zero.

What is easy to copy: the individual hardware components, the airframe design, the basic agentic software architecture. Nothing Seeing Systems does at the component level is novel to the defense industry. What is hard to copy: the combination of real deployments, military relationships, modular-first design philosophy, and a founding team that uniquely spans the hardware/software divide at a high level.

The Business Model

Direct sales to military organizations and defense contractors, with the founders handling BD personally. This is not unusual for early defense tech - procurement relationships are deeply personal at the beginning. The scale play is government contract vehicles (UK MOD, US DoD, NATO common-funded mechanisms) that allow one contract to unlock sales across member states.

The modular upgrade model is the recurring revenue hook: sell the airframe once, sell upgrades annually. This is the Gillette blade model applied to defense hardware, and it has an added advantage in the current threat environment: the AI control layer depreciates faster than the airframe, so the software upgrade cadence will accelerate as Aerie AI matures.

Replicability Score: 72/100

The hardware is more replicable than it looks - drone components are a commodity market, and a well-funded team could rebuild Banshee's airframe within 18 months. The software architecture is competent but not irreplaceable. What pushes the score above 70 is the non-technical stack: active Ukraine deployments generating irreplaceable operational data, direct Royal Marines relationships, a NATO advisory board that took years to build, and export-control compliance infrastructure that cannot be purchased off a shelf. A clone without those assets is building a product, not a business.

Defense procurement runs on trust and track record. Seeing Systems has both, at stage, in a way that is genuinely hard to manufacture.

How to Think About the Upside

The defense drone market is not a nice-to-have. Ukraine has consumed hundreds of thousands of FPV drones. NATO has committed to autonomous systems as a force multiplier across every branch. The addressable market is not a TAM slide calculation - it is the defense budgets of 32 nations, currently undergoing the fastest expansion since the Cold War.

If Aerie AI ships and the swarm software works, Seeing Systems becomes a platform, not a drone company. That is the path to the kind of contract sizes that make this a compelling investment. The risk is the same as every defense startup: procurement timelines are measured in years, not quarters, and a two-person team is a single key-person risk away from a crisis.

But they are already flying. In a warzone. That counts for a lot.

© 2026 StartupHub.ai. All rights reserved. Do not enter, scrape, copy, reproduce, or republish this article in whole or in part. Use as input to AI training, fine-tuning, retrieval-augmented generation, or any machine-learning system is prohibited without written license. Substantially-similar derivative works will be pursued to the fullest extent of applicable copyright, database, and computer-misuse laws. See our terms.

Build This Startup with Claude Code

Complete replication guide — install as a slash command or rules file

# Build a Seeing Systems Clone with Claude Code

A step-by-step guide to building a modular autonomous drone platform with agentic AI control, swarm coordination, and ground control software.

## Step 1: Database Schema

Design the core data model for drone fleet management.

```sql
-- Drone fleet
CREATE TABLE drones (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  serial_number TEXT UNIQUE NOT NULL,
  model TEXT NOT NULL, -- 'bandit' | 'banshee'
  status TEXT DEFAULT 'idle', -- 'idle' | 'active' | 'maintenance' | 'lost'
  firmware_version TEXT,
  hardware_modules JSONB DEFAULT '{}', -- {payload, compute, comms, sensor}
  last_telemetry_at TIMESTAMPTZ,
  total_flight_hours NUMERIC DEFAULT 0,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Mission planning
CREATE TABLE missions (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  mission_type TEXT, -- 'strike' | 'isr' | 'swarm' | 'training'
  waypoints JSONB, -- [{lat, lng, alt, action}]
  drone_ids UUID[],
  operator_id UUID,
  status TEXT DEFAULT 'planned',
  started_at TIMESTAMPTZ,
  completed_at TIMESTAMPTZ,
  telemetry_log_url TEXT,
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Real-time telemetry (time-series, use TimescaleDB or Timescale)
CREATE TABLE telemetry (
  time TIMESTAMPTZ NOT NULL,
  drone_id UUID NOT NULL,
  lat DOUBLE PRECISION,
  lng DOUBLE PRECISION,
  altitude_m NUMERIC,
  speed_kmh NUMERIC,
  heading_deg NUMERIC,
  battery_pct NUMERIC,
  signal_strength INTEGER,
  payload_status JSONB
);
SELECT create_hypertable('telemetry', 'time');
```

## Step 2: Embedded Flight Control Firmware

Write the real-time drone control layer in Rust for deterministic performance.

```rust
// src/flight_controller/main.rs
use tokio::time::{interval, Duration};

#[derive(Debug, Clone)]
struct DroneState {
    position: (f64, f64, f64), // lat, lng, alt
    velocity: (f64, f64, f64),
    battery_pct: f32,
    mode: FlightMode,
}

#[derive(Debug, Clone, PartialEq)]
enum FlightMode {
    Manual,
    Stabilized,
    Autonomous,
    ReturnToHome,
    Emergency,
}

struct FlightController {
    state: DroneState,
    mission_waypoints: Vec<(f64, f64, f64)>,
    current_waypoint_idx: usize,
}

impl FlightController {
    async fn run(&mut self) {
        let mut tick = interval(Duration::from_millis(20)); // 50Hz control loop
        loop {
            tick.tick().await;
            match self.state.mode {
                FlightMode::Autonomous => self.autonomous_step(),
                FlightMode::Manual => {} // passthrough to radio input
                FlightMode::Emergency => self.emergency_land(),
                _ => {}
            }
            self.publish_telemetry().await;
        }
    }

    fn autonomous_step(&mut self) {
        if let Some(target) = self.mission_waypoints.get(self.current_waypoint_idx) {
            let distance = haversine_distance(self.state.position, *target);
            if distance < 2.0 {
                self.current_waypoint_idx += 1;
            } else {
                let heading = bearing_to(self.state.position, *target);
                self.set_target_heading(heading);
            }
        }
    }
}
```

## Step 3: Agentic AI Control Layer

Build the autonomy layer using Claude's tool-use API for mission planning and real-time decision support.

```python
# agent/mission_planner.py
import anthropic
import json

client = anthropic.Anthropic()

TOOLS = [
    {
        "name": "set_waypoint",
        "description": "Command a drone to navigate to GPS coordinates",
        "input_schema": {
            "type": "object",
            "properties": {
                "drone_id": {"type": "string"},
                "lat": {"type": "number"},
                "lng": {"type": "number"},
                "altitude_m": {"type": "number"}
            },
            "required": ["drone_id", "lat", "lng", "altitude_m"]
        }
    },
    {
        "name": "get_fleet_status",
        "description": "Get current status of all active drones",
        "input_schema": {"type": "object", "properties": {}}
    },
    {
        "name": "abort_mission",
        "description": "Command RTH for specified drone",
        "input_schema": {
            "type": "object",
            "properties": {"drone_id": {"type": "string"}},
            "required": ["drone_id"]
        }
    }
]

def run_mission_agent(mission_brief: str, fleet_status: dict) -> list:
    """Returns list of tool calls representing mission plan"""
    messages = [{"role": "user", "content": f"Mission: {mission_brief}\nFleet: {json.dumps(fleet_status)}"}]
    
    response = client.messages.create(
        model="claude-opus-4-7",
        max_tokens=2048,
        tools=TOOLS,
        messages=messages,
        system="You are an autonomous drone mission controller. Plan and coordinate drone missions safely."
    )
    return [b for b in response.content if b.type == "tool_use"]
```

## Step 4: Ground Control API

Build the backend API that bridges the web UI, AI agent, and drone fleet.

```typescript
// api/routes/missions.ts
import { Hono } from 'hono'
import { droneFleet } from '../services/fleet'
import { missionAgent } from '../services/agent'

const app = new Hono()

app.post('/missions', async (c) => {
  const { brief, droneIds } = await c.req.json()
  
  // Get current fleet status for AI context
  const fleetStatus = await droneFleet.getStatus(droneIds)
  
  // Ask AI agent to generate mission plan
  const plan = await missionAgent.plan(brief, fleetStatus)
  
  // Persist mission
  const mission = await db.missions.create({
    name: brief.slice(0, 50),
    drone_ids: droneIds,
    waypoints: plan.waypoints,
    status: 'planned'
  })
  
  return c.json({ mission_id: mission.id, plan })
})

app.post('/missions/:id/execute', async (c) => {
  const mission = await db.missions.findById(c.req.param('id'))
  
  // Upload waypoints to each drone via MAVLink
  for (const droneId of mission.drone_ids) {
    await droneFleet.uploadMission(droneId, mission.waypoints)
    await droneFleet.arm(droneId)
  }
  
  await db.missions.update(mission.id, { status: 'active', started_at: new Date() })
  return c.json({ status: 'executing' })
})
```

## Step 5: Real-Time Swarm Coordination

Implement swarm behavior using publish-subscribe telemetry and distributed task allocation.

```python
# swarm/coordinator.py
import asyncio
import redis.asyncio as redis
from dataclasses import dataclass

@dataclass
class DroneAgent:
    id: str
    position: tuple[float, float, float]
    battery: float
    task: str | None = None

class SwarmCoordinator:
    def __init__(self):
        self.redis = redis.from_url("redis://localhost")
        self.drones: dict[str, DroneAgent] = {}
    
    async def run(self):
        pubsub = self.redis.pubsub()
        await pubsub.subscribe("telemetry:*")
        
        async for message in pubsub.listen():
            if message["type"] != "message":
                continue
            
            telemetry = json.loads(message["data"])
            await self.update_drone_state(telemetry)
            await self.rebalance_tasks()
    
    async def rebalance_tasks(self):
        """Hungarian algorithm for optimal task-to-drone assignment"""
        unassigned_tasks = await self.get_pending_tasks()
        available_drones = [d for d in self.drones.values() if d.battery > 20 and not d.task]
        
        if not unassigned_tasks or not available_drones:
            return
        
        cost_matrix = self.build_cost_matrix(available_drones, unassigned_tasks)
        assignments = hungarian_algorithm(cost_matrix)
        
        for drone_idx, task_idx in assignments:
            drone = available_drones[drone_idx]
            task = unassigned_tasks[task_idx]
            await self.assign_task(drone.id, task)
```

## Step 6: Operator Ground Control Interface

Build the real-time map-based UI with Next.js and WebSockets.

```tsx
// app/ground-control/page.tsx
'use client'
import { useEffect, useRef, useState } from 'react'
import mapboxgl from 'mapbox-gl'

export default function GroundControl() {
  const mapRef = useRef<mapboxgl.Map | null>(null)
  const [fleet, setFleet] = useState<DroneMarker[]>([])
  
  useEffect(() => {
    const ws = new WebSocket('wss://api.yourdomain.com/telemetry')
    
    ws.onmessage = (e) => {
      const telemetry = JSON.parse(e.data)
      setFleet(prev => updateDronePosition(prev, telemetry))
      
      if (mapRef.current) {
        updateMapMarker(mapRef.current, telemetry)
      }
    }
    
    return () => ws.close()
  }, [])
  
  return (
    <div className="h-screen flex">
      <div ref={el => { if (el) initMap(el, mapRef) }} className="flex-1" />
      <FleetSidebar drones={fleet} />
    </div>
  )
}
```

## Step 7: Deployment and Edge Infrastructure

Deploy the control stack with low-latency edge nodes co-located with forward operating areas.

```yaml
# docker-compose.yml (field deployment)
services:
  flight-control-api:
    image: your-registry/flight-api:latest
    ports: ["8080:8080"]
    environment:
      - DB_URL=${SUPABASE_DB_URL}
      - REDIS_URL=redis://redis:6379
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    restart: unless-stopped
  
  mavlink-bridge:
    image: your-registry/mavlink-bridge:latest
    network_mode: host  # required for UDP MAVLink
    devices: ["/dev/ttyUSB0:/dev/ttyUSB0"]  # radio modem
  
  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes
  
  telemetry-ingest:
    image: your-registry/telemetry:latest
    environment:
      - TIMESCALE_URL=${TIMESCALE_URL}
```

**Key deployment considerations:**
- Run the API behind Cloudflare Tunnels for zero-trust access from any network
- Use Supabase Realtime for telemetry broadcast to operator dashboards
- Cache mission plans in Redis for instant drone reconnect after signal loss
- Implement dead-reckoning in firmware for GPS-denied navigation
- Store all mission telemetry in object storage (Supabase Storage) for post-mission analysis

Install for:

claude-code-skills.md

#YC W2026 #Defense Tech #Autonomous Drones #Hardware #AI #UK Startups #NATO