AI platform engineering on OVHcloud: an internal developer platform experiment
Your application is ready. Getting it onto Kubernetes means a Dockerfile, a pipeline, a Deployment, a Service, an Ingress, a NetworkPolicy and a ServiceAccount. Someone picks the resource limits, wires up TLS and sorts out the registry pull secret. Even when your team has deployment standards, someone still applies them by hand to every application.

So can you hand that work to an AI agent? In 2026 we built an internal developer platform on OVHcloud to find out, with an assistant in front of it that turns a repository URL into a merge request someone can read.
This article is the overview: what the developer does, what runs underneath on OVHcloud, and where the assistant stops.
Part 1 of six. Each part stands on its own.
What a developer actually does
The developer gives the assistant a GitLab repository URL. It examines the application and asks for what it cannot work out by itself, such as the resource tier and whether the application needs to be reachable from outside.
It then fills the platform's templates and puts a Dockerfile, a pipeline and the Kubernetes configuration on a separate branch.
What arrives is a merge request. The developer reads the proposed build and deployment settings and decides whether to merge.
Repository and requirements → AI-prepared configuration → Developer review → CI build → Initial GitOps setup
After the merge, the workflow waits for the CI pipeline to pass. The agent then sets up the initial connection to Argo CD, which reconciles the application configuration from Git from that point on.
What had to exist underneath
None of that works without a platform to put the application on, so most of the project went into building one.
The foundation is OVHcloud Managed Kubernetes, defined in Terraform. Around the cluster sit the shared services: GitLab runners to execute builds, Harbor to store container images, Argo CD to manage configuration through GitOps, with monitoring and access configuration alongside them. All of it runs on the same OVHcloud project, on node pools we keep apart on purpose.
Then come the templates, which hold the conventions. Some settings are fixed by the platform, others depend on the application, and the templates make that split explicit so the agent never designs a deployment from scratch.
| Layer | Its role |
|---|---|
| Infrastructure | Provides the OVHcloud Managed Kubernetes environment |
| Shared services | Support builds, image storage, GitOps and platform operations |
| Templates | Capture deployment conventions and application-specific inputs |
| AI interface | Gathers requirements and coordinates onboarding |
Put together, it looks like this.

The whole platform in one picture.
Traffic comes in on the left, through DNS and an OVHcloud load balancer to the ingress controller. The applications themselves sit in their own namespace per onboarding, each running as a non-root pod behind its own service. The CI/CD column is where a commit becomes an image: the GitLab runner starts a builder pod, which pushes to Harbor. On the right are the pieces that keep it honest, with Prometheus and Grafana for monitoring, Let's Encrypt for certificates and GitLab for sign-in. And underneath all of it sit the four node pools, kept apart so a heavy build cannot starve a running application, inside one OVHcloud private network.
What stops the agent from getting it wrong
That is the question everyone asks next, and it is the right one.
Some of the answer is in the templates, which mark the lines the agent may fill in. Some of it is in the permissions its service account has on the cluster. And some of it is the merge request, where a person decides whether anything happens at all.
Those three are not enforced in the same way, and the difference matters more than the AI does. Part 6 goes through it.
Our article on AI in DevOps covers where AI belongs around delivery automation in general. This series is about one specific job: getting an application onto a platform.
What this is, and what it is not
This was a proof of concept on one specific OVHcloud, GitLab and Gemini setup. There are no automated tests, and the AI layer behaves differently from one run to the next. The OVHcloud environment it ran on has since been decommissioned.
What is left is the implementation, and that is worth reading: how we built the platform, how we encoded its conventions, and where we decided a human still has to look. The public repository has all of it.
In part 2 we start at the bottom, with the OVHcloud infrastructure.
The full series
- AI platform engineering on OVHcloud: an internal developer platform experiment
- OVHcloud Managed Kubernetes with Terraform: from state to cluster
- Argo CD app of apps: from an empty cluster to platform services
- Harbor container registry and GitLab CI: from build to Kubernetes
- Golden paths: what should an AI agent be allowed to change?
- Google ADK agents for app onboarding: where human review fits



