FOR PRIMES & DEFENSE INTEGRATORS

The problem is multidomain. The cadence is overnight. The answer is Labori Forge.

Single-vehicle autonomy has been largely solved. The next frontier is scale — getting all your vehicles working together to achieve mission effectiveness. You can't experiment your way through field testing. It costs too much, expensive assets sit idle, and a dozen people watch software engineers work through basic issues that should have been caught months earlier. We've all been there.

Labori Forge is the simulation and V&V environment where your engineers develop multi-vehicle autonomy, your test team validates it, and your customers see results — all browser-driven, all in one place. Air, ground, surface, underwater. Real-world adversarial conditions, at any scale you need.

Request a Technical Brief → See what's inside
10×
Lower sim infrastructure cost
10×
Faster to multi-vehicle V&V
5×
Reduction in wasted field time
Capabilities

What Labori Forge does.

01 / Rapid Iteration

The adversary adapts overnight. Your answer ships by morning.

Air. Ground. Surface. Underwater.
One environment, one cadence.

Rapid iteration isn't a slogan here — it's what the architecture is built for. Your autonomy plugs into a native domain — your software can't tell it's not on the vehicle. Edit, relaunch, rerun the same mission against the same conditions. Warp-factor time compresses hour-long missions into minutes. Scriptable REST turns the whole thing into a pipeline. When a tactic shows up in the field that wasn't in yesterday's test matrix, it's in tonight's.

  • Native domain — autonomy runs unchanged from sim to vehicle
  • Warp-factor time compression
  • Scriptable REST interfaces — drive runs from your own scripts
  • Same-day stand-up — connect in, no infrastructure to provision
02 / Multidomain & Realistic

Unified scenarios. All of it fuzzy.

Fuzzy sensors. Fragmented comms.
Partial pictures. Just like the field.

Most simulators give every vehicle a perfect view of the world — which is why autonomy that looks great in a sim fails on day one of operations. Labori Forge runs every domain in a unified physics-backed scenario, and each vehicle only sees what its comms let it see. RF, satellite, and acoustic channels — each degradable from nominal to severe to total failure at runtime. Denial zones you can drop on the map mid-mission. Your autonomy gets tested against the world it will actually operate in.

  • USV · UUV · UGV · drone · fixed-wing · operator-defined variants
  • Per-vehicle, comms-realistic world picture
  • RF · satellite · acoustic — degradable to moderate, severe, or total failure
  • Denial zones configurable at runtime
03 / Confidence at Scale

Run your real software in the loop. Sweep the space. Ship what you tested.

Software- and Hardware-in-the-loop V&V.
Broad coverage. Same-day adoption.

Labori Forge runs your real flight or mission software in the loop — the same binary that goes on the vehicle, running through the same interfaces. On your deployed compute board, on Linux boxes, or any mix. What passes V&V here is what ships.

Spawn parallel runs at operational scale, sweep the parameter space — comms degradation, fleet composition, sensor noise — and find the corners no hand-curated test matrix would ever hit. When a program review asks "did you test it under jamming?", the answer is a histogram, not a hand-wave.

Labori Forge is a hosted service. Your software runs where you choose and connects in for SIL or HIL. Your code and your processors stay where they are. No infrastructure to stand up, no environment to maintain, no migration.

  • Software- and hardware-in-the-loop — your real binary, your choice of where it runs
  • Parallel runs and parameter sweeps at operational scale
  • Hosted service — your software and hardware stay where they are
  • Scriptable from the command line — drive it from your own pipeline
Under the hood

How it actually works.

Labori Forge is running today as a hosted service, supporting multiple customer programs in parallel.

Stack
ROS2 Jazzy Gazebo Harmonic PX4 SITL Python 3.12 gRPC
Architecture
Domain split. The simulation domain hosts physics, the comms channel, target models, and a god's-eye world model. Autonomy runs in identical, isolated domains that replicate on-vehicle interfaces and are tailored to your specific platforms. The comms bridge is the only path between the domains, just like real tactical networks.
Vehicles
Air — fixed-wing and rotary. Ground — Ackermann and skid-steer. Surface — physics and kinematic. Underwater — flapping-foil and propeller-driven. Mix any combination in a single scenario.
Comms
RF, satellite, and acoustic channels with configurable drop, delay, and jitter. Each channel degradable to moderate, severe, or total failure at runtime. Denial zones, rate limits, and degradation profiles configurable per modality, per vehicle.
Deployment
Cloud-hosted service. You connect in over a secure tunnel — typically Tailscale — and run autonomy from your own Linux environment against the simulation endpoints. No infrastructure to provision, no environment to maintain. Stand-up is measured in hours.
Integration
Your autonomy plugs into a native ROS2 domain — same topics, same messages, same QoS as the deployed vehicle. Run against our library of representative platforms, or we'll tailor the interfaces and models to match your specific vehicles. Scriptable REST for parameter sweeps and parallel runs.
Software & hardware in the loop
Your real flight or mission software runs against the simulation through the same interfaces as the deployed vehicle. Run it on your deployed compute board, on Linux boxes, or any mix — same binary, same endpoints, same outcome. The binary that passes V&V here is the one that ships.
Simulation control
Sim configuration, scenario setup, target spawning, comms degradation, execution monitoring, and logging — all from a single web interface. No YAML-and-CLI shuffle to start a run or change conditions mid-mission. Your customer's operator UI is their concern — it plugs into the comms network like any other autonomy node.

The loop your programs are missing.

30-minute technical brief. We'll stand up a scenario in your domain, drop in a stand-in for your autonomy, and run a contested-comms mission end-to-end. No slides.

Request Technical Brief →