01. Confidential data on a general-purpose route
Contract terms, design files and personnel data travel the same path as marketing copy, because nobody decided otherwise.
Where a generative model runs decides which data it may see, what it costs and what happens when it fails. Most companies need more than one pattern. We help you choose one per use case, starting from the data involved and the rules of your industry.
One API key, one provider, and every new use case routed through it. That works until the contract team wants to analyse supplier agreements, the plant wants an assistant on the line, or the provider retires the model your processes were tested against. A deliberate deployment pattern separates use cases by what they need before the exceptions pile up.
Contract terms, design files and personnel data travel the same path as marketing copy, because nobody decided otherwise.
Price changes, rate limits and model retirements arrive on the provider's schedule, and each one touches every process built on that model.
An assistant on the line or a model on a drone stops working when the connection does. In an office that is an inconvenience. In the field it can be a safety issue.
The deployment decision belongs to each use case. Made once for the whole company, it is wrong for most of them.
Every request goes to a hosted model, and a gateway you control decides which provider serves it. You get the strongest models on the market, pay per use, and move to a better or cheaper one when it appears. Nothing runs on your own hardware.
Every prompt, and every document retrieved to answer it, goes to a third party. Contracts and data processing agreements cover much of the risk. Choosing an EU region decides where the data centre stands. It does not change which country's law the provider answers to.
Providers retire model versions, change prices and adjust rate limits on their own schedule. Each forced migration means re-testing every use case built on that model.
A prompt rarely behaves the same way on a different model, so each provider needs its own evaluation, security review and contract. A gateway that hides the differences also hides the features only one provider offers.
Per-token pricing is cheap in a pilot and becomes a budget line at company scale, especially for agentic workflows that make many model calls per task.
Latency depends on the network and on the provider's load, and nothing works offline. That is acceptable for drafting and research. On the line or in the field it is not.
The company owns the full stack: one gateway, one identity and policy layer, one retrieval index and one place for logs. Behind it, each application may use specific routes. Marketing drafts can go to any approved cloud model. Contract analysis goes only to a model in an EU region under your own contract, and export-controlled design data only to open-weight models on your own servers.
Gateway, policy, retrieval, model serving and monitoring add up to a product with an owner, an on-call rota and a budget. Without a permanent owner it falls behind quickly, because models, libraries and threats keep moving.
If documents are not classified correctly where the request is routed, restricted data takes the cloud route. Many hybrid projects turn out to be data classification projects first.
Open-weight models on your own servers handle many routine tasks well, but on the hardest reasoning tasks they can still trail the best hosted models. The same assistant may answer differently depending on the route a request took, and users notice.
Self-hosted capacity is sized for the peak and paid for around the clock. Whether owning hardware beats per-token pricing depends on how busy you can keep it.
Evaluation, security hardening, incident response and model updates have to work on the cloud routes and on your own servers, through two different mechanisms.
Models change more often than anything else in the stack, so they sit at the bottom and stay replaceable. The layers above them belong to you and stay in place when a model is swapped.
Applications talk to one internal endpoint. Provider keys, quotas and fallbacks live there, in a single place you can audit.
Who may use which application, with which data, on which route. The rules come from your existing roles and are enforced at the gateway instead of in each application.
Each request carries the classification of the data in it, and the gateway sends it only to routes approved for that class.
Documents are indexed on your infrastructure. Only the passages a request needs travel onward, on a route their class allows.
Contracted cloud models and open-weight models on your own GPUs sit behind the same interface, so an application does not need to know which one answered.
A fixed evaluation set per use case, run on every route and after every model change, with logs that let you reconstruct any answer later.
The model runs on the drone, in the vehicle or beside the production line, with no network in the loop. This pattern is for cases where a link cannot be relied on, the data must not leave the device, or the answer has to arrive within a fixed time. At the edge, generative models describe, summarise, explain and suggest. Deterministic, certified components make the decisions that move hardware.
Power, heat, weight and unit cost limit you to a small, quantised model. It handles constrained tasks well, such as describing a scene, explaining an error code or extracting fields. Open-ended reasoning over long documents belongs on a server.
A generative model's output is probabilistic. It can inform an operator or a mission system, but safety-relevant actions stay with deterministic logic and certified components, and that boundary has to be designed and tested.
A model on forty line PCs or a fleet of drones changes through a release process with staged rollout and rollback, often without network access and inside segmented OT networks such as IEC 62443 zones.
A downed drone or a stolen unit carries the model and any data stored on it. Encrypted storage and secure boot are the minimum, and the design should assume that the model can be extracted.
Airworthiness, functional safety and defense programmes fix hardware and software versions for years, while generative models change every few months. Assurance methods for learned components are still being written.
Edge covers several different places, and each one gets a different kind of model. Generative models rarely run on the sensor itself. They sit one step further along, where there is enough power to run them.
Smart cameras, vibration and acoustic sensors run filtering, detection and compression within a power budget of a few watts. That is classical perception rather than generative AI, and it decides what the generative model further along gets to see.
Drones, vehicles, vessels and satellites carry an embedded module that can run a small vision-language model. It describes what the sensors see, flags what matters, and sends results instead of raw footage when the link is thin or jammed.
An industrial PC or a small server in the plant's OT network runs an assistant for operators and maintenance staff. It explains fault codes, finds the right step in the manual and drafts the shift report, and the production data never leaves the site.
The bars show how well each pattern does on each dimension. Read them against your use case: a weakness that does not matter for it is no reason to rule a pattern out.
| Dimension | Cloud, multi-provider Hosted models, one gateway | Hybrid, own stack Routes by data class | Edge On the device or beside the line |
|---|---|---|---|
| Model capability | Strong The strongest models on the market, chosen per task | Workable Hosted models for open data, open-weight models for restricted data | Weak Small, quantised models sized to the power budget |
| Data control | Weak Contracts and region settings, but the data leaves your infrastructure | Workable Restricted data stays inside, provided the classification is right | Strong Raw data never leaves the device or the site |
| Offline operation and latency | Weak Needs a link, and latency varies with network and provider load | Workable On-site routes keep working when the internet link drops | Strong Works without any link, with predictable response times |
| Upfront investment | Strong Integration work only | Weak GPU servers, the platform build and a team to run it | Weak Hardware per unit, enclosures, and certification where required |
| Cost at high volume | Weak Grows with every call, and agentic workflows multiply the calls | Workable Cheaper per request while the GPUs stay busy | Workable Little cost per answer once fielded. The fleet hardware is the cost |
| Operating effort | Strong The provider runs the infrastructure. You run evaluation and contracts | Weak A platform team with an on-call rota | Weak Fleet updates, rollback and monitoring without a link home |
| Switching models | Workable Easy with a gateway and evaluation sets, hard without them | Strong Open-weight models behind your own gateway can be swapped at will | Weak Each change needs revalidation on the target hardware |
| Pace of improvement | Strong New models arrive without any hardware change | Workable New open-weight releases need testing, and sometimes new GPUs | Weak Fixed by hardware and certification for years |
The ratings describe typical setups. A specific provider contract, an air-gapped site or a certification regime can move a cell by a full step.
Most companies end up with one primary pattern and one or two others for specific use cases. This is where we usually see the weight fall in the industries we work in.
| Industry | Cloud, multi-provider | Hybrid, own stack | Edge |
|---|---|---|---|
| Marketing & content | Primary The strongest text, image and video models, with brand and rights rules enforced in the workflow | Limited role A controlled route for customer data and unreleased campaigns | Rarely fits Rarely a use case |
| Procurement | Selective Market research, supplier screening and drafting on non-confidential data | Primary Contracts, price structures and negotiation positions on EU-hosted or own models | Rarely fits Rarely a use case |
| Manufacturing | Limited role Office work and drafting on non-sensitive data | Primary Design data, process parameters and quality records inside the company stack | Selective Line-side assistants and inspection explanations inside the OT network |
| Energy & critical infrastructure | Limited role Office and other non-operational work | Primary Operational data on own infrastructure, in line with KRITIS and NIS2 obligations | Selective Substations and remote assets that must keep working through outages |
| Aerospace & Defense | Rarely fits At most for unclassified administration | Selective An air-gapped, on-premise stack for classified and export-controlled work | Primary Drones, vehicles and field systems that operate without a link |
| Remote sensing | Selective Archive-scale analysis of unrestricted imagery | Selective Ground-segment processing for restricted customers and data | Selective Onboard triage that sends results instead of raw scenes |
Hybrid here includes fully on-premise and air-gapped setups: one stack you own, with the cloud routes switched off.
Answer them for each use case separately. The first two settle most cases on their own.
What is the most sensitive data the use case will ever see, including documents pulled in to answer a question? That class sets the strictest route allowed, whatever the rest of the traffic looks like.
Does anything break when there is no link? If the answer has to arrive on a drone, a vessel or a production line during an outage, the model belongs on the device or on the site.
Which rules apply to the data and the use case? Export control, classified work, KRITIS and NIS2, works council agreements and the EU AI Act each restrict different things. The AI Act's obligations follow the use case and its risk class, whichever pattern you choose.
How much capability does the task need? Drafting, extraction and classification work on smaller models. Hard reasoning over long documents may need a frontier model, and that rules some routes out.
What does the use case cost at full volume? Multiply calls per task by tasks per day before comparing per-token pricing with GPUs you would have to keep busy.
How would you leave? Name the second provider or the open-weight fallback now, and keep the evaluation set that proves the switch works.
Deployment pattern review
Two to three weeks. You bring the use cases, the data they touch and the constraints you already know about.
Every current and planned generative AI use case, with the most sensitive data it touches, its volume, and what happens when it is unavailable.
Each use case assigned to a pattern with the reason written down, including the ones that should stay exactly where they are.
Gateway, routing rules, data classes, and the on-premise or edge capacity the placement actually requires, with cost scenarios for each.
A second provider or open-weight fallback for each route, the evaluation sets that prove a switch works, and the order in which to build.
Where generative AI creates measurable value, which comes before the question of where it runs.
Device classes, deployment tiers and build-or-buy for the hardware under the edge pattern.
What changes when the model behind a route can take actions as well as answer.
The evaluation sets that make switching a provider or a route a routine change.
The engagement that turns the pattern decision into a target architecture and a rollout plan.
Shortlisting the providers behind each route on evidence from your own cases.
You bring the use cases, the data they touch and the constraints you know about. You get each use case placed in a pattern with the reason stated, a target stack, cost scenarios, and an exit route for every provider.
Book a Strategy & Architecture ReviewDiese Seite gibt es auch auf Deutsch.