# Pulumi

Infrastructure as Code for AWS, Azure, Google Cloud, including Kubernetes, Serverless, Containers, for Developers and DevOps.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Everything after code, as code

DevFeed: [Everything after code, as code](<https://devfeed.tech/articles/everything-after-code-as-code-140948.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/everything-after-code-as-code/>)

Author: Joe Duffy

Published: 2026-11-18T13:30:00Z

Content type: release

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [CI/CD](<https://devfeed.tech/topics/cicd.md>), [pulumi](<https://devfeed.tech/topics/pulumi.md>), [Continuous Delivery (CD)](<https://devfeed.tech/topics/continuous-delivery.md>), [Production Engineering](<https://devfeed.tech/topics/production-engineering.md>), [policy-as-code](<https://devfeed.tech/topics/policy-as-code.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [Git](<https://devfeed.tech/topics/git.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [agentic-sdlc](<https://devfeed.tech/tags/agentic-sdlc.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [bottleneck](<https://devfeed.tech/tags/bottleneck.md>), [ci](<https://devfeed.tech/tags/ci.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [codex](<https://devfeed.tech/tags/codex.md>), [coding](<https://devfeed.tech/tags/coding.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [continuous-delivery](<https://devfeed.tech/tags/continuous-delivery.md>), [delivery](<https://devfeed.tech/tags/delivery.md>), [frontier](<https://devfeed.tech/tags/frontier.md>), [git](<https://devfeed.tech/tags/git.md>), [merge](<https://devfeed.tech/tags/merge.md>), [model](<https://devfeed.tech/tags/model.md>), [product](<https://devfeed.tech/tags/product.md>), [product-launches](<https://devfeed.tech/tags/product-launches.md>), [pulumi-cloud](<https://devfeed.tech/tags/pulumi-cloud.md>)

### AI overview

Pulumi introduces two public-preview products to extend agentic workflows beyond code merge. Pulumi Delivery defines release pipelines as code in TypeScript, Python, HCL, Go, C#, Java, or YAML, with stages, gates, approvals, policy, secrets, and support for existing tools including Pulumi, Terraform, OpenTofu, and Ansible; it works alongside existing CI for build and test. Pulumi Agents monitor systems through events from PagerDuty, Datadog, Sentry, and Honeycomb or scheduled runs, using provided or custom agents. Agents have separate identities, least-privilege roles, and short-lived credentials, and submit proposed production changes as pull requests with deterministic plans checked against existing policies rather than changing production directly. Together, pipelines can promote low-risk changes automatically while routing riskier ones to human approval, and agent fixes return through the same gated release process. Both products are available in public preview in every Pulumi Cloud edition, including Free.

### Source excerpt

Introducing Pulumi Delivery and Pulumi Agents: agentic code to production, and back again. At Pulumi, we like code. A lot. And we aren't the only ones: agents like it too. This year, the share of infrastructure operations on Pulumi done by agents went from zero in January to over 40% in October. Anything expressed as code (infrastructure, policy, configuration) is something an agent can work on. Today we're extending that to everything after the merge with two launches: Pulumi Delivery, which lets you and your agents write delivery pipelines as code, and Pulumi Agents, customizable agents that watch your running systems and act when something goes wrong. Together, they take agentic code to production, and back again. I honestly can't remember a launch since Pulumi 1.0 that our customers and team have been this excited about. TypeSafe AI bet on Pulumi to scale Jev, their decision model, to over a trillion tokens per day using the engineering practices they already had. What happens after the merge Frontier labs have made huge advances in agentic coding, code review, and everything up to the merge. Claude Code, Codex, and friends now write and test a growing share of the code we ship, and the labs felt it first. Anthropic's monorepo went from about 2,500 merges a day in May to over 30,000 by September. At OpenAI, where one engineer now has several changes ready for CI at once, Git reliability at times fell below 90% under the load. Both rebuilt source control to keep up. And then it all stops at the pull request. Everything after the merge (provisioning, configuration, secrets, policy, and delivery) still runs on scripts, tickets, and waiting. Today's SDLC was designed for human hands working at human speed, and it has become the bottleneck. An agentic SDLC needs agentic delivery, too. We set out to answer a few questions. How does code get to production, and which gates does it pass through? Which of those gates need a human, and which can an agent handle? When somet

## Introducing Pulumi Delivery: your release pipeline as code

DevFeed: [Introducing Pulumi Delivery: your release pipeline as code](<https://devfeed.tech/articles/introducing-pulumi-delivery-your-release-pipeline-as-code-140950.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/introducing-pulumi-delivery/>)

Author: Daniel Perlovsky

Published: 2026-11-18T13:00:00Z

Content type: release

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Continuous Delivery (CD)](<https://devfeed.tech/topics/continuous-delivery.md>), [CI/CD Pipeline](<https://devfeed.tech/topics/ci-cd-pipeline.md>), [pulumi](<https://devfeed.tech/topics/pulumi.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [blue-green deployment](<https://devfeed.tech/topics/blue-green-deployment.md>)

Tags: [after](<https://devfeed.tech/tags/after.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [application](<https://devfeed.tech/tags/application.md>), [bottleneck](<https://devfeed.tech/tags/bottleneck.md>), [change](<https://devfeed.tech/tags/change.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [config](<https://devfeed.tech/tags/config.md>), [console](<https://devfeed.tech/tags/console.md>), [context](<https://devfeed.tech/tags/context.md>), [continuous-delivery](<https://devfeed.tech/tags/continuous-delivery.md>), [database](<https://devfeed.tech/tags/database.md>), [delivery](<https://devfeed.tech/tags/delivery.md>), [deploy](<https://devfeed.tech/tags/deploy.md>), [dev](<https://devfeed.tech/tags/dev.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [product](<https://devfeed.tech/tags/product.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [pulumi-cloud](<https://devfeed.tech/tags/pulumi-cloud.md>), [release](<https://devfeed.tech/tags/release.md>), [releases](<https://devfeed.tech/tags/releases.md>)

### AI overview

Pulumi Delivery, in public preview, defines release pipelines as Pulumi programs in languages including TypeScript, Python, Go, HCL, and YAML. A program declares source repositories, release stages, stacks, and gates; Pulumi Cloud runs stages in order. The example triggers on pushes to GitHub main, deploys network and app stacks through dev, staging, and prod, and requires approval before production. Releases are pinned to a commit, keeping the staging-tested code consistent through production. Delivery infers stack update order from infrastructure dependencies and updates independent stacks concurrently, while teams define environment stages and may manually order stacks. Pipelines can include reusable rollout logic, AI risk review that promotes or escalates changes, and thresholds based on decision-model risk scores. Observability signals from PagerDuty, Honeycomb, Sentry, or Datadog can prompt an agent to open a fix pull request, which then follows the governed pipeline. The excerpt states availability in Pulumi Cloud Free, Essentials, Pro, and Enterprise editions.

### Source excerpt

Coding agents have made writing software faster than shipping it. The bottleneck is now everything after the code: release pipelines full of bespoke scripts, console steps, and hand-run promotions that slow teams down and don't scale. Today, we're introducing Pulumi Delivery, available in public preview. With Delivery, you define how a change moves from development through staging to production in the same languages you already use for infrastructure: TypeScript, Python, Go, HCL, YAML, and more. Your pipeline becomes a Pulumi program, so it gets the same policies and review process as the rest of your infrastructure, whether a person or an agent wrote the change. The new bottleneck Most applications span many infrastructure stacks. For example, your service may have separate stacks per environment for its networking layer, database, and application code, and they need to be deployed in the correct order. Today, that ordering and the rest of your delivery logic live in standalone pipeline files and manual console steps. Those tools run separately from your infrastructure, your secrets, and your policies, so the rules you enforce on a stack often don't apply to the pipeline that deploys it. Reusing logic across services usually means copying YAML, and testing a pipeline usually means running it and watching. Agents make that gap wider. They're fluent in code, but the context needed to promote a release is scattered across consoles and config files they can't see or access. Delivery puts your release pipeline in the same code your agents already work in, so you can ship as fast as they write. Your delivery pipeline, as code A Delivery pipeline is a Pulumi program. In it, you declare the repositories you deploy from, the stages a release moves through, the stacks each stage updates, and the gates that hold a release. Pulumi Cloud then runs each release through those stages in order. Here's a pipeline that deploys a shop app from dev through staging to prod, and waits fo

## Introducing Pulumi Agents

DevFeed: [Introducing Pulumi Agents](<https://devfeed.tech/articles/introducing-pulumi-agents-140949.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/introducing-pulumi-agents/>)

Author: Pulumi AI Team

Published: 2026-11-18T12:00:00Z

Content type: release

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [pulumi-neo](<https://devfeed.tech/topics/pulumi-neo.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [pulumi](<https://devfeed.tech/topics/pulumi.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-infrastructure](<https://devfeed.tech/tags/agentic-infrastructure.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [alerts](<https://devfeed.tech/tags/alerts.md>), [api](<https://devfeed.tech/tags/api.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-infrastructure](<https://devfeed.tech/tags/cloud-infrastructure.md>), [code](<https://devfeed.tech/tags/code.md>), [confluence](<https://devfeed.tech/tags/confluence.md>), [context](<https://devfeed.tech/tags/context.md>), [data](<https://devfeed.tech/tags/data.md>), [datadog](<https://devfeed.tech/tags/datadog.md>), [decision](<https://devfeed.tech/tags/decision.md>), [define](<https://devfeed.tech/tags/define.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [dependency](<https://devfeed.tech/tags/dependency.md>), [diagnosis](<https://devfeed.tech/tags/diagnosis.md>), [product](<https://devfeed.tech/tags/product.md>), [product-launches](<https://devfeed.tech/tags/product-launches.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>)

### AI overview

Pulumi Agents run in Pulumi Cloud to investigate incidents, plan infrastructure changes, and perform maintenance, then prepare findings or pull requests for team review. They combine infrastructure code, resource state, update history, and authorized connected sources; for incident work, they can consult runbooks, query logs and metrics, and use Pulumi's Context API to examine resource and stack dependencies. Tasks can be started manually, by events such as drift or failed updates, through integrations for Datadog, Honeycomb, and PagerDuty, via webhooks, or on a schedule. Agent instructions, integrations, and roles can be defined in code and reviewed before changes apply. Each agent has its own Pulumi Cloud role; connected-system credentials separately govern access, and task requests must be permitted for both the teammate and the agent. In Pulumi Delivery pipelines, agents can assess proposed changes against defined risk criteria and return structured results that pipeline rules use to require human approval. Teams can configure agents using a coding agent or the Pulumi Cloud console.

### Source excerpt

It's hard to overstate how much AI agents have changed the way we make software. When it comes to managing your cloud infrastructure, though, we're still very much in the early days. This is why we're excited to announce Pulumi Agents, your agentic infrastructure team. Pulumi Agents are digital teammates that assist with incident investigation, program and resource planning, or proactive infrastructure maintenance. The user experience with Pulumi Agents will feel familiar to anyone who has used agents before: you define the goal or tasks an agent performs, the constraints it must respect, and its permissions. Pulumi then runs the agent in the cloud, where it works with your existing infrastructure and connected tools to prepare findings and pull requests for your team to review. Delegate infrastructure work To carry out a task, agents combine infrastructure code, recorded resource state, and update history with data from connected systems. They can retrieve the runbooks and engineering standards your team keeps in Confluence, Notion, or GitHub, through connections authorized to read them. During an incident, an agent can consult those runbooks, query logs and metrics, and use Pulumi's Context API to examine dependencies between resources and stacks as it prepares a diagnosis or proposed fix. Authorized teammates can collaborate with the agent on the same task through Pulumi Cloud or Slack. The agent can ask for information or a decision, and teammates can ask it to explain a finding or revise its proposal. Tasks can start on request, in response to events, or on a schedule. Pulumi includes trigger setup for Datadog monitor alerts, Honeycomb triggers, and PagerDuty incidents, plus generic webhooks for other systems. Pulumi events, such as detected drift or failed updates, can also start tasks, and schedules can kick off recurring work such as dependency reviews. Define each agent's responsibility and access You can define agents in code, keeping their instructions, i

## Policy exceptions: enforce every policy, document every exception

DevFeed: [Policy exceptions: enforce every policy, document every exception](<https://devfeed.tech/articles/policy-exceptions-enforce-every-policy-document-every-exception-129258.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/policy-exceptions/>)

Author: Alejandro Cotroneo

Published: 2026-11-09T00:00:00Z

Content type: article

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [pulumi](<https://devfeed.tech/topics/pulumi.md>), [policy-as-code](<https://devfeed.tech/topics/policy-as-code.md>), [DevSecOps](<https://devfeed.tech/topics/devsecops.md>), [Access Control](<https://devfeed.tech/topics/access-control.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [blocks](<https://devfeed.tech/tags/blocks.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [compliance](<https://devfeed.tech/tags/compliance.md>), [exception](<https://devfeed.tech/tags/exception.md>), [exceptions](<https://devfeed.tech/tags/exceptions.md>), [features](<https://devfeed.tech/tags/features.md>), [governance](<https://devfeed.tech/tags/governance.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [log](<https://devfeed.tech/tags/log.md>), [maintenance](<https://devfeed.tech/tags/maintenance.md>), [mandatory](<https://devfeed.tech/tags/mandatory.md>), [needs](<https://devfeed.tech/tags/needs.md>), [policies](<https://devfeed.tech/tags/policies.md>), [policy](<https://devfeed.tech/tags/policy.md>), [policy-as-code](<https://devfeed.tech/tags/policy-as-code.md>), [policy-exceptions](<https://devfeed.tech/tags/policy-exceptions.md>), [preview](<https://devfeed.tech/tags/preview.md>), [product](<https://devfeed.tech/tags/product.md>), [production](<https://devfeed.tech/tags/production.md>), [public](<https://devfeed.tech/tags/public.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [pulumi-cloud](<https://devfeed.tech/tags/pulumi-cloud.md>), [resource](<https://devfeed.tech/tags/resource.md>), [resources](<https://devfeed.tech/tags/resources.md>)

### AI overview

Pulumi policy exceptions let teams enforce mandatory policies while exempting specified resources from specified policies. Other resources and policies remain enforced, and exempted violations still appear in results. Each exception records its reason, requester, scope, approvals and expiry; creation and removal are logged, and expired or removed exceptions remain accessible. Developers can request exceptions through Pulumi Cloud or an experimental CLI command. Organizations can allow audited self-service or require designated approvals; exceptions take effect on the next run after any required approval. The guidance recommends first auditing policies when existing violations are unknown, then making them mandatory and choosing approval based on expected exception volume or policy sensitivity. Local policy pack configuration is supported with any backend. Pulumi Cloud support requires CLI v3.274.1 or later; older versions may report violations without applying exceptions. The feature is in public preview on Essentials, Pro and Enterprise; approval requirements need Pro or Enterprise.

### Source excerpt

Policy exceptions in Pulumi Policies let you keep a policy mandatory while letting specific resources break it for a valid reason. Each exception identifies the resources and policies it applies to, and records who created it and why. You can require approval before it takes effect and set an expiry date so it doesn't last forever. Everything the exception doesn't cover must still comply. Why do mandatory policies stall? An advisory policy only warns. A mandatory policy blocks pulumi preview or pulumi up before a public bucket or an open security group reaches production. That difference matters more as coding agents build more of your infrastructure: agents make changes faster than people can review them, and a warning gets lost in a long preview. A mandatory policy forbids the misconfiguration entirely, so the code must comply before any change is applied, whether a developer or an agent wrote it. Many users struggle with updating their policies from advisory to mandatory. The new required policy applies to every stack, including resources created before the policy existed. Some violations are intentional: a static website bucket needs to be public, and a log bucket needs to allow the log delivery group. The policy is still correct, but it needs a few known exceptions. Without ways to handle edge cases, some users run into these situations: Leaving the policy advisory or disabled. Nothing is blocked, so nothing is prevented. Turning off the policy for a few stacks. A copied policy group with one rule disabled exempts every resource in those stacks, not only the one that needs it, and the copies multiply. Excluding resources in the policy configuration. This is more precise, but the exclusion lists spread across packs and policy groups and quickly become a maintenance burden. In each case, the reason a policy was skipped ends up in a chat thread, a ticket, or someone's memory, where it's hard to trace back to the resource. What changes with policy exceptions? Manda

## Pulumi at KubeCon NA 2026: attendee guide

DevFeed: [Pulumi at KubeCon NA 2026: attendee guide](<https://devfeed.tech/articles/pulumi-at-kubecon-na-2026-attendee-guide-122085.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/pulumi-at-kubecon-na-2026/>)

Author: Traci Myers

Published: 2026-11-06T00:00:00Z

Content type: article

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [pulumi](<https://devfeed.tech/topics/pulumi.md>), [Infrastructure as code](<https://devfeed.tech/topics/infrastructure-as-code.md>), [internal developer platform automation](<https://devfeed.tech/topics/internal-developer-platform-automation.md>), [human in the loop agent](<https://devfeed.tech/topics/human-in-the-loop-agent.md>), [AIOps for Kubernetes](<https://devfeed.tech/topics/aiops-for-kubernetes.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [cncf](<https://devfeed.tech/tags/cncf.md>), [code](<https://devfeed.tech/tags/code.md>), [community](<https://devfeed.tech/tags/community.md>), [database](<https://devfeed.tech/tags/database.md>), [devrel](<https://devfeed.tech/tags/devrel.md>), [distributed-sql](<https://devfeed.tech/tags/distributed-sql.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [gpus](<https://devfeed.tech/tags/gpus.md>), [guide](<https://devfeed.tech/tags/guide.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [infrastructure-as-code](<https://devfeed.tech/tags/infrastructure-as-code.md>), [kagent](<https://devfeed.tech/tags/kagent.md>), [kubecon](<https://devfeed.tech/tags/kubecon.md>), [kubecon-na](<https://devfeed.tech/tags/kubecon-na.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [pulumi-events](<https://devfeed.tech/tags/pulumi-events.md>)

### AI overview

Pulumi's KubeCon North America 2026 guide lists its Salt Lake City activities for November 9-12: booth 200 at the Solutions Showcase, two talks, a panel, sponsorship of Platform Engineering Day, and a Wednesday evening event. Booth visitors can speak with Pulumi engineers and watch an agent propose changes to a Kubernetes cluster and an external database, with a human approving the preview before deployment. The talks cover a personal kagent running coach and GPU sharing scheduled with Kubernetes DRA; a separate panel addresses developer use of agents. Platform Engineering Day requires an all-access pass, while the Distributed SQL Summit panel requires separate registration. KubeNight Out requires pre-registration and host approval, and attendees must bring ID. The guide offers code KCNA26PULHX20 for 20% off a conference pass, while passes last.

### Source excerpt

KubeCon is in Salt Lake City this year, and we've got a full week planned. Here's where to find us: booth 200, two talks and a panel from our team, a co-located day we're sponsoring, and a party on Wednesday. Come say hi. Salt Lake City - November 9-12, 2026 - Salt Palace Convention Center At a glance Mon, Nov 9 -- Platform Engineering Day, Salt Palace Convention Center Mon, Nov 9, 2:30 PM MT -- Adam Gordon Bell on the "DevRel Unfiltered" panel at Distributed SQL Summit - Gallivan Center Tue, Nov 10, 10:30 AM MT -- Booth 200 opens, Solutions Showcase Tue, Nov 10, 2:50 PM MT -- Adam Gordon Bell, "I Built an AI Running Coach: A Personal kagent Agent in Production" - Hall DE, Level 1 Tue, Nov 10, 4:40 PM MT -- Engin Diri, "Why Are You Still Wasting Whole GPUs?" - 255 BC, Level 2 Tue, Nov 10, 6:00-7:30 PM MT -- KubeCrawl + CloudNativeFest, we're at booth 200 Wed, Nov 11, 5:30-8:30 PM MT -- KubeNight Out at Soundwell, 149 W 200 S Come find us at booth 200 We're in booth 200 in the Solutions Showcase, on the corner by the coffee bar. Booth hours Tuesday, November 10: 10:30 AM - 7:30 PM (includes KubeCrawl + CloudNativeFest, 6:00-7:30 PM) Wednesday, November 11: 10:15 AM - 5:00 PM Thursday, November 12: 10:15 AM - 2:00 PM What's waiting for you there Our engineers, ready to dig in. The people staffing our booth build with Pulumi every day, and they'd rather talk through your setup than hand you a brochure. Bring whatever you're stuck on: Kubernetes, infrastructure as code, golden paths, a migration you're dreading. They'll walk you through how Pulumi handles it. A live look at what agents can do. Watch an agent propose a change to a cluster and the database outside it, then see the preview a human approves before anything ships. It takes a few minutes, and there are no slides. KubeCrawl + CloudNativeFest, Tuesday 6:00-7:30 PM. We'll be at the booth for the whole thing. Platform Engineering Day -- Monday, November 9 We're a Gold sponsor of Platform Engineering Day, the CNCF-hosted

## Manage Pulumi ESC change requests from the CLI

DevFeed: [Manage Pulumi ESC change requests from the CLI](<https://devfeed.tech/articles/manage-pulumi-esc-change-requests-from-the-cli-101114.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/esc-change-requests-cli/>)

Author: Sean Yeh

Published: 2026-10-26T00:00:00Z

Content type: release

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [pulumi-esc](<https://devfeed.tech/topics/pulumi-esc.md>), [pulumi-cli](<https://devfeed.tech/topics/pulumi-cli.md>), [pulumi](<https://devfeed.tech/topics/pulumi.md>)

Tags: [change](<https://devfeed.tech/tags/change.md>), [cli](<https://devfeed.tech/tags/cli.md>), [esc](<https://devfeed.tech/tags/esc.md>), [features](<https://devfeed.tech/tags/features.md>), [product](<https://devfeed.tech/tags/product.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [pulumi-cli](<https://devfeed.tech/tags/pulumi-cli.md>)

### AI overview

Pulumi ESC's `pulumi env change-request` CLI lets reviewers manage changes to protected environments without using the Pulumi Cloud console. They can list requests, inspect request status and approval requirements, review a diff, approve with a comment, then apply once required approvals are met; the CLI displays the diff before approval and prompts before approval or application. Scripts and agents can use `--yes` to skip those prompts and `--output json` for machine-readable output on commands such as `list`, `get`, and `apply`. If another request is applied first, `rebase <id>` updates a request to the latest environment revision. Change requests are available on Pulumi Cloud Pro and Enterprise editions.

### Source excerpt

With ESC Approvals, changes to a protected environment go through a change request. Teammates can review and approve the change before it's applied. Today we're introducing the pulumi env change-request command to work with change requests from the CLI. Review changes without switching to the Pulumi Cloud console, script your approval workflows, or give your agent the tools it needs to review and work with change requests. How it works Let's say your my-project/prod ESC environment is set up to require approval on change. Alice wants to scale the app to 3 replicas, so she opens a change request: $ pulumi env set my-project/prod app.replicas 3 --draft You're the reviewer. Here's how you'd take it from there. Find the change request List the open change requests for an environment: $ pulumi env change-request list --env my-project/prod ┌──────────────────────────────────────┬────────┐ │ ID │ AUTHOR │ ├──────────────────────────────────────┼────────┤ │ 3045b80b-9a13-43c3-9f63-59fa1b09e18d │ alice │ │ 0dace5b4-ef98-4b4c-9a17-627db3662d3f │ bob │ └──────────────────────────────────────┴────────┘ Review the change See the details of a change request: $ pulumi env change-request get 3045b80b-9a13-43c3-9f63-59fa1b09e18d ID: 3045b80b-9a13-43c3-9f63-59fa1b09e18d Environment: acme/my-project/prod Action: update Status: pending Author: Alice <alice> Created: 2 hours ago Revision: 1 Base environment revision: 2 Current environment revision: 2 Description: Scale up to 3 replicas Approved: false prod-approvers (not satisfied): 0 of 1 approvals URL: https://app.pulumi.com/acme/esc/my-project/prod?version=3045b80b-9a13-43c3-9f63-59fa1b09e18d See what it changes: $ pulumi env change-request diff 3045b80b-9a13-43c3-9f63-59fa1b09e18d --- acme/my-project/prod@2 +++ draft 3045b80b-9a13-43c3-9f63-59fa1b09e18d @@ -1,3 +1,3 @@ values: app: - replicas: 2 + replicas: 3 Approve the change Approve it with a comment. The CLI shows the diff again before you confirm: $ pulumi env change-request ap

## Running Pulumi Neo in a Docker Sandbox: workshop recap

DevFeed: [Running Pulumi Neo in a Docker Sandbox: workshop recap](<https://devfeed.tech/articles/running-pulumi-neo-in-a-docker-sandbox-workshop-recap-92883.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/running-pulumi-neo-in-a-docker-sandbox/>)

Author: Mike Coleman

Published: 2026-10-21T00:00:00Z

Content type: article

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [pulumi-neo](<https://devfeed.tech/topics/pulumi-neo.md>), [Docker Sandboxes](<https://devfeed.tech/topics/docker-sandboxes.md>), [pulumi](<https://devfeed.tech/topics/pulumi.md>), [Docker](<https://devfeed.tech/topics/docker.md>), [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [personal access token](<https://devfeed.tech/topics/personal-access-token.md>), [World models](<https://devfeed.tech/topics/world-models.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [api](<https://devfeed.tech/tags/api.md>), [coding-agent](<https://devfeed.tech/tags/coding-agent.md>), [community](<https://devfeed.tech/tags/community.md>), [data](<https://devfeed.tech/tags/data.md>), [docker](<https://devfeed.tech/tags/docker.md>), [docker-sandbox](<https://devfeed.tech/tags/docker-sandbox.md>), [esc](<https://devfeed.tech/tags/esc.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [neo](<https://devfeed.tech/tags/neo.md>), [policy](<https://devfeed.tech/tags/policy.md>), [production](<https://devfeed.tech/tags/production.md>), [prompt](<https://devfeed.tech/tags/prompt.md>), [proxy](<https://devfeed.tech/tags/proxy.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [pulumi-neo](<https://devfeed.tech/tags/pulumi-neo.md>), [recap](<https://devfeed.tech/tags/recap.md>), [sandbox](<https://devfeed.tech/tags/sandbox.md>), [security](<https://devfeed.tech/tags/security.md>), [token](<https://devfeed.tech/tags/token.md>), [workshop](<https://devfeed.tech/tags/workshop.md>)

### AI overview

The workshop describes running Pulumi Neo in a Docker Sandbox with controls outside the agent's prompt. Neo runs in an isolated microVM with access limited to mounted files and permitted network hosts; a proxy injects the Pulumi token so Neo does not hold the real credential. Pulumi governs permissions and approvals: manual asks before each tool call, balanced before `pulumi up`, and auto never asks. Read-only blocks Pulumi Cloud writes but does not prevent access to ESC environments or their cloud accounts; role permissions must restrict environment access. Preventative Pulumi Policies can block violations, `protect: true` can stop deletion of protected resources, and ESC can issue short-lived AWS credentials, which limit leak damage but do not prevent it. Docker's network proxy can deny unapproved hosts, though allowed hosts still receive what Neo sends. The excerpt recommends starting with a locked-down network preset and balanced approvals near production. Centralized Docker sandbox controls are paid; local sandboxes and the `sbx` CLI are free. The final teardown demonstration was not completed.

### Source excerpt

The more an agent can do on its own, the more infrastructure work you can hand it, as long as its limits hold when it gets something wrong. In April, they didn't hold for PocketOS. A coding agent on a routine staging task deleted the company's production volume in 9 seconds. According to founder Jer Crane's account, it used an API token it found in an unrelated file. Its explanation afterward: "I guessed that deleting a staging volume via the API would be scoped to staging only. I didn't verify." Railway recovered the data two days later. The agent had been told not to. "System prompts are advisory, not enforcing," Crane wrote afterward. If the prompt can't stop an agent, the limits have to sit where the agent can't negotiate with them. That was the premise of Neo in a Docker Sandbox, the workshop Adam Gordon Bell and I ran with Mike Coleman from Docker. So we gave Pulumi Neo two layers. The first is a Docker Sandbox. Neo runs in its own microVM and reaches only the files and hosts we allow. The Pulumi token gets injected by a proxy on the way out, so Neo never holds the real credential. The second is Pulumi itself, which decides what Neo may change and when it has to ask. With both in place, you can let Neo work without approving every step. For why YOLO mode belongs in a sandbox at all, see my August post. Mike Coleman is a Principal Solutions Architect at Docker. His running joke is that agents "want to be helpful". It happens in his own demos: Mike Coleman I talk to people about agents a lot. They just really want to please you. I don't know how many times I've done a demo [of] governance for MCP servers, and I'll be like, "Can you write to my Notion page?" And there will be a policy applied to the sandbox that says it can't. But I have a connector enabled in Claude somewhere. And it's like, "Well, not with that MCP server, but I can use this thing over here to do it." Mike's answer is to close those doors before the agent finds them: Mike Coleman The more you c

## Assign policy groups by stack and account tags

DevFeed: [Assign policy groups by stack and account tags](<https://devfeed.tech/articles/assign-policy-groups-by-stack-and-account-tags-90411.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/assign-policy-groups-by-tags/>)

Author: Dan Biwer

Published: 2026-10-19T00:00:00Z

Content type: release

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [policy-as-code](<https://devfeed.tech/topics/policy-as-code.md>), [pulumi](<https://devfeed.tech/topics/pulumi.md>), [pulumi-cloud](<https://devfeed.tech/topics/pulumi-cloud.md>)

Tags: [compliance](<https://devfeed.tech/tags/compliance.md>), [features](<https://devfeed.tech/tags/features.md>), [governance](<https://devfeed.tech/tags/governance.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [policy](<https://devfeed.tech/tags/policy.md>), [policy-as-code](<https://devfeed.tech/tags/policy-as-code.md>), [product](<https://devfeed.tech/tags/product.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [pulumi-cloud](<https://devfeed.tech/tags/pulumi-cloud.md>), [tag](<https://devfeed.tech/tags/tag.md>)

### AI overview

Pulumi Cloud now lets policy groups automatically include stacks and cloud accounts based on tag matching rules. Membership updates as tags change, and teams can define the rules in the console or with the Pulumi Service Provider while keeping existing individually assigned members.

### Source excerpt

Policy groups decide which policy packs apply to which stacks and cloud accounts. Until now, stacks and accounts were added to policy groups individually, so every new stack required opting into their correct group by hand. Policy groups membership can now be managed by tags, so new infrastructure gets the right policy coverage automatically as it's created. What's new Policy groups now support tag matching conditions. Every stack or cloud account whose tags match the condition joins the group, and membership stays current as tags change. Tag rules work alongside the stacks and accounts you add individually, so you can adopt them without restructuring your existing groups. To add one, open a policy group in Pulumi Cloud and select Match by tags. Or define it in code with the Pulumi Service Provider: import * as pulumiservice from "@pulumi/pulumiservice"; new pulumiservice.api.PolicyGroup("payments-production", { orgName: "my-org", name: "payments-production", mode: "preventative", stackMatchRule: pulumiservice.buildStackMatchRuleOutput({ rules: [{ conditions: [{ key: "env", value: "prod" }, { key: "team", value: "payments" }] }], }).matchRule, }); new pulumiservice.api.PolicyGroup("pci-accounts", { orgName: "my-org", name: "pci-accounts", mode: "audit", accountMatchRule: pulumiservice.buildAccountMatchRuleOutput({ rules: [{ conditions: [{ key: "env", value: "prod" }, { key: "compliance", value: "pci" }] }], }).matchRule, }); Example: enforcement by environment A common pattern is one policy group per environment tier, with stricter enforcement in production: A production preventative group with a rule matching env: prod, where critical policies are mandatory. A development preventative group with a rule matching env: dev, where the same packs are advisory. A new stack tagged env: prod joins your production policy group automatically, with no one editing the group. The same approach works for audit groups and cloud accounts, for example matching accounts tagged compl

## AI infrastructure on tap with the Pulumi AICR provider

DevFeed: [AI infrastructure on tap with the Pulumi AICR provider](<https://devfeed.tech/articles/ai-infrastructure-on-tap-with-the-pulumi-aicr-provider-93936.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/self-hosted-ai-infrastructure-pulumi-aicr/>)

Author: Peter Yoakum

Published: 2026-10-19T00:00:00Z

Content type: release

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [pulumi](<https://devfeed.tech/topics/pulumi.md>), [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [Self Hosted AI Tools](<https://devfeed.tech/topics/self-hosted-ai-tools.md>), [pulumi-cli](<https://devfeed.tech/topics/pulumi-cli.md>), [Self-hosted](<https://devfeed.tech/topics/self-hosted.md>), [self-service](<https://devfeed.tech/topics/self-service.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-infrastructure](<https://devfeed.tech/tags/ai-infrastructure.md>), [building-with-ai](<https://devfeed.tech/tags/building-with-ai.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [coreweave](<https://devfeed.tech/tags/coreweave.md>), [coreweave-fully-connected](<https://devfeed.tech/tags/coreweave-fully-connected.md>), [cost](<https://devfeed.tech/tags/cost.md>), [demand](<https://devfeed.tech/tags/demand.md>), [developers](<https://devfeed.tech/tags/developers.md>), [ecosystem](<https://devfeed.tech/tags/ecosystem.md>), [environments](<https://devfeed.tech/tags/environments.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [hyperscalers](<https://devfeed.tech/tags/hyperscalers.md>), [inference](<https://devfeed.tech/tags/inference.md>), [inference-endpoints](<https://devfeed.tech/tags/inference-endpoints.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [infrastructure-as-code](<https://devfeed.tech/tags/infrastructure-as-code.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [multi-cloud](<https://devfeed.tech/tags/multi-cloud.md>), [product](<https://devfeed.tech/tags/product.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

The Pulumi NVIDIA AI Cluster Runtime (AICR) provider uses NVIDIA's pre-validated GPU infrastructure recipes to deploy workload-specific training clusters and inference endpoints across cloud GPU providers. A Python example provisions a two-node CoreWeave inference stack from a kubeconfig, with configurable accelerator and service. `pulumi preview` shows the Kubernetes components before deployment; `pulumi up` manages them under one resource with diff, update, drift detection, and destroy support. The text says NVIDIA validates recipes across varied hardware, operating systems, software stacks, and cloud configurations, assessing deployment health, conformance, and performance. It presents this as a way to reduce setup effort amid provider, workload, cost, and capacity differences; it does not quantify time or cost savings.

### Source excerpt

Recently, some members of the Pulumi team spent time in San Francisco attending the CoreWeave: Fully Connected 2026 conference, where we had a chance to talk to everyone from solo developers to engineering leaders at Fortune 500 organizations and learn more about how they are building with AI. A frequent topic of conversation was open weight models and self-hosted inference. Whether AI is integrated into your platform, your product, or your productivity pipelines, rising token costs have decision makers everywhere giving open weight models a closer look, in exchange for the promise of tighter control over spend and greater domain expertise. If you are actively exploring the space or building with AI yourself, you may already have seen the challenges that come with serving inference at scale: Model stability and reliability can differ (sometimes dramatically) across hardware architectures and at different traffic volumes. Model performance and throughput can change depending on your workload type or model configuration. Cost differences and commitments across providers can make tracking spend challenging. Supply constraints and capacity shortages mean teams can't source hardware when they need it most. Many teams naturally gravitate toward multicloud strategies that combine hyperscalers with specialized GPU clouds as a way of balancing spend, performance, and reliability. One thing we've seen is that developers everywhere are choosing Pulumi to help them navigate the fragmented hardware ecosystem and maintain consistent environments, even when the provider is different. As part of our ongoing commitment to building better tools for builders, we're excited to announce the Pulumi NVIDIA AI Cluster Runtime (AICR) provider to help make your ideal self-hosted AI infrastructure available on demand. The Pulumi AICR provider lets you spin up workload-specific training and inference endpoints as you need them, configured with pre-validated recipes to match your workload with

## Pulumi ESC now issues OIDC tokens for any service

DevFeed: [Pulumi ESC now issues OIDC tokens for any service](<https://devfeed.tech/articles/pulumi-esc-now-issues-oidc-tokens-for-any-service-88195.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/esc-oidc-tokens-for-any-service/>)

Author: Devon Grove

Published: 2026-10-15T00:00:00Z

Content type: release

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [OpenID connect (OIDC)](<https://devfeed.tech/topics/oidc.md>), [personal access token](<https://devfeed.tech/topics/personal-access-token.md>), [internal developer platform automation](<https://devfeed.tech/topics/internal-developer-platform-automation.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [api](<https://devfeed.tech/tags/api.md>), [credentials](<https://devfeed.tech/tags/credentials.md>), [esc](<https://devfeed.tech/tags/esc.md>), [features](<https://devfeed.tech/tags/features.md>), [jfrog-artifactory](<https://devfeed.tech/tags/jfrog-artifactory.md>), [oidc](<https://devfeed.tech/tags/oidc.md>), [product](<https://devfeed.tech/tags/product.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [pulumi-esc](<https://devfeed.tech/tags/pulumi-esc.md>), [security](<https://devfeed.tech/tags/security.md>), [tokens](<https://devfeed.tech/tags/tokens.md>), [trust](<https://devfeed.tech/tags/trust.md>), [version](<https://devfeed.tech/tags/version.md>)

### AI overview

Pulumi ESC now issues short-lived OIDC tokens for services such as package registries and Anthropic, replacing stored long-lived keys with scoped credentials. The article explains configuration, trust-policy subject pinning, and using the tokens with Claude API workloads.

### Source excerpt

A Pulumi ESC environment can now mint a short-lived OpenID Connect (OIDC) token for any service that accepts one. Every pipeline and agent that touches your infrastructure eventually needs credentials for services beyond your cloud: a package registry such as Cloudsmith or JFrog Artifactory, an AI platform such as Anthropic, or a workload access platform such as Aembit. The default historically has been to store a long-lived API key that sits in an environment, which presents a much higher risk of exposure than short-lived credentials. With the new fn::open::oidc provider, ESC signs a short-lived token for the audience you choose when you open the environment. The service named in that audience checks the signature and exchanges the token for a credential of its own. The token expires within the hour, and ESC stores nothing. Why the stored key is the weak link A stored key for a registry or an access platform sits in ESC until someone rotates it. It works for anyone who reads it, from any machine, for as long as it exists. If it leaks, you rotate it, and every consumer of the environment breaks until it picks up the new one. An OIDC token works the other way around. ESC mints it at the moment you open the environment, signs it with a key only Pulumi holds, and stamps it with an expiry. The service checks it against the trust policy you configured and issues a credential with its own lifetime. You store nothing, so you rotate nothing. Why this matters for agents An AI agent that opens an environment gets whatever the environment holds. A stored key works from anywhere until someone rotates it, and one bad prompt can copy it out. A fn::open::oidc token is tightly scoped and short-lived so your agents will only access what they need and nothing more. How it works Declare the provider in an environment, name the audience the service expects, and export the token: values: aembit: login: fn::open::oidc: audience: https://acme.aembit.io duration: 15m identityToken: version

## Scale your team's use of AWS IAM account access manager with Pulumi

DevFeed: [Scale your team's use of AWS IAM account access manager with Pulumi](<https://devfeed.tech/articles/scale-your-team-s-use-of-aws-iam-account-access-manager-with-pulumi-87247.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/scale-your-teams-use-of-aws-iam-account-access-manager-with-pulumi/>)

Author: Tatiana Cooke

Published: 2026-10-14T00:00:00Z

Content type: tutorial

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [pulumi](<https://devfeed.tech/topics/pulumi.md>), [AWS IAM](<https://devfeed.tech/topics/aws-iam.md>), [Access Control](<https://devfeed.tech/topics/access-control.md>), [Single sign-on (SSO)](<https://devfeed.tech/topics/sso.md>), [Security, Identity, & Compliance](<https://devfeed.tech/topics/security-identity-compliance.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [administrator](<https://devfeed.tech/tags/administrator.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-iam](<https://devfeed.tech/tags/aws-iam.md>), [aws-iam-identity-center](<https://devfeed.tech/tags/aws-iam-identity-center.md>), [iam](<https://devfeed.tech/tags/iam.md>), [iam-identity-center](<https://devfeed.tech/tags/iam-identity-center.md>), [iam-roles](<https://devfeed.tech/tags/iam-roles.md>), [infrastructure-as-code](<https://devfeed.tech/tags/infrastructure-as-code.md>), [partner](<https://devfeed.tech/tags/partner.md>), [product](<https://devfeed.tech/tags/product.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [sdks](<https://devfeed.tech/tags/sdks.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

This tutorial explains how to manage AWS IAM account access manager (AAM) with Pulumi. It covers defining IAM roles, applications, and entitlements as code, scaling group-to-role assignments across AWS accounts, and using policy checks and review workflows. A digital bank is described as adopting AAM to move workforce access to IAM Identity Center while managing roles and entitlements in Pulumi.

### Source excerpt

In September 2026, AWS launched AWS IAM account access manager (AAM), which lets administrators assign IAM roles to workforce users and groups in AWS IAM Identity Center. AAM combines IAM Identity Center's single federation point and user awareness with the flexibility of IAM roles. Today, as part of our partner launch enablement, we're pleased to share that you can manage AAM as code with Pulumi. The accountaccess resources ship in the Pulumi AWS provider (v7.45.0 and later) and in the Pulumi AWS Cloud Control provider, AWS Native (v1.75.0 and later), with SDKs generated for every Pulumi language: TypeScript, Python, Go, C#, Java, HCL, and YAML. Teams that already manage their AWS organization with Pulumi can adopt AAM in the same stacks, languages, and review workflows they use today. If you're not using Pulumi today, this post demonstrates how infrastructure as code can help you adopt new AWS services and securely scale them out to your organization faster. In this post, we explain where AAM fits alongside permission sets. We walk through defining roles, applications, and entitlements as code, and we describe how one financial services customer is using this pattern to move its workforce access to IAM Identity Center. The challenge: flexible roles vs. centralized access Until now, organizations managing human access across many AWS accounts have had to choose between two approaches. IAM Identity Center permission sets provide a single sign-on experience and centralized user awareness. IAM Identity Center provisions a permission set into each account as a uniform role. That works well for baseline access, such as read-only or administrator access that looks the same everywhere. But many enterprises need roles that differ from account to account. These roles carry account-specific policies, tags for attribute-based access control (ABAC), custom trust policies, or role paths that encode team and environment. As organizations add accounts, teams, and specialized role

## Concurrent change requests in Pulumi ESC

DevFeed: [Concurrent change requests in Pulumi ESC](<https://devfeed.tech/articles/concurrent-change-requests-in-pulumi-esc-66952.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/esc-concurrent-change-requests/>)

Author: Sean Yeh

Published: 2026-10-07T00:00:00Z

Content type: release

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [pulumi-esc](<https://devfeed.tech/topics/pulumi-esc.md>), [pulumi](<https://devfeed.tech/topics/pulumi.md>)

Tags: [concurrent](<https://devfeed.tech/tags/concurrent.md>), [esc](<https://devfeed.tech/tags/esc.md>), [features](<https://devfeed.tech/tags/features.md>), [product](<https://devfeed.tech/tags/product.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [pulumi-esc](<https://devfeed.tech/tags/pulumi-esc.md>)

### AI overview

Pulumi ESC now allows multiple change requests on the same environment to remain open concurrently. If another request is applied first, users can update their draft to the latest revision; changes are reapplied using a three-way merge, with conflicts shown in the console. The feature is available in Pulumi Cloud Pro and Enterprise for environments with approvals enabled.

### Source excerpt

With ESC Approvals, you can propose, review, and apply environment changes with change requests. Until now, an environment could only have one open change request at a time. If a teammate's change was waiting for review, others were blocked from opening change requests. Today, multiple people can open change requests on the same environment at the same time. A platform engineer can rotate a database credential while an app team adds a new feature flag, and each change goes through its own review. You no longer need to wait on your teammates' changes! How it works Creating and viewing change requests in the Pulumi Cloud console Creating environment change requests works the same as before - just edit an environment that has approvals enabled, and click "Create Draft" once ready, which opens a change request for your teammates to review. You can view all change requests for the environment from either the version dropdown or the Approvals tab. Updating to the latest revision If another change request gets applied first, yours is now based on an older revision. This is nothing to worry about - just click "Update to latest revision" and your changes are reapplied on top of the latest revision (using a 3-way merge). If there is a merge conflict, the console will show which lines conflict. You can resolve this by either editing the draft or recreating the change request. Get started Concurrent change requests are available today in Pulumi Cloud on the Pro and Enterprise editions, for any environment with approvals enabled. To get started, see the Approvals documentation. Let us know what you think in the Pulumi Community Slack!

## Pulumi Google Cloud Provider Version 10.0.0

DevFeed: [Pulumi Google Cloud Provider Version 10.0.0](<https://devfeed.tech/articles/pulumi-google-cloud-provider-version-10-0-0-65864.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/gcp-v10-release/>)

Author: Alberto Pose

Published: 2026-10-06T15:00:00Z

Content type: release

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [Google Cloud Platform (GCP)](<https://devfeed.tech/topics/google-cloud.md>), [pulumi-cli](<https://devfeed.tech/topics/pulumi-cli.md>), [Agent Skills](<https://devfeed.tech/topics/agent-skills.md>)

Tags: [agent-skills](<https://devfeed.tech/tags/agent-skills.md>), [features](<https://devfeed.tech/tags/features.md>), [google-cloud](<https://devfeed.tech/tags/google-cloud.md>), [product](<https://devfeed.tech/tags/product.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [releases](<https://devfeed.tech/tags/releases.md>), [v8](<https://devfeed.tech/tags/v8.md>)

### AI overview

Pulumi released version 10 of its Google Cloud provider, based on version 8 of terraform-provider-google. The release includes a migration guide and an updated provider-upgrade skill that can scan project code and infrastructure, explain affected resources, and help prepare an upgrade. The article also highlights new support for Google Cloud TPU and Vertex AI resources.

### Source excerpt

TL;DR: we are releasing a new major version of the Google Cloud provider. To migrate, ask Neo or your coding agent to run the Pulumi provider-upgrade skill (how to use it) or follow the v10 migration guide. We are happy to announce the next major version of the Pulumi Google Cloud provider. This release is based on the new v8 major version of terraform-provider-google (see also the upstream v8 upgrade guide). It ships with a migration guide that covers every breaking change in depth. Here are a few links to help you get started if you are new to Pulumi: Getting Started: a guided walkthrough for creating your first project Setup & Install: how to install the Google Cloud provider How-to guides: how to provision specific resources with the Google Cloud provider Pulumi Neo: ask Pulumi Neo to help you with your project Upgrading The migration guide accounts for every resource, type and function that changed in the new version. For the most popular resources, it gives a description of the change, a risk and impact section, a way to check whether you are affected, and step by step migration snippets. Use an agent to assist with your upgrade We have updated the provider-upgrade skill in Pulumi Agent Skills to cover the upgrade from v9. You can use it from Pulumi Neo or from any popular coding agent. Before it bumps the provider, it scans your stack and code for the changes that affect you, and it stops to ask before anything that would replace or delete live infrastructure. Then it upgrades the dependency, runs pulumi preview until the diff is explained, and leaves pulumi up to you. In Neo, ask: "Upgrade this project to pulumi-gcp v10." Neo picks the provider-upgrade skill for you; there is nothing to install or name. Neo plans the upgrade, starting with a scan of your stack while it is still on v9. Before it edits any code, it tells you which resources are affected and what could be replaced, and waits for your answer. Finally, Neo opens a pull request with the changes an

## Building Kubernetes PR Previews with Shared Pulumi Components

DevFeed: [Building Kubernetes PR Previews with Shared Pulumi Components](<https://devfeed.tech/articles/building-kubernetes-pr-previews-with-shared-pulumi-components-63794.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/building-kubernetes-pr-previews-with-shared-pulumi-components/>)

Author: Sangharsh Agarwal

Published: 2026-10-01T00:00:00Z

Content type: tutorial

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [CI/CD](<https://devfeed.tech/topics/cicd.md>), [pulumi](<https://devfeed.tech/topics/pulumi.md>), [Service fabric](<https://devfeed.tech/topics/service-fabric.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [ci](<https://devfeed.tech/tags/ci.md>), [environment](<https://devfeed.tech/tags/environment.md>), [ephemeral-environments](<https://devfeed.tech/tags/ephemeral-environments.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [preview-environments](<https://devfeed.tech/tags/preview-environments.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [python](<https://devfeed.tech/tags/python.md>)

### AI overview

The article explains how a team uses shared Pulumi components and Kubernetes namespaces to create, update, and clean up ephemeral preview environments for pull requests. It covers CI lifecycle automation, serialized updates to avoid stack conflicts, scheduled reconciliation for missed cleanup, and handling infrastructure drift. The team reports an average of about four minutes from starting deployment until a preview is ready.

### Source excerpt

My team develops a microservices application on Kubernetes, with hundreds of PRs opened each day. To let engineers test and review those changes in isolation before they're merged, we give every pull request its own ephemeral environment. We use Pulumi to define those short-lived PR environments from a component resource that's shared with our long-lived Dev, Stage, Prod environments. Each PR gets its own Pulumi stack and Kubernetes namespace, which we tear down once the PR is merged or closed. In this post, I'll walk through how we've implemented this pattern and what we've learned from running it at scale. We use a self-managed Pulumi backend, so we manage the end-to-end lifecycle of PR environments ourselves. Pulumi Cloud users can instead use review stacks to automate the lifecycle of ephemeral environments tied to pull requests. How our ephemeral environments work A Kubernetes namespace gives each PR its own place to run, but to get to a working preview environment we need to do quite a bit on top of that. We still need to deploy the application into that namespace, make it reachable to reviewers, update it as new commits arrive, and remove it when the PR closes. And while a namespace separates the Kubernetes resources for each preview, things like database isolation, access controls, and network policies depend on the application and cluster. Pulumi gives us a way to define these environments once while managing each one independently. Dev, Stage, Prod, and each PR run the same Pulumi program in separate stacks. The program defines the infrastructure for an environment, while each stack maintains its own configuration and state. For each PR, our CI creates or updates its Pulumi stack as new commits arrive, then destroys it when the PR closes. Defining the environment Our implementation uses a single custom Pulumi component, but for the simplified example below, we've split it into two components to make the pattern easier to follow. StackInstance represents on

## Route every Claude Code message to the right model with Jev

DevFeed: [Route every Claude Code message to the right model with Jev](<https://devfeed.tech/articles/route-every-claude-code-message-to-the-right-model-with-jev-60790.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/route-every-claude-code-message-to-the-right-model-with-jev/>)

Author: Engin Diri

Published: 2026-09-28T00:00:00Z

Content type: article

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [Model Routing](<https://devfeed.tech/topics/model-routing.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [The Chapel Parallel Programming Language](<https://devfeed.tech/topics/chapel.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [confidence](<https://devfeed.tech/tags/confidence.md>), [developer-experience](<https://devfeed.tech/tags/developer-experience.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [git](<https://devfeed.tech/tags/git.md>), [gpt](<https://devfeed.tech/tags/gpt.md>), [handle](<https://devfeed.tech/tags/handle.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llms](<https://devfeed.tech/tags/llms.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [rlcd](<https://devfeed.tech/tags/rlcd.md>)

### AI overview

The article introduces jev-router, an open-source tool that uses TypeSafe AI's Jev model to route Claude Code messages to an appropriate Claude model. It describes Jev as a fast decision model that returns probabilities for classification, choice, and scoring tasks, and presents model selection as one routing use case.

### Source excerpt

Not every message you send to Claude Code needs the most capable model. A quick question about a Git command runs on the same model as a refactor across three services, unless you remember to switch models first. Jev, a new model from TypeSafe AI, can make that decision for you in a few hundred milliseconds and for a fraction of a cent. So I built jev-router, an open source router that asks Jev which Claude model each of your messages needs, and sends it there. What Jev is After co-inventing ChatGPT, I kept asking myself: why have superhuman chat models not led to AGI? I've spent the last 2 years in stealth building a new way to train models (RLCD), and a new type of frontier AI model that we are releasing today: Jev - 20-200x faster - 40-400x... pic.twitter.com/JSybNG2BKJ -- Diogo Almeida (@CompleteSkeptic) September 15, 2026 TypeSafe AI released Jev in September 2026. Its founder, Diogo Almeida, co-authored OpenAI's InstructGPT paper, the research behind ChatGPT. Jev isn't a large language model, and it can't write you a sentence. TypeSafe calls it a System One model, a term borrowed from Daniel Kahneman's Thinking, Fast and Slow. LLMs like Claude and GPT work like System Two: they write their answer token by token, take seconds to minutes, and can say anything. Jev works like System One. You describe a situation, ask a few typed questions, and it answers all of them in one parallel pass, in 70-500 milliseconds end to end, according to TypeSafe's launch post. Every question takes one of three shapes. A Noul asks whether a statement is true and returns a probability. A Choice picks from a list of options you provide, with a probability for each one. A Score places the situation on a scale. Jev never answers outside your options, so there's no malformed JSON to parse and no made-up category to handle. TypeSafe trains Jev with a method it calls reinforcement learning for calibrated decisions (RLCD), and says the probabilities are calibrated: a higher confidence should m

## Self-driving infrastructure with Pulumi and Jev

DevFeed: [Self-driving infrastructure with Pulumi and Jev](<https://devfeed.tech/articles/self-driving-infrastructure-with-pulumi-and-jev-61357.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/self-driving-infrastructure-pulumi-jev/>)

Author: Peter Yoakum

Published: 2026-09-28T00:00:00Z

Content type: tutorial

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [pulumi-neo](<https://devfeed.tech/topics/pulumi-neo.md>), [pulumi](<https://devfeed.tech/topics/pulumi.md>)

Tags: [agentic-workflows](<https://devfeed.tech/tags/agentic-workflows.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [automation-api](<https://devfeed.tech/tags/automation-api.md>), [container-image](<https://devfeed.tech/tags/container-image.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [multi-cloud](<https://devfeed.tech/tags/multi-cloud.md>), [typescript](<https://devfeed.tech/tags/typescript.md>)

### AI overview

The article describes GeoDeploy, an example agentic workflow built with Pulumi and TypeSafe AI's Jev. It uses deployment inputs such as user locations, residency rules, container image, workload needs, provider constraints, and budget to choose cloud regions and provision infrastructure.

### Source excerpt

It's been a weirdly great time to be building software. We've never had so many tools that help us get things done: endless cloud providers, regions, deployment frameworks, and now AI agents that can actually build and manage infrastructure for us. That's part of what made this past week feel so big. TypeSafe AI opened early access to Jev, their SystemOne model, and we here at Pulumi were bitten by the excitement bug and got straight to work building. Almost immediately we were able to whip up some test agentic workflows that were making real, live decisions about infrastructure. If you're not familiar with TypeSafe's Jev, it comes with a powerful set of AI primitives that let your apps, agents, and workflows make decisions based on context. Jev's decision-making primitives are the perfect complement to agentic work. When you combine that reasoning power with Pulumi, the gap between dreaming up your ideal infrastructure and deploying it to production practically vanishes. In the past, having more choices usually meant dealing with more complexity, which added technical debt and inevitably meant someone (perhaps you) spent hours setting things up. Now you can let agents handle provisioning and the day-to-day scaling and reliability decisions while you stay focused on defining how your infrastructure should work. Okay, but how does it work? Our example, GeoDeploy, answers one question: my users are in these places and I have this container image, so where should it run and what will it cost? Then it builds the answer. You give it a deployment request with four parts: Target geos: where your users are, what share of traffic each place sends, and any data-residency rule (EU-only, US-only, or in-country). An image: a container image and the platforms it's built for (amd64, arm64, or both). A workload shape: replicas, CPU and memory per pod, egress, and storage. Constraints: which providers are allowed, how many providers you'll tolerate, and a budget. From there, GeoDepl

## How Pulumi Neo Uses Kopia Snapshots to Preserve Long-Running Agent Workspaces

DevFeed: [How Pulumi Neo Uses Kopia Snapshots to Preserve Long-Running Agent Workspaces](<https://devfeed.tech/articles/ai-agents-need-continuity-not-just-context-60167.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/neo-kopia-workspace-snapshots/>)

Author: Derek Schaller

Published: 2026-09-25T19:00:00Z

Content type: article

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Persistence](<https://devfeed.tech/topics/persistence.md>), [pulumi-neo](<https://devfeed.tech/topics/pulumi-neo.md>), [Repository](<https://devfeed.tech/topics/repository.md>), [Git](<https://devfeed.tech/topics/git.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [systems](<https://devfeed.tech/topics/systems.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [git](<https://devfeed.tech/tags/git.md>), [infrastructure-as-code](<https://devfeed.tech/tags/infrastructure-as-code.md>), [object-storage](<https://devfeed.tech/tags/object-storage.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [persistence](<https://devfeed.tech/tags/persistence.md>), [pulumi-neo](<https://devfeed.tech/tags/pulumi-neo.md>), [repository](<https://devfeed.tech/tags/repository.md>)

### AI overview

Pulumi describes how Neo preserves hosted-runtime workspaces for long-running agent tasks. After finding Git-based recovery insufficient for generated files, dependencies, scratch output, and other workspace state, the team chose Kopia for encrypted, incremental, content-addressed snapshots stored in backends such as object storage.

### Source excerpt

Pulumi Neo works on infrastructure the way an engineer does: it clones repositories, edits files, installs dependencies, runs previews, and produces intermediate work along the way. A task is not only a conversation with a model. It is also a working directory that has to survive long enough for the agent to keep making progress. Imagine asking an agent to upgrade a Pulumi provider version across a repository, regenerate SDK code, run previews and tests, inspect the failures, and open a pull request. Halfway through, the runtime restarts. Conversation replay can recover what the agent said and which tools it called, but it does not recover the generated files, dependency state, local commits, or scratch output the next step may depend on. Without workspace continuity, the agent can wake up remembering the plan but missing the room it was working in. For early hosted Neo tasks, workspace recovery started with Git. We persisted enough information to reconstruct repositories later: remotes, branches, commits, and local diffs. This was about the hosted runtime workspace, not a user's local checkout when running pulumi neo, where local filesystem and shell tools execute on the user's machine. The Git-based approach worked for simple hosted-runtime cases, but it was the wrong abstraction for long-running agent work. We needed to recover the workspace Neo had actually used. This post walks through how we tackled workspace continuity for long-running agent tasks, what we learned along the way, and how the same techniques can help you build more resilient agentic systems of your own. The core primitive we chose was Kopia, an open source backup tool that creates encrypted, incremental, content-addressed snapshots and stores them in backends such as object storage. Git was the wrong recovery boundary The original persistence model was repository-oriented. After a turn, the hosted agent runtime scanned its own working directory for Git repositories, recorded each remote, branch

## Change infrastructure components while preserving existing resources

DevFeed: [Change infrastructure components while preserving existing resources](<https://devfeed.tech/articles/change-your-components-keep-your-infrastructure-60789.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/component-state-migrations/>)

Author: Julien Poissonnier

Published: 2026-09-25T00:00:00Z

Content type: article

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [Amazon VPC](<https://devfeed.tech/topics/amazon-vpc.md>), [versioning](<https://devfeed.tech/topics/versioning.md>), [Continuous Deployment (CD)](<https://devfeed.tech/topics/continuous-deployment.md>)

Tags: [components](<https://devfeed.tech/tags/components.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [infrastructure-as-code](<https://devfeed.tech/tags/infrastructure-as-code.md>), [migration](<https://devfeed.tech/tags/migration.md>), [product](<https://devfeed.tech/tags/product.md>), [production](<https://devfeed.tech/tags/production.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>)

### AI overview

Pulumi introduces experimental component state migrations that translate a component's saved state and child resources before determining what infrastructure needs to change. The article illustrates how migrations can help evolve an AWS VPC component across versions while preserving existing infrastructure; it also warns that unplanned replacements can affect dependent resources and production databases.

### Source excerpt

Components let you turn a group of resources into a reusable building block. You can define a network, a database, or an application service once and share it across projects and teams. People using the component work with its inputs and outputs without needing to understand every resource inside it. Suppose you built your network with the legacy AWSX VPC component. It manages the VPC, subnets, route tables, and gateways behind a few lines of code. Now you want to upgrade to the modern AWSX component. Later, your needs change again: you want more control over the resources than the component gives you. At each step, the network is already running. You want to change the code that manages it without rebuilding the network itself. Pulumi's new component state migrations let you ship the upgrade path with the component itself. A migration translates the saved state of a component and its children before Pulumi works out which resources need to change. Component authors can change the internal design and include the migration in the same release. The state migrations API is experimental and may change. Share feedback in the component state migrations discussion. One VPC, three versions of the code The AWSX VPC example follows a network as your needs change over time. You start with v1, upgrade to v2, and later move to v3. Each version builds on the infrastructure already running. You start with the legacy awsx.classic.ec2.Vpc component. This first version creates a VPC with one isolated subnet, a route table and its association, and an internet gateway. A security group sits outside the component and refers to the VPC. Without a migration that connects the old state to the new code, an upgrade could replace the VPC instead of keeping it. That change would reach beyond the component: the security group refers to the VPC's ID, so a new VPC would mean replacing the security group too. Now imagine a production database using that network and security group. The example does

## 10 tips to improve your coding agent game

DevFeed: [10 tips to improve your coding agent game](<https://devfeed.tech/articles/10-tips-to-improve-your-coding-agent-game-57589.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/10-tips-to-improve-your-coding-agent-game/>)

Author: Engin Diri

Published: 2026-09-21T00:00:00Z

Content type: opinion

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [Code](<https://devfeed.tech/topics/code.md>), [Documentation](<https://devfeed.tech/topics/documentation.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [codex](<https://devfeed.tech/tags/codex.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agent](<https://devfeed.tech/tags/coding-agent.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [research](<https://devfeed.tech/tags/research.md>), [tips](<https://devfeed.tech/tags/tips.md>)

### AI overview

An opinion article presents ten research-informed tips for working with coding agents. It recommends moving important guidance from chat into instruction files, hooks, tests, or fresh sessions, while noting that agent instructions can become stale and that subagent costs require caution.

### Source excerpt

In May I told you to trim the root instruction file until it fits on one screen. I also said anything that needs a hard guarantee belongs in a hook. In June I argued that the model that wrote the code shouldn't be the one grading it. Several papers published this summer tested related questions. Most of the findings support that advice, while the research on subagent costs calls for more caution. Below are ten tips for working with any coding agent. Each one is checked against what the research measured, which is sometimes narrower than the abstract suggests. Instructions kept only in chat can disappear during summarization. Nearly every fix below moves something out of the chat and into a file, a hook, a test, or a fresh session. That's what I meant in June by "the agent forgets, the repo does not." Agent instructions 1. Write for the agent, not for a new hire A new hire can ask a teammate what a vague convention means. An agent may proceed with an interpretation you never intended. Anthropic's docs on project instructions ask for instructions "concrete enough to verify," like "API handlers live in src/api/handlers/" instead of "Keep files organized." One line in my own Go instructions says to wrap errors with fmt.Errorf("...: %w", err) and never discard one silently. An agent can follow that, and a reviewer can check it. Try doing either with "handle errors properly." The instruction file is also where agents look first. A Peking University study by Zhijun Gao and Jing Chen traced 557 real agent sessions and sorted every documentation touch. Instruction files and the agents' own working notes made up 60.5% of them, and API references only 1.3%. The authors couldn't show that any particular writing style changes behavior. Most of their sessions also came from Claude Code, so the style question is still open. 2. Treat agent instructions like code, because they rot Specific instructions go stale. Rename a folder or swap a database, and the file keeps describing a cod

## Cloud Sovereignty, Provider Risk, and Migration Options for EU Companies

DevFeed: [Cloud Sovereignty, Provider Risk, and Migration Options for EU Companies](<https://devfeed.tech/articles/beyond-the-hyperscalers-what-actually-protects-you-31468.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/beyond-the-hyperscalers-what-actually-protects-you/>)

Author: Adam Gordon Bell

Published: 2026-09-16T13:00:00Z

Content type: opinion

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [Cloud](<https://devfeed.tech/topics/cloud.md>), [migration](<https://devfeed.tech/topics/migration.md>), [pulumi](<https://devfeed.tech/topics/pulumi.md>), [Security](<https://devfeed.tech/topics/security.md>), [scaleway](<https://devfeed.tech/topics/scaleway.md>), [Developer Tools](<https://devfeed.tech/topics/developer-tools.md>)

Tags: [aws](<https://devfeed.tech/tags/aws.md>), [azure](<https://devfeed.tech/tags/azure.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [customers](<https://devfeed.tech/tags/customers.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [migration](<https://devfeed.tech/tags/migration.md>), [platform-engineering](<https://devfeed.tech/tags/platform-engineering.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [scaleway](<https://devfeed.tech/tags/scaleway.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

This recorded discussion examines cloud sovereignty, legal and cost concerns for EU companies using major US cloud providers, and the practical tradeoffs of moving to European providers. Three guests discuss provider exposure, encryption and account shutdown risks, migration costs, and whether Pulumi and agentic infrastructure can make future moves easier.

### Source excerpt

Recorded September 3, 2026. Quotes are lightly edited for clarity. Maybe this sounds familiar. You run infrastructure at a company that isn't American. Your workloads are on AWS, Azure, or Google Cloud, probably more than one, because that is what everyone picked. Until recently nobody asked you where the data lives or who can reach it. Now you're getting questions. Legal wants to know what NIS2 means for where your systems run. Someone on the leadership team read that the US government locked the cloud accounts of judges at the International Criminal Court and wants to know if that could happen to you. Finance wants to know why the bill went up again. A customer's security review asked, in writing, which country your data sits in. So now you have questions of your own: If a US court or agency wants my data, can they get it from my provider without involving me? Does putting everything in an EU region change that? The big providers now sell "sovereign cloud" in Europe. Is that different, or a rename? If I encrypt everything and hold the keys myself, am I covered? Could my account be switched off one day? What would I do? Are Hetzner, OVH, and Scaleway usable for real workloads? How much cheaper are they once you count the migration? What should I be building on now so I can leave later if I need to? A migration like this used to be a multi-year project. Does Pulumi and agentic infrastructure change that? Is any of this worth the disruption, or should I leave what works alone? I put those questions to three people who have each dealt with this for real. One of them helps EU companies work out their exposure and builds the tooling to leave. Another has spent fifteen years sizing what cloud actually costs, and thinks most people should stay put. The third moved his company off AWS and onto a European provider. They don't agree on how big the risk is. The full hour is below. Don't just default to the hyperscalers Waldemar Kindler co-founded Think Ahead Technologies, whe

## Set Up Cloud OIDC From the Pulumi CLI

DevFeed: [Set Up Cloud OIDC From the Pulumi CLI](<https://devfeed.tech/articles/set-up-cloud-oidc-from-the-pulumi-cli-19001.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/esc-oidc-setup-cli/>)

Author: Sean Yeh

Published: 2026-09-11T00:00:00Z

Content type: tutorial

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [OpenID connect (OIDC)](<https://devfeed.tech/topics/oidc.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [AWS IAM](<https://devfeed.tech/topics/aws-iam.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [Azure](<https://devfeed.tech/topics/azure.md>), [Google Cloud Platform (GCP)](<https://devfeed.tech/topics/google-cloud.md>)

Tags: [automated](<https://devfeed.tech/tags/automated.md>), [aws](<https://devfeed.tech/tags/aws.md>), [azure](<https://devfeed.tech/tags/azure.md>), [cli](<https://devfeed.tech/tags/cli.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [docs](<https://devfeed.tech/tags/docs.md>), [esc](<https://devfeed.tech/tags/esc.md>), [google-cloud](<https://devfeed.tech/tags/google-cloud.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [iam](<https://devfeed.tech/tags/iam.md>), [identity](<https://devfeed.tech/tags/identity.md>), [oidc](<https://devfeed.tech/tags/oidc.md>), [openid-connect](<https://devfeed.tech/tags/openid-connect.md>), [product](<https://devfeed.tech/tags/product.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [pulumi-cli](<https://devfeed.tech/tags/pulumi-cli.md>), [security](<https://devfeed.tech/tags/security.md>), [terminal](<https://devfeed.tech/tags/terminal.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

This tutorial explains how to use the Pulumi CLI command pulumi env setup to configure Pulumi ESC as an OIDC provider for AWS, Azure, and Google Cloud. It covers interactive onboarding, non-interactive flags for scripts and agents, cloud credentials, account selection, access policies, and automatic creation of identity providers, IAM roles, policy attachments, and ESC environments.

### Source excerpt

Pulumi ESC can act as an OpenID Connect (OIDC) provider for AWS, Azure, and Google Cloud, issuing short-lived, signed tokens that these clouds exchange for temporary credentials. This eliminates hard-coded credentials and improves your security posture. Last year, we introduced an onboarding flow in the Pulumi Cloud console that makes it super easy to configure OIDC for your cloud provider in a few guided steps. We're bringing Pulumi Cloud into the CLI so agents can use its capabilities directly from the terminal, without requiring a human to complete steps in the console. The new pulumi env setup command brings OIDC onboarding to that workflow, with interactive prompts for guided setup and non-interactive flags for scripts and agents. pulumi env setup - how it works Run the command with your desired cloud provider (aws, azure, gcp). For example: pulumi env setup aws The command then asks what it needs to configure your cloud, including your credentials, the accounts to configure, and the level of access. The questions differ per cloud. For AWS, it asks: How to authenticate to AWS. It uses the credentials you already have, or it signs you in with AWS SSO. Which accounts to configure. Which policy to attach to the OIDC role. Choose AdministratorAccess for Pulumi Deployments, ReadOnlyAccess for Pulumi Insights, or any other policy ARN. Then, it will print out the plan: About to configure OIDC for organization my-org: account 111111111111: create role pulumi-esc-oidc-622e86ea-319ba4c675bb3c00-role attach arn:aws:iam::aws:policy/AdministratorAccess create ESC environment my-org/aws-login/sandbox-account-env Proceed? [yes/no] After you confirm, the command creates the identity provider, the IAM role, and the policy attachment in each account. It then creates one ESC Environment per account, with the aws-login provider already configured. Non-interactive setup You can also run the command without interactive prompts by passing in the necessary flags. Each cloud has its ow

## Best Policy as Code Tools in 2026

DevFeed: [Best Policy as Code Tools in 2026](<https://devfeed.tech/articles/best-policy-as-code-tools-in-2026-91257.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/best-policy-as-code-tools/>)

Author: Pulumi Content Team

Published: 2026-08-28T00:00:00Z

Content type: article

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [policy-as-code](<https://devfeed.tech/topics/policy-as-code.md>), [Open Policy Agent](<https://devfeed.tech/topics/open-policy-agent.md>), [pulumi](<https://devfeed.tech/topics/pulumi.md>), [Kyverno](<https://devfeed.tech/topics/kyverno.md>), [rego](<https://devfeed.tech/topics/rego.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Terraform](<https://devfeed.tech/topics/terraform.md>), [Access Control](<https://devfeed.tech/topics/access-control.md>), [versioning](<https://devfeed.tech/topics/versioning.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [blast-radius](<https://devfeed.tech/tags/blast-radius.md>), [block](<https://devfeed.tech/tags/block.md>), [blocking](<https://devfeed.tech/tags/blocking.md>), [ci](<https://devfeed.tech/tags/ci.md>), [code](<https://devfeed.tech/tags/code.md>), [credentials](<https://devfeed.tech/tags/credentials.md>), [database](<https://devfeed.tech/tags/database.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [devops](<https://devfeed.tech/tags/devops.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [engine](<https://devfeed.tech/tags/engine.md>), [general](<https://devfeed.tech/tags/general.md>), [identity](<https://devfeed.tech/tags/identity.md>), [infrastructure-as-code](<https://devfeed.tech/tags/infrastructure-as-code.md>), [policy](<https://devfeed.tech/tags/policy.md>), [policy-as-code](<https://devfeed.tech/tags/policy-as-code.md>), [security](<https://devfeed.tech/tags/security.md>), [tools](<https://devfeed.tech/tags/tools.md>)

### AI overview

Policy as code can block a specific infrastructure change before it takes effect, adding a check beyond limiting an AI agent's credentials. The tools differ in scope and workflow: OPA is a general-purpose Rego engine that requires integrations; Sentinel attaches policies to HashiCorp product runs; Kyverno uses Kubernetes YAML at admission time; and Pulumi Policies evaluates Pulumi deployment previews, with preventative, audit, and limited remediation modes. Checkov combines many built-in IaC scanning checks with custom YAML or Python rules, but relies on a CI gate for blocking. The excerpt also describes Gatekeeper, Conftest, and Cloud Custodian for narrower Kubernetes, CI, and live-cloud governance uses. Tool choice depends on where rules must run, policy authors' language familiarity, and whether the need is deployment blocking or reporting. The excerpt recommends that teams may use multiple tools, since those functions address different stages.

### Source excerpt

Policy as code means writing infrastructure rules as version-controlled code, then having a policy engine evaluate every proposed change against those rules before it takes effect. It matters more as AI agents start proposing infrastructure changes alongside engineers, because a policy engine decides whether a given change is allowed to happen, regardless of who or what authored it. Why AI agents raise the stakes for policy as code An AI agent that can open a pull request against your infrastructure code can also, in principle, propose a change that deletes a production database, widens a security group to the internet, or spins up resources nobody approved. Most of the current conversation about containing that risk focuses on identity: scoping what an agent's credentials can reach, and limiting which systems it can call. That is necessary, and it is not the whole answer. Identity scoping bounds what an agent could touch. It says nothing about what a specific, concrete change will actually do. Policy as code operates at a different point in the pipeline. When a policy engine runs against an infrastructure preview, before anything is created, replaced, or destroyed, it evaluates the real, itemized set of resource changes a specific plan would make, and it can block that plan outright if it violates a rule. That is a stronger and more precise guarantee than credential scoping alone, and it holds whether the change came from a human running terraform apply, a CI pipeline, or an autonomous agent. This is the vocabulary infrastructure and security teams reach for by default when this comes up: bounding the blast radius of a change before it executes, on top of bounding the reach of whoever or whatever proposed it. Pulumi's own documentation on policy as code describes preventative policies this way: evaluated during pulumi preview and pulumi up, blocking a deployment outright when a resource change violates a rule, before that resource is ever touched. For a fuller defi

## Pulumi Kubernetes v4.34.0: CRDs as provider extensions

DevFeed: [Pulumi Kubernetes v4.34.0: CRDs as provider extensions](<https://devfeed.tech/articles/pulumi-kubernetes-v4-34-0-crds-as-provider-extensions-19012.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/kubernetes-crds-as-provider-extensions/>)

Author: Guinevere Saenger

Published: 2026-08-28T00:00:00Z

Content type: release

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [pulumi](<https://devfeed.tech/topics/pulumi.md>), [SDK](<https://devfeed.tech/topics/sdk.md>), [ingress-nginx](<https://devfeed.tech/topics/ingress-nginx.md>), [YAML](<https://devfeed.tech/topics/yaml.md>)

Tags: [cli](<https://devfeed.tech/tags/cli.md>), [crd](<https://devfeed.tech/tags/crd.md>), [extension](<https://devfeed.tech/tags/extension.md>), [extensions](<https://devfeed.tech/tags/extensions.md>), [feature](<https://devfeed.tech/tags/feature.md>), [flag](<https://devfeed.tech/tags/flag.md>), [gateway](<https://devfeed.tech/tags/gateway.md>), [gateway-api](<https://devfeed.tech/tags/gateway-api.md>), [ingress](<https://devfeed.tech/tags/ingress.md>), [ingress-nginx](<https://devfeed.tech/tags/ingress-nginx.md>), [kubeconfig](<https://devfeed.tech/tags/kubeconfig.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [language](<https://devfeed.tech/tags/language.md>), [language-support](<https://devfeed.tech/tags/language-support.md>), [package](<https://devfeed.tech/tags/package.md>), [product](<https://devfeed.tech/tags/product.md>), [providers](<https://devfeed.tech/tags/providers.md>), [pulumi](<https://devfeed.tech/tags/pulumi.md>), [release](<https://devfeed.tech/tags/release.md>), [releases](<https://devfeed.tech/tags/releases.md>), [schema](<https://devfeed.tech/tags/schema.md>), [sdk](<https://devfeed.tech/tags/sdk.md>), [sdks](<https://devfeed.tech/tags/sdks.md>)

### AI overview

Pulumi Kubernetes provider v4.34.0 lets you extend the provider with a Kubernetes CRD manifest using `pulumi package add --extension`. Pulumi generates a custom SDK in the project's `sdks/` folder and records the extension in `Pulumi.yaml`; the CRDs share the existing provider instance and kubeconfig. SDK files can be regenerated with `pulumi install`, and teams may version them or check them into version control. CRDs are supported in all Pulumi languages, including YAML. The excerpt also says migration from `crd2pulumi` can use the new SDK package name without stack state changes, with a no-op migration expected. Availability requires Pulumi v3.255.0 and Kubernetes provider v4.34.0.

### Source excerpt

We're really excited to bring you v4.34.0, the newest version of the Pulumi Kubernetes provider, which includes improved support for Kubernetes Custom Resource Definitions (CRDs). As with any release, we've also shipped standard dependency updates and bug fixes. This provider release includes the newest resources for Kubernetes v1.37.0, which was recently cut. So that in itself is very exciting! But the feature we're proudest of is that you can now extend the Kubernetes provider with any Kubernetes Custom Resource Definition of your choice by passing its manifest file to Pulumi, using the new --extension flag. We believe first-class CRD support in Pulumi is becoming more important than ever. For example, since the retirement of the ingress-nginx controller earlier this year, the recommended path for cluster ingress is Gateway API, which is maintained and shipped as CRDs. Generating a Pulumi SDK for CRDs In your Pulumi project root, run: pulumi package add kubernetes --extension "name=gateway-networking crd-manifest=gateway-api-crds.yaml" You will see the custom SDK appear in a new sdks/ folder, as well as a new parameterization reference in Pulumi.yaml. Single provider instance Your new CRD schema exists as an extension to your existing provider and will be managed under the same provider instance, allowing you to use a single provider configuration and kubeconfig. SDKs as dependencies Additionally, your code no longer needs to ship SDK files as part of the project. The provider extension is referenced in your project file and its SDK, like all dependencies, can be regenerated via pulumi install. You can choose to version the extension SDK, or continue to check the files into version control if you so desire. Full language support, including for YAML Kubernetes CRDs can now be provisioned with Pulumi in all supported languages. Unified CLI experience pulumi package add --extension extends your CRD schema into the Pulumi Kubernetes provider, using the same CLI as any

## Neo Security: Securing Infrastructure in the Agentic Era

DevFeed: [Neo Security: Securing Infrastructure in the Agentic Era](<https://devfeed.tech/articles/neo-security-securing-infrastructure-in-the-agentic-era-19024.md>)

Original publisher: [Read original article](<https://www.pulumi.com/blog/pulumi-neo-security/>)

Author: Joe Duffy

Published: 2026-08-28T00:00:00Z

Content type: release

Language: en

Sources: [Pulumi](<https://devfeed.tech/sources/pulumi.md>)

Topics: [pulumi-neo](<https://devfeed.tech/topics/pulumi-neo.md>), [Security](<https://devfeed.tech/topics/security.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [Security research](<https://devfeed.tech/topics/security-research.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [attack-paths](<https://devfeed.tech/tags/attack-paths.md>), [aws](<https://devfeed.tech/tags/aws.md>), [azure](<https://devfeed.tech/tags/azure.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cloud-infrastructure](<https://devfeed.tech/tags/cloud-infrastructure.md>), [code-analysis](<https://devfeed.tech/tags/code-analysis.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [infrastructure-as-code](<https://devfeed.tech/tags/infrastructure-as-code.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [logs](<https://devfeed.tech/tags/logs.md>), [malicious](<https://devfeed.tech/tags/malicious.md>), [neo-security](<https://devfeed.tech/tags/neo-security.md>), [product](<https://devfeed.tech/tags/product.md>), [production](<https://devfeed.tech/tags/production.md>), [pulumi-neo](<https://devfeed.tech/tags/pulumi-neo.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

Pulumi Neo Security is a research-preview agent that assesses cloud infrastructure for exploitable flaws by analyzing a context graph of resources, dependencies, runtime information, and related cloud context. It first builds a threat model identifying critical assets, externally accessible resources, production data accounts, trust boundaries, and realistic attackers to estimate relative risk and blast radius. It then maps attack vectors, including internet entry points, federation and trust relationships, workload identity, and lateral movement between accounts. The excerpt says findings are intended to form an actionable security posture report and work with existing infrastructure regardless of how it was provisioned, across providers including AWS, Azure, Google Cloud, and Kubernetes. Pulumi says it is beginning with a research preview and will work closely with customers to run it and address findings. The excerpt cuts off during the attack-vector description, so it does not establish the complete three-pass process.

### Source excerpt

Recently, AI systems have started turning up exploitable flaws in code that survived decades of human review. The frontier labs have released useful tools to help uncover many of these flaws through agent-led static code analysis. This is a huge leap ahead, but cloud infrastructure has many exploitable flaws that code analysis alone cannot find. These flaws are often as severe as the ones in code, or worse, and they await discovery by malicious agents on offense. We realized recently we can uniquely help here. At Pulumi, we have complete visibility into your entire cloud estate: infrastructure resources, their semantics, connections and dependencies between them, runtime logs and information, and more -- and have built an entire context graph out of them that is accessible to agents. Thanks to large language models, the cost of analyzing that full context graph is no longer prohibitive. As a result, today we're opening a research preview of Pulumi Neo Security. Neo Security is an agent that can find exploitable flaws in your cloud infrastructure. It starts with a threat model of your cloud estate, and then works systematically through every potential point of attack. The result is a security posture report that is immediately actionable thanks to Pulumi's infrastructure as code technology. Neo Security works on your existing infrastructure regardless of how it was provisioned, across any of our thousands of cloud providers including AWS, Azure, Google Cloud, and Kubernetes. We're releasing it in research preview to begin, so we can work closely with customers to run and address any findings. If you'd like to give it a try, contact us. How it finds attack paths Neo Security's aim is to provide a high-confidence, actionable security posture report. It gets there in three passes. The first builds a threat model, before it looks for anything. It works out what your crown jewels are, which resources are accessible to outside actors, which accounts hold production data, wh

[Next page](<https://devfeed.tech/sources/pulumi.md?cursor=WyIyMDI2LTA4LTI4VDAwOjAwOjAwKzAwOjAwIiwgIjAwNTEyYjZhLTZhMWUtNDEyZi1iMWQ3LTRiMjJmZjM4ZGM4NCJd>)