Complexity Labs is a research-led engineering
company. We build the data platforms and AI systems that hard
problems need, and we run the research those systems turn out to
require. Our partners are in academia, industry and government.
One queryable, AI-ready surface over the whole estate: files,
object stores, databases, warehouses, streams and APIs. Nothing is
replaced. You declare where data lives, how it transforms and
where results land, and every change propagates on its own.
Agents extract what matters from filings, forms and archives,
check it against your rulebook, and draft the next action with
citations to both the document and the rule. A person approves
every consequential step, and every step is logged.
Data platforms, document automation and AI for agencies, built
to be examined. We deploy inside your tenant, integrate through
APIs, and leave your source systems unmodified. Registered, SAM.gov
active, with a capability statement you can print for your files.
We unify estates scattered across decades of systems and
rebuild aging pipelines while they keep serving traffic. Lineage,
quality scores and access controls come from day one, because
retrofitting them onto a live platform is the expensive way.
The theory side works on PAC learning and, in particular,
verification: what it takes to check a model with less work than
training it yourself. The applied side ships bias testing under
the NIST AI Risk Management Framework, drift detection in
production, and retrieval that cites its sources.
We audit where you are exposed to harvest-now-decrypt-later
collection, then migrate: key exchange to ML-KEM (FIPS 203) and
signatures to ML-DSA (FIPS 204). We build on algorithm-agnostic
libraries, so your next migration is a configuration change. The
research arm works on lattice problems and verifiable audit trails.
Sketches and streaming estimators answer anyway, and state how
much to trust the answer: Morris counters, count-min sketches,
locality-sensitive hashing. You choose the accuracy and the
confidence, and the algorithm chooses how little it can get away
with reading. These primitives end up inside NRV.