Platform
One engine, four pillars, across the whole AI lifecycle
One engine sits beneath everything AICAP does. Four pillars are built on it, covering the AI lifecycle from knowing what you have to securing how agents behave in production. It runs on open intelligence and on what your own deployments tell it.
Four pillars, one engine
Survey (discover). Maps every model, agent and tool in use, so assurance starts from a complete picture.
Origin (build). Captures the provenance of AI-written code and re-checks it when the model that wrote it turns out to be flawed.
Core (deploy). Assures deployed models and agents as their context changes, generating the tests that matter before go-live.
Trace (operate). Watches agent behaviour in production: the tools they reach for, the sequences they run, the actions they take.
Same intelligence, same correlation engine, same air-gapped delivery.
A closed loop, not a checklist
Intelligence goes in continuously. Open sources make up most of it: MITRE ATLAS for adversarial-ML technique, CVE and NVD for disclosure, CISA KEV for what is actually being exploited, EPSS for how likely exploitation is, GHSA and OSV for the software supply chain, NCSC advisories, the AI Incident Database, model registries, benchmarks and research. Data and feedback from your own deployments and operations go in alongside them. Prioritised, targeted findings and assurance evidence come out, and those results feed back, so each cycle is sharper than the last.
How discoveries get matched to your specific deployments, how impact is scored, and how a risk becomes something you can act on is the part we have built and the part we would rather walk you through than publish.
AI on both sides of the loop
AICAP assures AI, and it uses AI to do it. Models and agents sit inside the platform to make the question easier to frame and the answer easier to get: ask what changed, what it affects and what to do about it, in plain language, rather than knowing which query to write. They also go further than anyone has time to by hand, pulling threads across intelligence, your asset register and previous results.
The model layer is deliberately swappable. Self-hosted open-weight models where the data cannot leave, commercial models where that is appropriate, chosen per deployment and per classification.
Where this is going. How agents should couple to an assurance platform is not a settled question, and we would rather say so than pretend otherwise. We expect the coupling to be tight. We may fine-tune our own models for assurance, compliance and security, or integrate specialised ones that already do it well. The architecture is built to keep that choice open rather than betting the platform on one answer.
In practice · Core
An analysis AI moves to a new environment
Standard tests pass. Without AICAP: weeks later a known model flaw surfaces, published all along, never connected to this deployment. With AICAP: the context change triggers correlation and the right tests run before go-live.
In practice · Origin
The model your team codes with turns out to be vulnerable
Months of its output is already merged. Without AICAP: nobody knows which files that model wrote, so the review is either everything or nothing. With AICAP: every codebase and file it touched is already on record, flagged for re-check, and back in the pipeline the same day.
In your pipeline
AI writes a large share of production code, but the record of which tool and model wrote it disappears the moment a suggestion is accepted. Origin captures it where it happens and lives inside your existing pipeline.
Capture at the source. Hooks for the assistants your engineers already use, plus a browser extension and editor plugins.
Scan in CI. A repository scan runs as a step on any build. Retroactive labelling backfills repositories that predate the hooks.
Gate the build. Each codebase gets an assurance posture your pipeline can assert on like any other quality gate.
Re-check retroactively. When a code-generation model is later found vulnerable, every codebase it touched is flagged, back in the pipeline rather than in someone's inbox.
Alongside your SOC, not instead of it
AICAP feeds the tools your security and engineering teams already run, rather than asking them to watch another dashboard. Core raises what changed about a deployed system; Trace raises what an agent actually did.
Today: severity-scored alerting, an append-only event store with stream fan-out, signed and verifiable export bundles, test specs exportable to pytest, JUnit and GitHub Actions, and Prometheus metrics.
On the roadmap: webhook and email alert delivery, and named SIEM connectors. The event stream and alert plane are the surface those will be built on.
CI/CD
Test specs export to pytest, JUnit and GitHub Actions. Origin scans and assurance gates run as ordinary build steps.
Alerting
Scored, deduplicated and routed by severity, with human review where the decision warrants it.
Evidence export
Signed bundles with a verification endpoint, so the receiving party can check them independently.
Event stream
An append-only event store with per-type fan-out: the integration surface for downstream SOC and SIEM tooling.
Observability
Prometheus and Grafana, including feed freshness so you can see when a source goes quiet.
Identity
OIDC and LDAP with role-based access, so assurance activity is attributable to a named person.
Cloud to air-gapped
The same build deploys from commercial cloud down to fully air-gapped, on Lattice, our air-gapped Kubernetes distribution. Open foundations throughout, including open-weight LLMs, so inference can stay where the data has to stay. Classification-aware handling runs through the platform rather than sitting on top of it.