# AI architecture for technology leaders

An 8-minute guide for CTOs, CIOs and engineering managers on connecting AI to the systems your business runs on, with the guardrails built into the architecture.

Your teams want to connect AI to your product, price and customer data. How do you make sure it can only do what you allow? This guide is for CTOs, CIOs and engineering managers. It shows how we connect AI to the systems your business runs on, with the guardrails built in, and what we have learned from AI that is already live.

## Why this matters now

AI agents are starting to act inside your systems. What they can see and do has to be decided by your architecture, not by a prompt.

### AI agents are starting to act, not just answer.

They book and process work people still do by hand. To do that safely, they need access to the systems behind those decisions, with permissions limited to the minimum.

### The standard offers access without control.

Model Context Protocol, an open standard released in 2024, is widely used to connect AI agents to backend systems. MCP provides the connection. The layer underneath decides what an agent may see and do.

## One governed interface between AI and your systems

Guardrails can only be relied upon when they are built into your systems, not written into a prompt. Our technical approach puts one interface between AI and the systems your business runs on: a federated GraphQL supergraph. Your website, your apps and your AI agents all use the same interface, with the same data and the same permissions.

This is at the centre of how we engineer platforms, and it turns AI safety into an engineering problem you can test. Our guide to [GraphQL and federation](https://www.labdigital.nl/insights/topics/graphql-and-federation) explains the approach in full. For the business side, governance and the questions to ask first, read [AI governance for business leaders](https://www.labdigital.nl/insights/topics/ai).

### One model of your business

Products, prices, stock and customers are defined once, in a typed schema, even when the data comes from several systems. An agent uses the same vocabulary as your website, so it never has to guess your business rules.

### Rules in the platform, not the prompt

The platform recalculates prices, checks promotions and confirms stock before an order goes through, whatever the agent asks for. The agent can read your data and take approved actions, such as creating a shopping list, but it cannot change prices, stock or other master data.

### Tools from approved operations

We generate the tools an agent may use from GraphQL operations a developer has approved. The agent can run those operations and nothing else. A new tool goes through code review and testing like any other change.

### Changes checked before they ship

Every schema change is checked before it is merged. A change that would break the website, an app or an agent is caught in the pull request, not in production.

### Models you can replace

The AI layer sits on top of the graph, not inside it. You can change the model or the provider without rebuilding the tools or the rules. Pick the right model for your use case, and the platform handles the rest.

![Diagram: the website, apps and AI agents all connect to one GraphQL supergraph, which holds the rules: one model of your business, prices and stock checked, tools from approved operations, and changes checked before they ship. AI agents can run approved operations only, and the model can be replaced. The supergraph connects to the systems your business runs on: products, prices, stock and customers.](https://www.labdigital.nl/media/ai-architecture-supergraph-layers.png)

## Three ways to connect AI to your business systems

Most organisations connect AI to their systems in one of three ways. The choice decides where your rules live, and how much work each new AI use case takes.

One governed graph

Vendor MCP servers

One integration per system

What the AI sees

One typed model of your business

Each vendor's own data model

Whatever each integration exposes

Where the rules live

In the platform, enforced for every client

In each vendor's product, or a prompt

Rebuilt in every integration

Adding a new AI tool

Approve an operation that already exists

Wait for the vendor to offer it

Build and secure a new integration

The same answer everywhere

Yes, web, apps and AI share one interface

No, each server has its own view

No, each integration has its own logic

Changing model or provider

Tools and rules stay as they are

Depends on each vendor

Rework every integration

Protocols such as MCP decide how an agent connects to a system. They do not decide what the agent may see or do. That is the job of the layer underneath.

## AI that is live, not a pilot

Libra Energy, part of Rensa Family Group, sells solar and battery equipment to installers. Since summer 2026, an AI agent has turned emailed requests from installers into shopping lists they can purchase.

**Case study**

### AI-assisted order intake at Libra Energy

Installers email their requests for a quote as PDF or Excel files. An AI agent reads each one, matches the lines to the product catalogue and creates a shopping list. An account manager checks the list before the reply goes out. The agent uses the same gateway and permissions as the webshop, so it can do only what the webshop can do.

- **<1 min** to turn an emailed quote into a shopping list, down from ~30 min

[Read the case study](https://www.labdigital.nl/work/libra-energy)

**Open source**

### AI tools generated from the API you already have

We generate the tools an AI agent may use from approved GraphQL operations. The agent can run those operations and nothing else, with the same permissions as any other client. We have open-sourced this generator, so anyone can see how it works.

[Read how it works](https://www.labdigital.nl/blog/generating-mcp-tools-from-graphql-schemas)

![A Lab Digital developer reviews code on a large monitor, with a website design open on his laptop](https://www.labdigital.nl/media/CSpsifJ3K3E3PVWdCxyby-lab-digital-210622-104-98ff3f.jpg)

## How we take AI to production

We have built cloud-native, composable platforms since 2018. That work is what makes AI useful: clean data, clear interfaces and systems with an owner. These are the lessons from the AI we have taken live.

1. Start narrow, on a channel that already has volume, so you can measure the result in weeks, not quarters.
2. Put the trust boundary in the architecture, not in the prompt. The AI can only do what the system allows.
3. Keep a person in the loop where it matters. It makes the system safer, and it helps the people who use it learn to trust it.
4. Run security and governance from the first sprint, including tests for prompt injection and a switch that turns the feature off.

We are not tied to any model provider. We use off-the-shelf models, and build everything around them: the data, the tools, the guardrails and the fallbacks.

## Want to learn more about this?

Talk to one of our colleagues about connecting AI to your systems.

[Get in touch](https://www.labdigital.nl/contact)
