Lymis discovers sensitive data wherever it lives, maps who — and which AI — can reach it, and governs that access from a single control plane. Collection and classification run at the edge, next to the data; only compact evidence and decisions move. Nothing crosses the customer boundary.
Every component — sources, collectors, classification, control plane, store and console — sits inside the customer's environment. Data flows up as evidence, never as content.
The expensive engines never run on everything. Cheap deterministic passes filter the field first; structural and semantic engines only ever see what survives. Run next to the data, this is what lets one platform classify petabyte-scale estates on commodity hardware.
Each tier hands only its survivors to the next. The GPU- and model-bound work touches a fraction of a percent of the estate — cost scales with sensitive data, not total data.
Large stores — databases, big repositories — are classified by representative sample and extrapolated, rather than read byte-by-byte.
Classification runs in or beside the collector, where the data already is. Grams of evidence move upward; terabytes of content never do.
Throughput scales by adding stateless collectors per source, site or region. The control plane and graph scale independently behind Postgres.
Threshold gating keeps each tier from wasting the next on noise, and honest per-source / per-engine coverage shows exactly what's been classified and by which tier.
The async API that ingests evidence, resolves and links the risk graph, runs the ABAC policy engine, computes AI reachability and blast radius, drives remediation, and generates compliance evidence. Stateless app tier — scale out behind the database.
One model of data, identities, groups, policies, applications, AI systems and the access paths between them — plus classifier evidence, fingerprints and audit. The single source of truth every surface reads from.
Edge workers that read sources read-only, classify and fingerprint locally, and ship compact evidence over mTLS. A high-throughput Rust agent for file systems; a Python collector for Microsoft 365 and identity; sampling collectors for databases.
A library of engines — pattern, reference, NER, fingerprint, exact-data-match, embedding and small-language-model — arranged as a tiered cascade. Each emits a hit only above its calibrated confidence threshold, keeping precision high and the pipeline cheap.
The operator and executive interface: posture and next-best-actions, exposure and reachability, AI governance, access reviews, detection & response, and privacy and reporting — one view over the API, entirely inside the boundary.
Containerised and self-contained, with no outbound dependency required. Deploys on-prem in a customer VPC, a private datacentre, or a fully air-gapped enclave — the same platform in every case.
The architecture is built around a single rule: content stays where it is; only evidence and decisions travel.
The same containers deploy as an all-in-one node for a pilot or air-gapped enclave, or as a replicated cluster for production. Stateless tiers scale out; the database scales with replicas; collectors scale with the data.
The whole platform via Docker Compose on one host — API, workers, PostgreSQL and console together. Ideal for proofs of value and isolated enclaves with no moving parts to operate.
API and workers replicated behind the load balancer; PostgreSQL primary with a hot standby and optional read replica; collectors distributed across sites. No single point of failure in the application tier.
| Deployment | Data estate | Topology | API / workers | PostgreSQL | Collectors |
|---|---|---|---|---|---|
| Pilot / enclave | up to ~10 TB | single node (Compose) | 1 / 1 | single instance | 1–2 |
| Standard | ~100s TB | HA cluster | 2–3 / 2–3 | primary + standby | 3–10 across sites |
| Large / multi-site | petabyte-scale | HA · multi-site | scale-out | primary + standby + read replica | tens, sharded by site |
Sizing figures are illustrative reference points to show how the architecture scales, not hard limits or benchmarks.
Because Lymis sits inside the boundary, the security model is the product. Access is least-privilege, every component authenticates, evidence is signed, and nothing phones home.
Protocol and policy specifics — IdP type, session lifetime, rotation cadence and exact role names — are the target control model and should be confirmed against the current build before formal diligence.
From an operator triggering a scan to a governed decision — the only thing that ever moves upward is evidence.
An operator runs or schedules a scan of a source.
The control plane assigns the job to the collector responsible for that source.
The collector connects read-only and walks or samples the source — async file walks for shares, per-column sampling for databases.
Each object or sample runs the local cascade: deterministic → structural → semantic, every hit gated by a calibrated confidence threshold.
Produces a fingerprint, data class, confidence and metadata, then signs it. The underlying content stays at the source.
Evidence streams to the ingest API over mTLS; progress heartbeats keep the job observable.
The signature is verified; assets, verdicts and coverage are written to the risk graph.
Assets are resolved against identities, groups, policies, applications and AI systems; exposure and AI reachability are computed.
The ABAC engine flags overexposure, toxic combinations and what AI can reach, producing findings and next-best-actions.
Posture updates; cases and remediation are created; evidence is ready for compliance — all inside the boundary.