§ Use case · SBOM compliance tool · Measured file lineage

Scan what ships.
Not the whole source tree.

Scanners crawl ~70,000 source files when only ~20,000 flow into the product. ABIS reverses the order: observe the real build, measure the file-to-file lineage, verify it with a reduced rebuild — then scan and clear only what actually ships. The SBOM isn't declared. It's measured.

The two artifacts every reviewer asks for: what the software is made of, and what it did — side by side, straight from the running system.

§ The gap

Scanners don't know the build. Build systems demand migration.

The compliance market splits into two camps — and the gap between them is exactly where the pain lives.

The problem

Scan everything, know nothing about what ships

Compliance scanners crawl the complete source tree with regex heuristics — none of them answers whether a file ends up in the product:

  • ~70,000 files scanned when ~20,000 flow into the product
  • Hundreds of manual clearing hours per component version
  • Test code, examples, and dead configs cleared for nothing
  • Build systems like Bazel or Nix know the answer — but only after months of build migration
  • Declared SBOMs drift from shipped reality with every release
The ABIS answer

Measure the lineage. Then scan only what ships.

ABIS observes the unmodified legacy build and measures what actually flows in — no migration, no guessing:

  • Syscall tracing + toolchain artifacts — the build's own ground truth
  • Backwards reachability from the shipped artifact, per configuration
  • Verified by reduced rebuild: unit tests + identical function signatures
  • Content-addressed delta: 80–90% of files skip re-scanning between versions
  • Measured SBOM generated only from the approved graph state
§ The levers

What measuring first changes.

Example figures from a Linux-kernel-class component — the hardest case in any clearing portfolio.

70k 20k

Scan-set reduction before the first license scan — measured and verified, not sampled.

80–90% skipped

Identical files between versions are recognised by content hash and never rescanned.

Rebuilt = proven

The reduced bundle rebuilds and passes the test suite — audit-proof evidence, not a heuristic.

Experts see <5%

Deterministic detection first; only low-confidence edge cases reach a human reviewer.

§ The landscape

Where ABIS sits in the tooling market.

Not against the incumbents — in the layer none of them occupies. ScanCode stays the deterministic detector; clearing platforms remain optional endpoints. ABIS feeds them a smaller, qualified file set.

Approach File lineage No build migration Scan reduction Verification Clearing workflow
ORTyespolicy as code
FOSSologyyesdelta only (reuse)strong
ScanCode.ioheuristicyespartial
Black Duck & co.yesmedium
Bazel / Nix / Yoctoexactno — migration requiredexactreproducible
ABISmeasured (trace + toolchain)yesbefore the scanreduced build + testsgraph + human in the loop
§ How it works

Observe. Measure. Verify. Scan. Deliver.

One pipeline for every ecosystem — the same five steps for an Angular bundle and the Linux kernel. Every step leaves evidence you can hand to a reviewer.

1

Observe the real build

The build runs once, unmodified, in a hermetic container under syscall tracing. Every opened file is logged; the toolchain's own dependency artifacts (.d/.cmd files, compile databases, linker maps) are collected alongside. No parsing, no guessing — the trace is ground truth.

You get: raw, audit-grade evidence of everything the build touched.
2

Derive the file-to-file lineage

Deterministic rules turn the evidence into typed edges — include, link, file-I/O, generated — each with provenance and confidence. Backwards reachability from the shipped artifact answers the core question: which files are actually in the product, per build configuration.

You get: a measured lineage graph, not an estimate.
3

Reduce and verify

Everything not in the lineage is removed, and the reduced bundle is rebuilt in the identical environment. Passing unit tests and identical function signatures prove the reduction lost nothing — roughly 70,000 source files shrink to ~20,000 verified product files.

You get: audit-proof evidence that the scan set is complete.
4

Scan only what ships

Deterministic license detection runs on the qualified set only; content-addressed delta skip removes 80–90% of files between versions before any scan. Just the low-confidence remainder routes to expert review — and every verdict makes the next version cheaper.

You get: clearing effort proportional to what changed, not to repo size.
5

Gate and generate the measured SBOM

Declarative rules ("no AGPL in shipped artifacts") gate the release; your compliance manager approves the graph state. Only the approved state generates the SBOM (CycloneDX/SPDX) — reconciled against any declared SBOM, with every entry traceable to raw build evidence.

You get: a gated, measured deliverable — not a report.
§ The difference

A file you request vs. evidence you already have.

Vendor-supplied SBOM files age the moment they're written. Evidence produced by the running system doesn't.

Typical AI/BI vendor

  • No SBOM, or one produced on request months later
  • Cloud-hosted — your data leaves the perimeter
  • Telemetry and model calls you can't inspect
  • No record of what the tool did with your data
  • Compliance answered with a marketing PDF
  • Audit questions routed through vendor support

ABIS

  • Published SBOM per release; signed + source escrow in Sovereign
  • Self-hosted, air-gappable — data never leaves the building
  • No telemetry, no phone-home, offline updates available
  • Hash-chained audit log of every read, write, and refusal
  • Compliance answered with exportable evidence
  • Annual third-party security review in Sovereign
abis · lineage_runner · linux-kernel · x86_64-defconfig ● LIVE RUN
strace · execve("gcc -c kernel/sched/core.c") pid 4711
strace · openat("kernel/sched/core.c") · read
strace · openat("include/linux/sched.h") · read
strace · openat("/usr/include/openssl/ssl.h") · read · scope=external:system
collect · .kernel/sched/.core.o.cmd · toolchain dependency list
hermetic · build phase --network=none · no unexpected network access

The build runs once for real, in a sealed container, under syscall tracing. Every file it opens is logged — nothing is guessed or parsed.

core.c → sched.h · include · toolchain:kbuild-cmd · confidence 1.0
core.o → vmlinux · link · linker-map --cref
client.ts → node_modules/axios/…/http.js · pkg:npm/axios@1.7.2
kconfig → config.h · generated · lineage passed through
qualify · backwards reachability from shipped artifact · 20,412 files build-relevant

Deterministic rules turn the evidence into typed file-to-file and file-to-package edges — qualified backwards from the artifact, so the graph answers exactly one question: what is in the product?

reduce · scan set 70,000 → 20,412 files · unmarked files removed
rebuild · reduced bundle · identical container digest · build succeeded
verify · unit tests 1,284 / 1,284 passed
verify · function signatures · identical · artifact hashes compared per object
flag · lineage · QUALIFIED

The reduction is proven, not assumed: the product builds identically from the reduced set — audit-proof evidence instead of a heuristic.

delta · content-addressed skip 83% of files unchanged since v6.9 · not rescanned
scancode · 18,970 files · deterministic license hit
route · unmapped remainder 3.1% → model + expert review only
review · drivers/net/e1000.c GPL-2.0-only → GPL-2.0-or-later · corrected · label recorded

Deterministic first, experts only for genuine edge cases — and every correction makes the next version cheaper.

reconcile · declared-but-unused 41 packages · SBOM bloat, no clearing needed
reconcile · used-but-undeclared 3 packages · supply-chain alarm
rule · "no AGPL in shipped artifacts" · pass
gate · compliance manager · APPROVED
export · SBOM CycloneDX · signed · every entry traceable to raw evidence

Only an approved graph state generates the SBOM. It isn't a report — it's a gated, measured deliverable.

One pipeline, five steps — from observed build to measured, signed SBOM. Hover to pause, click a step to jump.

§ Who this is for

Built for the strictest reviewer in the room.

If your security team vetoes SaaS AI tools on supply-chain grounds, this is the deployment model they will approve.

Regulated enterprises

Banks, insurers, and healthcare organisations that must evidence supply-chain controls under NIS2 and sector rules.

  • Signed SBOM for procurement review
  • Air-gapped install available
  • Hash-chained audit log, indefinite retention

BI & data platform teams

Teams that want Agentic BI without handing the security team an unauditable black box.

  • MCP server runs locally next to the data
  • Every agent action logged and attributed
  • EU AI Act Articles 10 + 12 evidenced by default
§ Questions

SBOM compliance, answered.

If yours is not here, write to hello@abis-cloud.nl

What is an SBOM compliance tool?
A tool that helps you produce, verify, and maintain a Software Bill of Materials to satisfy regulations like the EU Cyber Resilience Act and NIS2. Most tools scan the entire source tree with regex heuristics. ABIS reverses the order: it first measures which files actually flow into the shipped product (file lineage, observed from the real build), then scans only those — and generates the SBOM from measurement instead of declaration.
What is a measured SBOM?
A declared SBOM lists what a vendor or manifest says is in the software. A measured SBOM is generated from evidence: ABIS observes the real build via syscall tracing and toolchain dependency artifacts, derives file-to-file and file-to-package lineage, verifies the result with a reduced rebuild plus unit-test comparison, and only then generates the SBOM (CycloneDX/SPDX) from the approved graph state. Reconciling measured against declared yields two delta lists: declared-but-unused (SBOM bloat) and used-but-undeclared (a compliance alarm and supply-chain indicator).
What is file-to-file lineage?
The measured dependency chain from source file to source file to package to shipped artifact — which files actually flow into the product for a given build configuration. ABIS measures it by executing the build once under observation: every file the build opens is logged, toolchain dependency files explain why, and backwards reachability from the shipped artifact qualifies exactly the set that ends up in the product. For a Linux kernel that reduces roughly 70,000 source files to about 20,000 product files before the first license scan.
How is ABIS different from SBOM scanners like ORT, ScanCode, or Black Duck?
Compliance scanners analyse the complete source tree and optimise handling of the result — none of them answers whether a file actually ends up in the product. Build systems like Bazel or Nix know the lineage exactly but require migrating the build. ABIS sits in the gap: it measures lineage by observing unmodified legacy builds, verifies the reduction with a rebuild and unit tests, and then feeds established tools like ScanCode a dramatically smaller, qualified file set. It complements the incumbents instead of replacing them.
What is SBOM compliance?
Being able to produce a complete, current Software Bill of Materials — every component, library, and dependency inside a piece of software — whenever a regulator, customer, or security team asks. In the EU, the Cyber Resilience Act makes SBOMs a requirement for products with digital elements, and NIS2 pushes the same transparency onto essential and important entities.
Which EU regulations require an SBOM?
The Cyber Resilience Act requires manufacturers to maintain a software bill of materials covering at least top-level dependencies. NIS2 requires supply-chain security measures, and the EU AI Act adds record-keeping and transparency obligations for AI systems. Together they make supply-chain transparency a standing obligation, not a one-off audit exercise.
Does ABIS provide a signed SBOM?
Yes. ABIS publishes an SBOM for every release, and the Sovereign edition ships a signed SBOM with source escrow held by a notary — so ministries, banks, and air-gapped deployments can verify exactly what runs on their hardware without trusting a vendor claim.
Why do SBOMs matter for AI and BI tools specifically?
AI assistants and BI connectors are the newest and least-scrutinised software in most estates: they touch the most sensitive data while their own supply chain is often a black box. A self-hosted tool with a published SBOM, no telemetry, and hash-chained audit logs closes that gap — you can prove what the software is, what it did, and what data it touched.
ABIS logo

Bring the SBOM to your next security review.

Request access and we send the whitepaper plus the current release SBOM — everything your security team needs to say yes.