Find the transient.
Ship the bird.
COSMOS was born in aerospace hardware labs during subsystem and system integration & test. Two decades later, it still does that better than anything else.
The pieces that matter on day one of I&T.
No tool-chain assembly required. Plug the rack in, point COSMOS at it, start running campaigns.
Every device on one bus
Power supplies, DMMs, oscilloscopes, DAQs, FPGAs, SOCs, flight computers — same UX.
Script Runner for sweeps
Run timing, voltage, and thermal sweeps nights and weekends. Auto-analyze scope output.
Limits & alerts
Watch every mnemonic. Wake an engineer only when reality drifts off the rails.
Full logs & replay
Every packet, every command, every test. Replay any minute, any campaign.
I&T → Ops reuse
Pull your I&T configurations forward into ops. No rewrite. No re-learning.
Flight-proven
50+ missions, TRL-9. From hobbyist labs to national assets.
From breakout box to launch readiness.
Plug it in
GPIB, Ethernet, USB, RS-422, MIL-1553, SpaceWire. Point COSMOS at the device.
Define the packets
Plain-text command & telemetry definitions. Version them in git like real code.
Script the campaign
Ruby or Python. Loops, sweeps, conditional branches, parallel sequences.
Run unattended
Limits monitor every mnemonic. Pager fires only when something actually drifts.
Replay the anomaly
Scrub any packet log down to the microsecond. Find the offending edge in seconds.
Promote to ops
The same configs go forward. No rewrite for launch, ops, or contingency.
One platform. Four stages. Growing scope.
From a bare board on a bench to a full spacecraft talking to its ground system — the same COSMOS commands every stage. Configs move forward as scope grows.
Skip the harness. Start commanding silicon.
Whether you write a one-off firmware connection or pull a plugin from the App Store, COSMOS commands and monitors any embedded board from day one.
- Repeatable command execution with full logging
- Real-time visibility into processor state and task health
- Scripted sequences for regression validation
- Formal command/telemetry dictionary from the first power-up
Validate flight-software interfaces faster — without building throwaway tooling.
Turn integration risk into predictable validation.
Consistently applied, pre-configured regression sequences and telemetry dashboards turn box-level integration from a panic into a checklist.
- Scripted fault-injection sequences
- Real-time limits monitoring and alerting
- Unified command + telemetry timeline
- Automated test scripts tied to command definitions
Reliable, repeatable regression — integrated faster, without burning engineers.
Bus, payload, and GSE on one pane of glass.
Unify every system across bus, payload, and ground support equipment — multiple telemetry streams merged into one operator view.
- Unified control of payload and bus interfaces
- Time-synchronized telemetry across systems
- Command injection while monitoring the full data path
- Centralized sequencing across ADCS and payload
End-to-end mission dataflow and subsystem coordination under realistic conditions.
Train operators on the system that flies.
Start in test, then scale the same COSMOS into the operational system — providing one consistent environment across the whole hardware lifecycle.
- Scripted anomaly scenarios with full capture and replay
- Multi-user environment for operator training
- Hardware-in-the-loop + simulation integration
- The same configs that go forward into mission ops
Validate resilience before launch — not after it.
Every box in the lab,
one console.
Hundreds of pre-built drivers, plus a plugin SDK for the one-off box only you have. Same dashboards. Same Script Runner. Same log format.
Power supplies
Keysight, Rigol, TDK-Lambda, Magna-Power
DMMs & SMUs
Source-measure, precision metrology
Oscilloscopes
Auto-capture, screenshot, waveform analysis
DAQs
NI, LabJack, Measurement Computing
FPGAs & SOCs
JTAG, SPI, I²C, custom flight buses
Comms & radios
RF chains, modems, SDR, CCSDS framing
Thermal chambers
TVAC profiles, soak, ramp, dwell
Anything with a port
If it talks, COSMOS talks to it.
Tests that ran themselves all weekend.
Ruby or Python. Branch on telemetry. Sweep voltage and timing. Drop an artifact in a folder. The test campaign you used to assign engineers to babysit now just… finishes.
- Parameter sweeps with conditional branches
- Auto-capture scope waveforms on limit break
- Parallel sequences across multiple devices
- Resume from checkpoint after a power glitch
# Sweep PSU voltage × FPGA clock until fault asserts
(3.20..3.45).step(0.01) do |v|
cmd("PSU SET_VOLTAGE with VOLTS #{v}")
[50, 75, 100, 125].each do |mhz|
cmd("FPGA SET_CLK with FREQ_MHZ #{mhz}")
wait 0.250
if tlm("OBC FAULT_STATUS") != 0
capture_scope("CH1,CH2,CH4")
log "Fault @ V=#{v} MHz=#{mhz}"
end
end
end“One of my favorite COSMOS-saves-the-day stories: we built up the world’s ugliest breakout box and I used Script Runner to sweep timing and voltage settings. The test ran by itself until one day it found the combination that activated the fault — and the wiring fault behind it.”
The configs you built in the lab fly the mission.
Most teams ship I&T tools to /dev/null the day before launch and start over for ops. With COSMOS, your packet definitions, limits, screens, and procedures move forward as-is.
- 01 · I&TSubsystem I&T
- 02 · I&TSystem I&T
- 03 · LaunchLaunch campaign
- 04 · OpsMission ops
What you stop building the day you adopt COSMOS.
Questions I&T leads actually ask.
Does COSMOS talk to my specific FPGA / radio / bus?+
Can we use it during subsystem I&T, not just system-level?+
What languages do scripts run in?+
How does this carry forward into mission operations?+
Open source or enterprise?+
Stop hand-rolling test harnesses.
See COSMOS drive your test rig in a live demo. Bring your weirdest box — we’ll wire it up.