The data layer for MOSA-aligned tactical edge platforms.
Arc is the columnar analytical database for defense and aerospace programs running on open architecture compute at the tactical edge. Ingest sensor and mission telemetry on-platform. Operate through DIL connectivity. Sync to the rear when the link is up. Query everything in standard SQL.
Single Go binary. Open Parquet. Standard SQL. Air-gap friendly.
The shape of the problem
The Department of Defense has spent the last decade trying to break out of proprietary, vendor-locked, expensive defense IT. The Modular Open Systems Approach is now policy. OCP openEDGE and OpenVPX are giving programs modular, COTS-built, rugged compute that survives shock, vibration, and the environment of a real platform. Mercury, Curtiss-Wright, and others are delivering blade servers with Xeon and NVIDIA accelerators inside MIL-STD-rated chassis. Primes and integrators can finally mix and match hardware modules across vendors.
The hardware story is moving fast. The software story is lagging.
Most analytical and time-series data systems were not built for this world. The big observability SaaS platforms are non-starters in tactical and classified environments. Traditional defense data historians license per tag and ship proprietary formats that lock the data inside one vendor\'s stack, which is exactly what MOSA is trying to escape. Open-source observability stacks are cluster-heavy and assume reliable network connectivity that the tactical edge cannot promise. Cloud data warehouses assume cloud.
Every modular open compute box on a platform generates and consumes data. Sensor fusion outputs. AI inference results. Radar tracks. Signals intelligence. Vehicle and subsystem telemetry. ISR feeds. Health and status from a thousand subsystems. That data either ships back to a rear data center under bandwidth pressure, or it sits in local logs that no system can query, or it lands in a closed historian that contractually outlives the program it was bought for.
The hardware story is moving fast. The software story is lagging. Arc is the data layer underneath.
Modular. Open. Single binary. Runs on any OCP-compliant or OpenVPX-compatible Linux box, x86 or ARM. Stores everything as Apache Parquet on storage the program controls. Queries with standard SQL. Operates autonomously through DIL connectivity. Syncs to the rear when the link is up. The same database runs on the platform, at the FOB, and in the rear data center, with the same data, in the same format, queried the same way.
Built for the workloads tactical edge programs actually run
On-platform telemetry capture
Mission software running on a rugged edge server generates telemetry constantly: sensor outputs, AI model inference results, RF spectrum samples, vehicle state, subsystem health. Arc ingests all of it locally at sustained 19.9M records/sec on a single box, partitioned by time, queryable about 100 milliseconds after it lands. The data does not have to ship back to be useful.
AI and ML inference context at the edge
H100s and A100s sitting in defense edge servers run target recognition, sensor fusion, and autonomous decision models. Those models need recent operational context. Arc serves as a fast columnar feature store at the edge, with standard SQL access, so the inference loop can pull recent sensor history and track state from data that landed milliseconds ago.
Disconnected and DIL operations
Tactical platforms operate through Denied, Intermittent, and Limited connectivity. Arc runs autonomously on the platform, ingests and stores locally, and syncs Parquet files to a central instance when connectivity returns. No cluster to lose quorum. No SaaS endpoint to fail unreachable. The platform keeps collecting and serving its own data whether the rear can hear it or not.
Edge-to-rear synchronization
The same database runs on the platform and in the rear data center. The same SQL queries work in both places. The same Parquet files move between them. One architecture, one query surface, edge to ground.
Rear-side cross-platform analytics
In the rear data center or sovereign cloud, every platform's data converges in Arc. Cross-platform queries become a single SQL statement: every aircraft, every ship, every ground vehicle, every sensor, every mission, in one queryable surface. Post-mission analysis, training data assembly, after-action reconstruction, and compliance retention all run against the same store.
Coalition data sharing
Coalition partners and allied contractors can read Arc's Parquet directly with their own tools: Pandas, Polars, Spark, DuckDB, any analytical engine that speaks Parquet. No proprietary client, no licensed driver, no format conversion.
What Arc gives a defense or aerospace program
MOSA-aligned by design
AGPL-3.0 open source with a commercial license. Single binary, no proprietary runtime. Data in an open format any tool can read. Runs on any standard Linux on any OCP-compliant or OpenVPX-compatible hardware. The architectural posture is exactly what MOSA was written to require.
Open Parquet, not a closed historian
Operational and mission data lives as Apache Parquet on storage the program controls. If Arc disappeared tomorrow, the archive is still readable by every analytical tool on earth. Not trapped inside one vendor's format. This is the technical answer to vendor lock-in, not a marketing one.
Air-gap friendly, no external dependencies
No required external connections. No phone-home telemetry, no required SaaS calls, no license server check-in. Runs in fully air-gapped classified environments, in disconnected mobile platforms, and in sovereign on-premise deployments without modification.
Single binary, edge to ground
One Go binary. No Java runtime, no Python interpreter, no Zookeeper, no service mesh, no cluster topology to design. The same binary runs on a Mercury CMS X08, on a forward operating base server, in a SCIF data center, and in a sovereign cloud.
Standard SQL across the whole archive
Standard SQL through an embedded vectorized engine. Analysts, operators, and contractors who already know SQL are productive on Arc immediately. No proprietary query language to train against, no vendor-specific tooling to license per analyst.
Cardinality without penalty
Tagging telemetry with platform ID, mission ID, sortie ID, sensor ID, or operator ID does not collapse query performance. Arc treats high-cardinality fields as ordinary column data, not as an exploding index. Cross-platform and cross-mission queries that crater tag-indexed systems are routine.
Years of history at object-storage prices
Arc stores data as ZSTD-compressed Parquet, typically 5-7x smaller than raw. Multi-year archives of full-resolution telemetry cost what object storage costs, not what a per-tag licensed historian charges. The pressure to drop resolution or shorten retention disappears.
Compatible with prime contractor ATO boundaries
For programs running inside a prime contractor's accredited boundary, Arc's posture is built for it: no required external services, deterministic build, open format storage, self-contained binary, no inherited SaaS risk. Arc rides inside the accredited boundary the prime already operates.
Supply chain posture and compliance roadmap
Arc is built for environments where software supply chain integrity is mandated under EO 14028 and increasingly required by DoD procurement.
Available today
- AGPL-3.0 open source. Full source auditable. Commercial license available for programs that require it.
- Coordinated vulnerability disclosure. Demonstrated publicly in release 26.06.1 with external researcher credit.
- FIPS 140-3 build variant (arc-fips) with FIPS-approved validated cryptography. Available starting in release 26.06.2 (July 2026).
- Cross-platform binaries for any standard Linux distribution.
- No external dependencies at runtime. Air-gap and offline operation supported.
On the roadmap
- SLSA Level 2 signed builds with provenance attestation.
- Software Bill of Materials (SBOM) published with every release.
- NIST SSDF self-attestation.
- CVE Numbering Authority application.
Customer-driven certifications. CMMC Level 2 and other program-specific compliance requirements are pursued in partnership with the customer when a contract requires them.
Why defense and aerospace programs choose Arc over the alternatives
Proprietary defense data historians are exactly what MOSA was written to escape. Per-tag licensing, closed formats, contracts that outlive the program. Arc is one binary, open Parquet, and the data leaves with the customer.
Observability SaaS platforms like Datadog and Splunk are operationally polished and structurally wrong for the tactical edge. SaaS dependencies, ingest-based pricing, and external network requirements rule them out of most classified and disconnected environments. Arc is self-hosted, single binary, and air-gap native.
Cluster-heavy open-source stacks like ClickHouse or Prometheus, Loki, and Tempo are designed for stable connectivity and a data center operations team. They do not survive DIL operations on a rugged edge box. Arc runs on one node, autonomously, through any connectivity profile.
Cloud data warehouses like Snowflake and BigQuery were not designed for tactical workloads. Connectivity, cost model, and data sovereignty all argue against them in defense contexts. Arc keeps data on infrastructure the program already controls.
Build-it-yourself DuckDB plus Parquet is the most thoughtful alternative, and it is exactly what Arc is. DuckDB plus the production layer a defense program actually needs: high-throughput ingestion from real telemetry protocols, autonomous compaction, retention, edge-to-rear sync, governance, and supply chain integrity. In one binary.
What this looks like in production
Arc is running in production aerospace flight operations today, including modern flight ops in the United States. Sovereign deployments. Single-instance ingestion at sustained millions of records per second. Multi-year archives in open Parquet on customer-controlled storage. Standard SQL across the full archive.
AGPL-3.0 with a commercial license for organizations that require it.
Get started
Three ways to evaluate Arc for a defense or aerospace edge workload.
See it run on real telemetry
Our live demos include vehicle tracking, sensor telemetry, and the Mission ARC-1 launch dashboard, all running against real Arc instances.
Get Arc
Arc is open source and ships as a precompiled single binary. Pull it from the download page as Docker, Helm, or a .deb, and point your existing telemetry pipeline at it. Most teams have data flowing in within an hour. Source on GitHub.
Talk to us about your program
For programs with ITAR, sovereign cloud, air-gapped, or classified requirements, we run a private discovery to scope deployment architecture, integration with your MOSA-aligned hardware stack, supply chain documentation, and licensing.