Private AI and data sovereignty

The AI runs where your data already lives.

Open-weight models served inside your own cloud, private retrieval over your own documents, and a policy and redaction gateway that logs every request before it is made. For the workloads that were never going to be allowed out of the building.

Where your data actually flows.

Four stages, and every one of them inside your perimeter. The point of the diagram is the box, not the arrow.

Request path, fully self-hosted posture. The models change. The boundary doesn’t.

  1. 01

    Your data stores

    Documents, tickets, records and the vector index built from them stay in the systems and accounts you already control. Nothing is copied into a vendor's index to be searchable.

  2. 02

    Policy and redaction gateway

    Every request passes one gate: who is allowed to ask what, which fields are stripped before the request moves on, and a log entry written before the model is called rather than after.

  3. 03

    Model serving in your VPC

    Open-weight models — Llama, Mistral, Qwen — served on your own GPUs or in your own cloud account through vLLM or Ollama. In this posture no third-party inference call exists in the path.

  4. 04

    Response and audit log

    The answer comes back with the sources it was grounded in, alongside a record of who asked, what was retrieved, which model answered and what was redacted on the way.

Three ways to draw the line. Most companies pick the middle one.

Private AI is not one architecture, and the strictest option is not automatically the right one. Each of these buys something and costs something, so both are printed beside it.

Boundary added

Frontier API, guarded

You keep using the best available models, and we put the boundary in front of them: sensitive fields redacted before the call, zero-retention terms in place with the provider, policy on who may ask what, and an audit log you own.

  • Best for: Teams whose constraint is contractual and auditable rather than absolute.
  • What it costs you: Inference still happens on someone else's hardware. That is a control, not residency, and it should never be described as the latter.

Hybrid routing

Sensitive in, everything else out

A router classifies each request. Anything touching the data classes you have named runs on a model inside your own environment; everything else goes to a frontier API under the same redaction and logging. One gateway, two destinations.

  • Best for: Most companies. A minority of traffic is genuinely sensitive and it is rarely the expensive part.
  • What it costs you: You are running two paths, so the classifier becomes a thing that has to be right. We build it with evaluations and fail it closed, toward the private side.

Fully self-hosted

Open weights, your environment

Llama, Mistral or Qwen served on your own GPUs or in your cloud account through vLLM, with private retrieval over your own stores. No third-party inference call exists in the path — no provider to trust, no retention window to negotiate.

  • Best for: Regulated data, contractual residency requirements, air-gapped environments, and anything a regulator may ask you to reconstruct.
  • What it costs you: You take on GPU capacity and the operations that come with it, and you give up the top of the frontier reasoning curve. We size both honestly before you commit.

You draw the line.

Which of your workloads belongs on which side is a decision for your risk owner, not for us. The audit produces the list and the evidence.

What never leaves your environment.

In the fully self-hosted posture. This is the section to read closely and quote to whoever signs off on where your data is allowed to be.

Your documents and records.

Retrieval runs against stores in your own accounts. There is no upload step into anything of ours, because there is nothing of ours in the path.

Your embeddings.

The vector index is derived from your documents and is as sensitive as they are, so it is built and served inside your environment rather than in a hosted vector service.

Your prompts and completions.

In the self-hosted posture there is no external provider to send them to and no provider-side retention window to negotiate. The only log is the one you own.

Anything you fine-tune.

Adapters trained on your data are your artefacts, in your registry, under your accounts. They are not pooled, reused for anyone else, or held anywhere we control.

Your keys and your accounts.

Where a frontier API is still in the mix, the credentials are yours and the billing relationship is yours. We do not sit between you and a provider, and we take no margin on your spend.

What we never do.

On any posture, including the convenient ones.

We never train on your data.

Not for our models, not for a shared evaluation set, not anonymised, not aggregated. Your data is used to build your system and for nothing else.

We never route your traffic through infrastructure we own.

There is no Zylen gateway, proxy or router in the path. Everything we build runs in your accounts, which is also why nothing breaks when the engagement ends.

We never say self-hosted means safe.

Self-hosting moves the trust boundary inside your perimeter; it does not remove it. Anyone with production access to the cluster can see what passes through it, so access control and logging are part of the build, not an afterthought.

We never make the residency claim for a hybrid setup.

Where a request reaches a frontier API, the honest claim is redaction before the call plus zero-retention terms — a real control, and a weaker one than in-VPC serving. We will not let the stronger sentence be used for the weaker architecture.

We never tell you that you are compliant.

We build controls and produce the evidence: what is logged, what is redacted, where inference happens, who can reach it. Whether that satisfies GDPR, DPDP, HIPAA or your regulator is a determination for your counsel, not a line in our proposal.

The questions buyers actually ask.

What does “your data does not leave your environment” actually mean?

It means one specific architecture: open-weight models served inside your own VPC or on your own hardware, retrieval running against stores in your accounts, and no third-party inference call anywhere in the request path. That sentence is only true of the fully self-hosted posture, and we only write it there. In a hybrid or frontier-API setup the accurate claim is different and weaker — sensitive fields are redacted before the request leaves and the provider is under zero-retention terms — and we will say that rather than let the stronger phrase be reused for it.

Are open-weight models good enough for the work we would move?

For most of what companies want to keep private, yes: classification, extraction, summarisation, routing, and retrieval-grounded answers over your own documents. Those are exactly the tasks where a well-served mid-size open-weight model is close enough that the difference does not change the decision. Frontier models still win on the hardest multi-step reasoning. We settle it the same way we settle everything else — an evaluation set built from your own cases, scored before anything moves.

What does self-hosting actually cost compared to an API?

It changes the shape of the cost rather than always reducing it. An API is pure variable cost per token. Self-hosting is a mostly fixed cost — reserved or owned GPUs, plus the operations around them — which pays off at sustained volume and is poor value for spiky, low-volume traffic. The audit sizes this on your actual request pattern before you commit to hardware, and where the numbers do not support it we will tell you the private posture is not worth buying yet.

Which models do you run, and who chooses?

You do, on evidence we produce. In practice the shortlist is the current Llama, Mistral and Qwen families, served through vLLM for throughput or Ollama for smaller footprints, with quantisation chosen against your latency and memory budget. We benchmark the candidates on your own evaluation set rather than on public leaderboards, and the whole thing is designed to be swapped: model choice is a config decision, not an architecture rewrite.

How does retrieval work when different people can see different documents?

Permissions are enforced at retrieval, not by asking the model to be discreet. Documents carry their source system's access metadata into the index, the query is filtered by the asking user's entitlements before any candidate reaches the model, and the answer cites what it used so an over-broad result is visible rather than silent. A private model with an unfiltered index is a data leak that happens to be self-hosted.

Does this make us GDPR, DPDP or HIPAA compliant?

We do not make that claim, and you should be wary of anyone who does. What we build are the controls and the evidence: where inference happens, what is redacted before it, what is logged, who can reach the cluster and what they can see. Whether that package satisfies a particular regulation for your particular processing is a determination for your counsel and your DPO. We will sit in that conversation and document the architecture for it; we will not sign off on it.

Do you take our data for training or evaluation?

No. Not for our models, not for a shared benchmark, not anonymised or aggregated. Evaluation sets built during an engagement are built from your data, live in your repository and stay yours. Our engineers work under your access controls, in your accounts, and the handover is designed so that when we leave there is nothing of yours left with us to delete.

If we self-host now, are we stuck with it?

No, and that is a design requirement rather than a reassurance. The gateway speaks one interface to the application, so the model behind it is a routing decision. Moving a workload back to a frontier API, or onto a newer open-weight model, is a config change and a re-run of the evaluation set. Everything is in your repository under your accounts, so none of it depends on us being there.

Find out which workloads could run inside your walls.

Tell us what you are running and what your risk owner has already refused to approve. The audit meters the AI you have, ranks it by cost and exposure, and moves one workload into your own environment so the architecture is a thing you can inspect rather than a diagram.