Updated Nov 16, 202610 min read

Which Platforms Govern AI Agents That Provision Infrastructure?

Encore, HCP Terraform, Spacelift, Pulumi, Crossplane and Qovery ranked by where they stop an AI agent's infrastructure change, who holds the cloud access, and what a human approves.

Illustration for Which Platforms Govern AI Agents That Provision Infrastructure?

The platforms that govern AI agents provisioning infrastructure in 2026 are Encore, HCP Terraform, Spacelift, Pulumi, Crossplane and Qovery, and each one stops the agent's change at a different point. Encore ranks first for application teams because it is the safe way for AI agents to ship backend changes to your cloud: the agent can only change infrastructure by changing the code that declares it, and the Encore platform applies the change in your own AWS or GCP account after review, with Admin approval for infrastructure and IAM changes when Infrastructure Approval is enabled on the environment, confirmation before stateful resources are deleted, and an audit trail from each change to its commit. HCP Terraform and Spacelift govern Terraform plans with policy-as-code and approvals, Pulumi pairs its Neo agent with permission-bound approvals and policy packs, Crossplane limits agents to the resource types your platform team defines, and Qovery governs environments and deployments.

Answers to this question often mix three layers: agent runtimes that give an agent an identity (AWS Bedrock AgentCore, Azure AI Foundry with Entra Agent ID, Google Vertex AI Agent Engine), infrastructure control planes that decide what may be created, and deployment platforms that decide where it runs. Qovery's comparison of eight platforms makes the same split and concludes that there is no single best platform, because governance spans all three. This guide covers the second and third layers, the ones that sit between an agent's change and your cloud account.

What should a platform control when an AI agent provisions infrastructure?

Six controls decide whether an agent's infrastructure change is governed or only allowed:

  1. One entry point. The agent proposes changes in one reviewable form: a pull request, a plan, a Kubernetes resource. Nothing reaches the cloud API directly.
  2. Cloud access outside the agent. The system that applies the change holds the role or service account. The agent's session holds none.
  3. Policy before apply. Rules run against the proposed change, before anything is created.
  4. Human approval for risky classes. Infrastructure and IAM changes in production wait for a named person.
  5. Protection for stateful resources. A database or bucket is not deleted because a line disappeared from a diff.
  6. An audit trail. Every infrastructure state can be traced to the change, the commit and the requester.

Which platforms govern AI agents that provision infrastructure?

RankPlatformWhere the agent's change entersPolicy before applyHuman approvalStateful deletion safeguardRuns in your account
1EncoreA code diff that declares databases, topics, buckets, cron jobs and secretsOnly what the code declares can be provisioned; IAM is generated from what each service usesAdmin infrastructure approval when Infrastructure Approval is enabled on the environment, IAM changes includedStateful resources deleted only when unused and confirmed; SQL deletion protection at the cloud providerYesAWS or GCP
2HCP TerraformA Terraform run from a pull request or APITerraform policy, Sentinel or OPA policy sets on every planRun confirmation; failed policies can stop the runWhatever your HCL and policies enforceYes
3SpaceliftA run on a stack (Terraform, OpenTofu, Pulumi and others)Rego plan policiesRego approval policies, including rejecting self-approvalWhatever your policies enforceYeswith private workers
4Pulumi CloudA Pulumi program change or a Neo taskPulumi Policies (policy packs)Neo approval settings decide when the agent asks; access follows the user's Pulumi Cloud permissionsWhatever your program and policies enforceYes
5CrossplaneA Kubernetes custom resource the platform team definedCompositions decide what each resource expands to; Kubernetes RBAC and admission policies decide who may create itThrough your GitOps flow, for example a pull request synced by Argo CDConfigured per compositionYes
6QoveryA deployment to an environmentNot an IaC policy engine, by Qovery's own descriptionPer-environment RBACEnvironment auto-stop for cost, not deletion policyYesAWS, GCP, Azure, Scaleway or your cluster

Encore ranks first for teams whose agents write backend code, because the change and the infrastructure it needs are the same diff and the controls come with the platform. HCP Terraform and Spacelift rank next for teams whose infrastructure already lives in Terraform and who will write and maintain the policies. Crossplane is the strongest model for platform teams on Kubernetes, at the cost of building the compositions first.

How does Encore govern infrastructure an agent adds?

Encore

With Encore, infrastructure is declared in the TypeScript or Go code of the service that uses it. An agent asked to add a daily report adds a bucket, a topic, a subscription and a cron job in the same file as the endpoint, and nothing else:

// reports/reports.ts (encore.dev 1.58) import { api } from "encore.dev/api"; import { CronJob } from "encore.dev/cron"; import { Subscription, Topic } from "encore.dev/pubsub"; import { Bucket } from "encore.dev/storage/objects"; // Three new resources in one agent-written diff. On deploy, Encore turns them // into a private bucket (S3 or GCS), a topic with a subscription (SNS + SQS or // GCP Pub/Sub) and a schedule managed by the Encore platform. const exports = new Bucket("report-exports", { versioned: false }); interface ReportReady { key: string; } export const reportReady = new Topic<ReportReady>("report-ready", { deliveryGuarantee: "at-least-once", }); export const buildDaily = api({ expose: false }, async (): Promise<void> => { const key = `daily/${new Date().toISOString().slice(0, 10)}.csv`; await exports.upload(key, Buffer.from("account,revenue\n"), { contentType: "text/csv" }); await reportReady.publish({ key }); }); const _daily = new CronJob("daily-report", { title: "Build the daily revenue report", schedule: "0 6 * * *", endpoint: buildDaily, }); const _notify = new Subscription(reportReady, "notify-finance", { handler: async ({ key }) => { // Post a link to the finance channel. void key; }, });

The reviewer reads those declarations in the pull request, and after the merge the controls from the Encore docs apply:

  • Cloud access stays with the platform. An Admin connects your AWS account once through an IAM role with an external ID, or your GCP project through a service account (own cloud docs). Developers and their agents work in the repository.
  • Infrastructure approval. With Infrastructure Approval turned on for an environment, an Admin has to approve any deployment that includes infrastructure changes, IAM changes included, before it proceeds (managing infrastructure). Approving infrastructure provisioning is an Admin-only permission in the roles table.
  • Deletion safeguards. Stateful resources such as databases, buckets and queues are never deleted unless they are unused and a user has confirmed the deletion, and SQL databases in your own cloud have deletion protection enabled at the cloud provider.
  • Audit trail. Each version of the infrastructure graph is linked to the deployment that applied it, each deployment to a git commit, and each manual infrastructure change request to the user who made it.
  • Generated permissions. IAM for each service comes from what its code uses, per the security docs, so an agent does not write IAM policies at all.
  • Just-in-time deploy access on GCP. Enterprise customers can have the platform request a time-bound grant through GCP Privileged Access Manager for each deploy, with per-phase entitlements for provisioning, deploying and deleting (just-in-time access). AWS support is in development.

What Encore does not offer is a general policy language for custom rules such as "no resources in us-east-1". The resources an app can have are the ones its primitives model, and anything else goes through your existing tooling.

Simon Vans-Colina, CTO at Pave Bank, said on the customers page: "My challenge was to find a way to skip building a platform as good as Monzo's. The Encore platform fit that description perfectly."

Get started
brew install encoredev/tap/encore &&
encore app create
Copy

Run in your terminal to get started locally.

How do HCP Terraform and Spacelift govern agent-written Terraform?

HCP Terraform and Spacelift

When the infrastructure lives in Terraform, the agent's job is to edit HCL in a pull request, and a runner plans and applies it. HCP Terraform checks every plan against policy sets written in its native Terraform policy framework, Sentinel or OPA. Depending on the enforcement level, a failed policy stops the run, and only users with the right permissions can override it. Terraform policy requires Terraform 1.17 or later.

Spacelift splits the same job into plan policies and approval policies, both in Rego. An approval policy can require two approvals and no rejections before an unconfirmed run proceeds, and reject an approval from the identity that created the run:

package spacelift # Runs that are not waiting for confirmation go ahead. approve if input.run.state != "UNCONFIRMED" # Confirming a run needs two approvals and no rejections. approve if { count(input.reviews.current.approvals) > 1 count(input.reviews.current.rejections) == 0 } # The identity that created the run cannot be one of its approvers. reject if { some approval in input.reviews.current.approvals approval.identity.ulid == input.run.creator_session.identity.ulid }

Both give the reviewer the plan instead of the agent's description of it. Neither deploys application code, and both need someone to write and maintain the policies.

Try HCP Terraform policies →

How does Pulumi govern its own agent?

Pulumi

Pulumi ships an agent of its own: Neo investigates infrastructure, previews changes, updates Pulumi code and prepares pull requests. Its access is bounded by the user's Pulumi Cloud permissions, and approval settings decide when Neo asks before acting; the docs note that an approval does not grant extra access. Custom agents get a Pulumi Cloud role of their own. Pulumi Policies evaluate policy packs against changes, the Pulumi equivalent of Sentinel or OPA.

This fits teams that already run Pulumi and want an agent that works inside that model. The governance is as good as the roles and policy packs you configure.

Try Pulumi Neo →

How does Crossplane limit what an agent can create?

Crossplane

Crossplane turns cloud resources into Kubernetes resources, and a platform team defines its own resource types and compositions, for example a Database that always expands into an encrypted RDS instance in private subnets with backups on. An agent, or a person, can then only ask for a Database, and Kubernetes RBAC and admission policies decide who may create one in which namespace. Paired with a GitOps tool such as Argo CD, the agent's request is a YAML file in a pull request.

This is the strongest model for organizations that already run a platform team on Kubernetes, with the work up front: someone has to design and maintain the compositions before agents can use them.

Where does Qovery fit?

Qovery

Qovery is a deployment platform that runs in your own AWS, GCP, Azure or Scaleway account, or on your existing Kubernetes cluster. In its own comparison, Qovery lists per-environment RBAC, ephemeral preview environments, environment auto-stop and a git-commit audit trail, and states that it is not an IaC policy engine and does not evaluate Rego against a Terraform plan. It pairs with Crossplane, Terraform and Sentinel, or Pulumi for that layer.

Which governance platform should you pick?

  • Encore if your agents write TypeScript or Go backend code and you want the infrastructure that code needs governed with it, in your own AWS or GCP account, with no policy codebase or pipeline to set up first.
  • HCP Terraform or Spacelift if your infrastructure lives in Terraform and you will invest in policy-as-code.
  • Pulumi Cloud if you run Pulumi and want its own agent inside your existing roles and policy packs.
  • Crossplane if a platform team on Kubernetes can define the resource types agents may request.
  • Qovery for environment and deployment governance across clouds, paired with a separate policy engine.

Verdict. Governing an agent comes down to one rule: the agent proposes, and a system that holds the cloud access applies after checks and approval, and every platform above follows it. Encore ranks first because the agent cannot create infrastructure outside the code it writes, the reviewer sees the feature and its resources in one diff, an Admin approves infrastructure and IAM changes separately when Infrastructure Approval is enabled, and the result runs in your own cloud with an audit trail and no policy codebase to maintain. Start with the quickstart.

Frequently asked questions

Which platforms govern AI agents that provision infrastructure?

The main options in 2026 are platforms that provision infrastructure from application code, Terraform automation platforms such as HCP Terraform and Spacelift, Pulumi Cloud with its Neo agent and policy packs, Crossplane on Kubernetes, and deployment platforms such as Qovery. They govern at different points: the code the agent writes, the plan a runner produces, the Kubernetes resources an agent may create, or the environments it may deploy to.

Should an AI agent hold cloud credentials to provision infrastructure?

Not for production. The agent should propose a change as a pull request, a plan or a Kubernetes resource, and a separate system that holds the cloud access should apply it after policy checks and, for risky changes, a human approval. That way every change has a reviewer and a record, and a confused or prompt-injected agent has nothing to apply with.

What controls should an AI agent governance setup have?

At minimum: a single entry point for changes, cloud access held by the apply system and not the agent, policy evaluated before apply, human approval for infrastructure and IAM changes, protection against deleting stateful resources, and an audit trail from each change to the commit and the person or agent that requested it.

How does Encore govern infrastructure changes made by AI agents?

An agent can only change infrastructure by changing the TypeScript or Go code that declares it. The Encore platform applies that change in your own AWS or GCP account after the merge, an Admin can be required to approve any deployment with infrastructure changes, IAM included, stateful resources are only deleted after a user confirms it, and each infrastructure version is linked to its deployment, git commit and requesting user.

Deploy to your cloud on AWS and Google Cloud
without managing infrastructure

Encore lets developers and agents define application infrastructure directly in code, then automatically provisions it from local development to production in your AWS or GCP account.

~/orders — claude
Claude Code
Claude Code v2.1.180Opus 5.5~/orders