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.

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.
Six controls decide whether an agent's infrastructure change is governed or only allowed:
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.
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:
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."
Run in your terminal to get started locally.
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.
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.
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.

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.
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.
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.
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.
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.
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.