Pulumi Release Notes

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:

1. How to authenticate to AWS. It uses the credentials you already have, or it signs you in with AWS SSO.
2. Which accounts to configure.
3. 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 own flags, so be sure to check pulumi env setup <cloud> --help. Running non-interactively is great for automated use cases or agents!

Example:

pulumi env setup aws \
  --account 111111111111 \
  --policy AdministratorAccess \
  --project my-project \
  --yes

Get started

pulumi env setup ships with the latest Pulumi CLI. To configure your first cloud:

1. Authenticate to Pulumi Cloud with pulumi login.
2. Run pulumi env setup aws, pulumi env setup azure, or pulumi env setup gcp.

See the OIDC configuration docs to learn more about using OIDC with Pulumi, and the Pulumi ESC docs to explore what you can do with ESC.

3.262.0 (2026-09-10)

Features

• [engine] Support importing a pulumi:index:Stash resource. The stash adopts the given id and holds a null value, and the program's configured input then applies as an update #24544

Bug Fixes

• [auto/go] Match wrapped errors in the Automation API error predicates, and unwrap the underlying cause #24197
• [cli/deployment] Stop pulumi deployment settings edit clearing settings it was not asked to change, let --branch and --commit replace one another rather than be combined, and reject --oidc-*-clear=false instead of ignoring it #24525
• [cli] Re-validate an agent account claim marked unavailable instead of trusting the stale marker forever #24495
• [cli] Verify TLS certificates when downloading a template from a URL outside the configured service #24504
• [engine] Propagate --target-dependents and --exclude-dependents through resources read with .get() #24538
• [engine] Run state migrations for aliased remote components #24545
• [engine] Sort resources deterministically when repairing a snapshot #24551
• [engine] Fix state migration ordering for components interleaved with other resources #24552
• [sdk] Allow Automation API project settings to use any language runtime #24559
• [engine] Redact secret property values in violates plan error messages unless --show-secrets is passed #24567
• [cli] Treat a resource provider attached through PULUMI_DEBUG_PROVIDERS as installed, so package installation does not try to download it #24572
• [cli] Install the packages a local plugin directory requires before the plugin is installed and run #24576
• [engine] Avoid a deadlock when a resource provider asks the engine to load another plugin while it boots #24571
• [engine] Allow component state migrations to split managed state using compatible existing resource identities #24582
• [sdk/go] Allow outputs and prompt values to be marshalled into fields typed as input interfaces, such as pulumi.StringInput #24577
• [backend/diy] Make sure disableSSL doesn't override explicitly specified protocols #24593
• [cli] Fix pulumi install for a project that requires a resource provider attached through PULUMI_DEBUG_PROVIDERS #24604
• [cli] Resolve a project's relative plugin and package paths against the project directory when a plugin starts from a subdirectory of the project #24596
• [sdk/go] Report the source position of the user code that calls a generated resource getter instead of the getter body #24602
• [engine] Normalize successor references between chained component state migration callbacks #24598
• [cli/new] Error out on ambiguous template names instead of failing silently #24607

Improvements

• [cli/plugin] Correct pulumi plugin rm help text to note that the CLI re-downloads removed plugins automatically #24618
• [cli] Add --filter to pulumi api list to filter endpoints by keyword #24594
• [cli/new] Warn in interactive pulumi new when cloud credentials are missing or invalid for providers that opt in via the new validateCredentialsOnNew and configurationDocsUrl schema fields #24456
• [sdk/nodejs] Add helper methods to transform ResourceOptions to InvokeOptions #24534
• [cli] Read stack outputs for stack references through the Pulumi Cloud stack outputs endpoint when the service advertises it, instead of exporting the whole deployment #24554
• [sdkgen/python] Replace parver with packaging in generated Python SDKs #24585
• [ci] Skip the unconsumed release-binary rebuild on pull requests #24595
• [engine] Run provider configuration as part of provider create steps so errors are returned associated with the provider resource, not the first resource that uses it #24556
• [backend/service] Improve error messages if default org is invalid #24605

Miscellaneous

• [sdk/dotnet] Upgrade dotnet to v3.113.2 #24590
• [java] Upgrade java to v1.37.0 #24590
• [hcl] Upgrade hcl to v0.17.0 #24590

Took the chance to rename some of the fields here as well, given the TODO.

• // TODO Change to (State, Input)
• Olds, News resource.PropertyMap
• // OldOutputs is the previously persisted outputs of the resource, if any.
• OldOutputs resource.PropertyMap

• // NewInputs are the new inputs for the resource from the program.
• NewInputs property.Map
• // OldInputs are the previously persisted inputs of the resource, if any.
• OldInputs property.Map
• // OldOutputs are the previously persisted outputs of the resource, if any.
• OldOutputs property.Map

Didn't go with the TODOs suggestion of State/Input, but instead with the terminology we're using elsewhere about explicit old/new inputs/outputs.

Summary

pkg/testing/integration assumed a single-digit major version in two places, which broke ProgramTest for the Go and .NET SDKs of any provider at v10 or above.

getSanitizedModulePath matched v\d anywhere in the module path and stripped that substring. For github.com/pulumi/pulumi-gcp/sdk/v10 it found the v1 inside v10 and rewrote the path to github.com/pulumi/pulumi-gcp/sdk/0, so every Go program test resolved its replace directive to a directory that does not exist. It also mangled unrelated paths that happen to contain a vN substring. It now strips a trailing /vN element and nothing else.

The local NuGet lookup used the glob dep+".?..nupkg", where ? matches exactly one character. Pulumi.Gcp.9.0.0.nupkg matched but Pulumi.Gcp.10.0.0.nupkg did not, so the lookup failed with yielded 0 results. The pattern is now dep+".[0-9].nupkg", which accepts any digit count while still refusing to match a longer package name sharing the same prefix.

Part of #24497

Test plan

Added appropriate unit tests - For all changes

Added a test in pkg/engine/lifecycletest - For all engine/protocol changes

Added a conformance test in pkg/testing/pulumi-test-language - For language protocol changes

Added a golden test in pkg/backend/display - For changes to the output renderers

TestSanitizedPkg and TestDepRootCalc gain cases for major versions of an arbitrary number of digits (v10, v123) plus a path with an embedded vN substring. Both fail against the previous implementation, which reproduces the symptoms directly: .../sdk/v10 becoming .../sdk/0, .../sdk/v123 becoming .../sdk/23, and github.com/pulumi/v2fly/sdk becoming github.com/pulumi/fly/sdk. The NuGet glob is now a single inlined expression at its only call site and carries no unit test of its own.

Validation

• make lint — clean
• make test_fast — all pass
• make tidy_fix — clean
• make format — clean
• Relevant SDK tests pass (if SDK changes)
• make check_proto — clean (if proto changes)

One caveat on test_fast: it reports 15 failures across cmd/pulumi/convert and cmd/pulumi/project/newcmd. Every one of them reproduces identically on an unmodified master on this machine, so they are pre-existing and environmental rather than anything this branch introduces. pkg/testing/integration, the package actually changed here, passes in full. No go.mod or proto changes, so tidy and check_proto are no-ops.

Changelog

Changelog entry added.

Risk

Low and confined to the test harness; nothing here ships in the CLI or the SDKs. The behaviour change for existing single-digit callers is that a vN substring is only stripped when it is the trailing path element, which is what a Go module major version always is. Every existing case in TestSanitizedPkg and TestDepRootCalc is unchanged.

Co-authored-by: Claude Opus 5 [email protected]

3.261.0 (2026-09-02)

Features

• [engine] Support state migration callbacks on resource registrations #24328
• [cli/env] Add pulumi env setup {aws,azure,gcp} to configure cloud OIDC trust and create the ESC environments that use it #23911

Bug Fixes

• [engine] Report a clear error instead of panicking when the stack's state contains a custom resource with no ID #24438
• [cli] Show the agent account's claim URL instead of an inaccessible View Live link when running on ephemeral agent credentials #24476
• [pcl] Fix a crash when binding a schema property with an integer constant value #24480
• [cli/policy] Avoid hanging when policy pack fails to start up #24492
• [pkg/testing] Fix ProgramTest for providers whose Go module or NuGet package has a double-digit major version #24499
• [sdk] Fix serialization of secret unknowns in NodeJS, Python and PCL #24500
• [engine] Ignore internal property keys (those starting with an underscore) when generating and checking update plans #24532

Improvements

• [sdkgen] Generate precise Python output types for discriminated unions. An array of a union was typed Sequence[Any] and a scalar union Any, while the matching getters on the generated Args classes were already typed #24485
• [sdk/python] Resolve a union value to its member by matching the value's wire shape, so unions whose members carry no constant properties serialize and translate with the right member's property names #24484
• [sdkgen/python] Accept a generated output type wherever the classes-and-dicts input types accept its Args class or TypedDict, so a resource's output can be passed to another resource's input without a type error #24507
• [engine] Send previously persisted outputs to a provider's Check on update, gated by a new sends_old_outputs_to_check handshake capability #24524
• [sdk/python] Add helper methods to transform ResourceOptions to InvokeOptions #24533

Miscellaneous

• [java] Upgrade java to v1.36.3 #24509
• [yaml] Upgrade yaml to v1.38.5 #24509
• [sdk/dotnet] Upgrade dotnet to v3.113.1 #24512

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 other Pulumi operation. It generates validated, schematized types that will be discoverable with autocomplete tools in your codebase.

Migration from crd2pulumi

If you’ve been using crd2pulumi in the past, pivoting to using the new provider extension is possible by referencing the new SDK package name in your Pulumi program, without any changes to your stack state. Migrating should result in a seamless no-op on pulumi up. Read more in Migrating from crd2pulumi.

Available from Pulumi v3.255.0 and the Pulumi Kubernetes provider v4.34.0.

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, where the trust boundaries sit between the internet, your workloads, and the identities those workloads carry, and which attackers are realistic for your organization. That is what gives it relative risk and blast radius. Without it, a development sandbox would be treated the same as a production database.

Working from that model, the second pass maps attack vectors: internet entry points, federation and trust relationships, workload identity, lateral movement between accounts, data and secret reachability, and the ways those combine. A resource matters only insofar as an attacker can use it. The goal is to find, for each misconfiguration, the worst outcome it enables.

The third pulls together six planes of evidence at once, each living in a different system:

• Resource inventory. The discovered infrastructure inventory across all cloud accounts, regions, and resource types. For example: AWS S3 buckets and EC2 VMs, GKE clusters and the Kubernetes resources within them, Azure functions, Cloudflare CDNs, Snowflake data warehouses, and even hybrid and private cloud resources. This includes resources provisioned outside of IaC.

• The reference graph. This tells Neo which workload carries which identity, which identity reaches which data, and which stack manages which discovered resource. Neo Security reads this plane through the Context API we shipped earlier this week: a single query walks relationships across the estate and returns every result with the path that reached it.

• Intent. When available, Neo reads the infrastructure code that created a resource, whether Pulumi or Terraform IaC, for the semantics a cloud API doesn’t know about: comments surrounding resources, the resource declarations and relationships, logic and naming, code commit and review history, and more.

• Runtime state. Information that isn’t statically known from code and infrastructure metadata. This includes logs and metrics, uptime information and boot logs for servers, network traffic, and more. This is enabled by Neo having access to any tools a platform engineer would.

• Policy and compliance results. Pulumi’s discovery and governance capabilities ship over 150 built-in policies, many of them security rules, mapped to CIS Controls, NIST SP 800-53, HITRUST CSF, and PCI DSS. Enterprises can also write their own. Neo Security uses existing scanned resources and their violations as well as the policy definitions to discover potential risks in the infrastructure beyond known violations.

• The provider’s own answers. Some questions configuration cannot settle, so Neo asks the cloud directly: Access Analyzer for external reachability, public-access checks on storage, and policy simulation for whether a principal can actually perform an action. This is what resolves the permissions and firewall rules that survive once every overlapping rule, boundary, and service control policy has been applied.

Neo uses this information to build a model of your estate and home in on validated paths. It proves or refutes each attack vector, then ranks what survives by severity and confidence. The result is a short list, each entry carrying its evidence and, where source is available, a fix as specific lines of code. The analysis deeply understands each cloud’s identity model, networking, and data services well enough to resolve effective permissions and firewall rules and to ask the providers directly. The assessment phase is read-only throughout.

Findings become pull requests

Most security tools stop at telling you something is wrong, which leaves the hardest part — remediation — as an exercise for the reader. Pulumi already declares and applies infrastructure change, so a proven finding becomes a proposed diff, a preview of what would change, and a pull request for a person to review. Remediation is the only part that writes anything, and only ever a proposed change in a repository, with deployment left to your existing reviewed workflow.

What a report looks like

We have worked with several teams to run Neo Security against real production estates of different shapes and maturity, and it repeatedly found critical vulnerabilities the owners did not know existed. A single run reconciles thousands of managed resources against the account’s discovered inventory across every region in use.

Here are example findings, anonymized and generalized from real runs:

1. Deployment federation role grants administrator access with no subject-claim condition — critical severity, high confidence
2. Build role trusts source-control OIDC with a wildcard on the branch claim — high severity, confirmed confidence
3. Build policy grants iam:AttachRolePolicy on every role in the account — high severity, confirmed confidence
4. Test Kubernetes cluster API endpoint reachable from any address — high severity, confirmed confidence
5. Security groups named for production allow all TCP and SSH from 0.0.0.0/0 — high severity, confirmed confidence
6. Public compute instance with IMDSv1 and suspected secrets in user data — high severity, medium confidence
7. Load balancer HTTP listener forwards API requests without enforcing TLS — medium severity, high confidence
8. CDN connects to its origin over HTTP-only, exposing auth headers in transit — medium severity, high confidence
9. Static access key for the mail-sending user, unrotated for over a year — medium severity, high confidence
10. Mail-sending policy allows send-as on any verified identity — medium severity, high confidence
11. Database snapshot shared with an account outside the organization — medium severity, confirmed confidence
12. Analytics tool auto-provisions any account on the corporate domain — medium severity, medium confidence
13. No management-plane audit trail defined in IaC — low severity, high confidence
14. No WAF on the internet-facing load balancer or CDN — low severity, high confidence

The implications of these example findings range from complete production account take-over, to poor encryption practices that put sensitive data at risk, to improperly authenticated email services that could be abused for phishing campaigns, to static unrotated keys that leave the account open to risks should it leak, and many other unfortunate outcomes. Each comes with a severity and risk so you can prioritize accordingly, and Neo works to exclude disproven findings and those without consequence.

Getting a scan

We have been impressed what the combination of the latest frontier models, the unique context Pulumi has across several dimensions of your infrastructure, and giving the agent deep security domain expertise have been able to produce. We hope it helps the world of infrastructure get more secure.

Pulumi Neo Security is open now to a small group of invited customers, and the initial scan is free during the research preview. We’re looking for estates with real complexity and risk: multi-cloud and multi-account, a good mix of resource types, IaC and non-IaC resources, and those for which their infrastructure security is paramount.

Attackers are going to point agents at cloud infrastructure next. We would rather you find these problems first and we want to help. If you want to try a scan, get in touch.

3.260.0 (2026-08-28)

Features

• [cli/deployment] Make pulumi deployment settings get render every source kind and show environment variable values, changing the --output=json shape of environmentVariables from a list of names to a list of objects #24284
• [sdk/go] Support Go 1.27 #24401
• [cli/state] Add pulumi state promote to turn stateful snippets into Pulumi program code #24453

Bug Fixes

• [engine] Replace resources whose deletedWith target is being replaced, instead of leaving them orphaned in state #23818
• [sdk/python] Serialize typed object stack outputs with their wire-format (camelCase) property names, matching other language SDKs #24246
• [cli/neo] Cancelling a task now interrupts a running local tool call instead of waiting for it to finish #24268
• [programgen/python] Access schema properties whose names contain hyphens as attributes under their Python names instead of subscripting #24300
• [programgen/go] Generate valid struct field names for properties whose names contain hyphens #24300
• [sdkgen/nodejs] Quote property names that are not legal identifiers (e.g. kebab-case) in generated declarations and use bracket access for them #24300
• [cli/neo] Cancelling a local tool call no longer leaves the TUI stuck on "Thinking..." with input blocked #24318
• [sdk/go] Use resolved environment names when evaluating ESC imports #24375
• [codegen/pcl] Allow output-typed values for the id attribute of a read resource #24386
• [sdkgen/nodejs] Register resolvers for output-only properties in generated Resource.get so they resolve as unknown during preview when the id is unknown #24386
• [engine] Avoid replacing imported resources when an input changes from plain to a secret or output-wrapped value with the same inner value #24387
• [backend/diy] Keep DIY backend stacks readable when checkpoint compression transitions fail #24383
• [cli/stack] Give a clearer error message when selecting a stack by name outside a directory with a Pulumi.yaml project file #24394
• [sdk/python] Propagate runtime context across thread boundaries #24403
• [programgen/python] Name plain function input object types without the Args suffix, matching the name the generated SDK exports #24440
• [cli/new] Reject zip template entries that resolve outside the extraction directory #24447
• [cli/package] Keep a package's pluginDownloadURL in SDKs regenerated by pulumi install #24432
• [sdk/python] Preserve all providers passed to remote components in Python programs #24443
• [sdkgen] Apply schema defaults to generated Python and Node.js function inputs #24452
• [programgen/python] Mark required component inputs as required in generated Python TypedDicts #24459
• [programgen/python] Add type annotations for config variables default values coming from invokes #24464
• [programgen/python] Generate valid Python when a component with inputs instantiates another component #24466
• [cli/neo] Stop the running local tool immediately when a Neo task is cancelled and report it as cancelled #24470
• [programgen/python] Support final argument expansion for min and max in Python programs #24471

Improvements

• [cli] Treat adjacent character swaps as a single typo when suggesting commands #23899
• [sdk/python] Correctly resolve discriminated unions by their tag #24352
• [sdk/python] Allow transforms to be mocked #24406
• [sdk/nodejs] Allow transforms to be mocked #24415
• [sdk/go] Allow transforms to be mocked #24416
• [sdkgen] Allow hyphens in the member segment of tokens, so resource, object type and function names can be kebab-case #24440
• [cli] Print secret provider information with other stack information #24430
• [auto/python] Allow refresh, preview_refresh, and preview_destroy to request rich diffs #24445
• [engine] Cache provider mapping results on disk so repeated plans do not boot a provider to re-fetch an unchanged mapping #24462
• [sdk/python] Improve stack traces for providers #24465

Miscellaneous

• [sdk/dotnet] Upgrade dotnet to v3.113.0 #24441
• [java] Upgrade java to v1.36.2 #24441
• [yaml] Upgrade yaml to v1.38.4 #24441

Answers that span all your infrastructure

Every platform team fields the same questions: What is running? What breaks if we change this? What can we safely delete? The answers exist, but they’re scattered across state files, cloud consoles, and the memories of whoever set things up. Today we’re launching the Pulumi Context API, which connects what Pulumi knows about your infrastructure into a single graph you can query. It’s designed agent-first: Pulumi Neo, our infrastructure agent, uses it out of the box, and the API itself teaches any agent what it needs to know to get started. It’s available in preview for organizations on the Enterprise and Business Critical editions.

Pulumi already holds a detailed picture of your infrastructure. It knows the resources your programs manage, the dependencies between them, how stacks consume each other’s outputs, and which resources in your cloud accounts Discovery found outside IaC entirely. Each of those views is useful on its own. Now, the Context API lets you ask questions that cut across all of them:

• Impact: Which stacks are affected if we upgrade this provider? If this stack changes, what consumes its outputs?
• Coverage: How much of our infrastructure lives outside IaC, and in which accounts?
• Cleanup: Which stacks have no dependents and are candidates for retirement?

Each of these can be answered with a query against a graph that covers your resources (both Pulumi-managed and discovered), your stacks, and the relationships that connect them.

A query is a JSON document with a handful of clauses. anchor names the starting nodes, traverse walks relationships from there, and return picks what comes back. To run one, POST it to https://api.pulumi.com/api/insights//graph/query, or use the CLI: pulumi api GraphQuery -F orgName= --input query.json. Here’s a query that finds every resource that’s managed by an AWS provider older than version 7.0.0:

{ "anchor": { "nodeType": "resource", "match": { "type": "pulumi:providers:aws", "fields": { "provider_version": { "op": "lt", "value": "7.0.0" } } } }, "traverse": [ { "edgeTypes": [ "provided_by" ], "direction": "in", "depth": { "min": 1, "max": 1 }, "alias": "managed" } ], "return": { "select": [ "anchor", "managed" ] } }

And here’s the response, trimmed to a few nodes and fields:

{ "nodes": [ { "id": "urn:pulumi:prod::payments::aws:rds/instance:Instance::payments-db", "nodeType": "resource", "frontier": [ "managed" ], "type": "aws:rds/instance:Instance", "stack": "prod", "project": "payments" }, { "id": "urn:pulumi:prod::payments::aws:ec2/vpc:Vpc::payments-vpc", "nodeType": "resource", "frontier": [ "managed" ], "type": "aws:ec2/vpc:Vpc", "stack": "prod", "project": "payments" }, { "id": "urn:pulumi:prod::payments::pulumi:providers:aws::default_6_0_4", "nodeType": "resource", "frontier": [ "anchor" ], "type": "pulumi:providers:aws", "stack": "prod", "project": "payments" } ], "edges": [ { "from": "urn:pulumi:prod::payments::aws:rds/instance:Instance::payments-db", "to": "urn:pulumi:prod::payments::pulumi:providers:aws::default_6_0_4", "type": "provided_by" } ], "pageInfo": { "resultCount": 5 }, "meta": { "resultMode": "exact", "visibility": "complete", "schemaVersion": "2026-08-25" } }

Each node shows the traversal step that reached it with the frontier field. In this example, the anchor is the outdated provider and the resources are managed by it. The meta fields tell you whether the answer is complete: resultMode flips to truncated if a size limit capped the results or the search backend answered partially, and visibility is trimmed if your RBAC permissions hid part of the graph. A continuation token appears in pageInfo if the answer was split into multiple pages.

Ask Neo, or bring your own agent

We expect AI agents to be the primary users of the Context API. Pulumi Neo uses it out of the box: ask Neo what breaks if a stack changes, and it queries the graph on your behalf, with the permissions of the user who invoked it.

Any other agent, whether that’s Claude Code, Cursor, Codex, or your own automation, can learn the API in one request. The schema endpoint returns a Markdown document (“primer”) covering the node and edge vocabulary, the full query grammar, and examples. Fetch it with the Pulumi CLI:

pulumi api GetGraphSchema -F orgName=my-org

or over plain HTTP:

curl -H "Accept: text/markdown" \
-H "Authorization: token $PULUMI_ACCESS_TOKEN" \
https://api.pulumi.com/api/insights/my-org/graph/schema

The primer is the complete reference for the query language. To onboard an agent, have it fetch the primer with pulumi api GetGraphSchema -F orgName=. Putting that command in your AGENTS.md or CLAUDE.md means the agent pulls a fresh copy whenever it needs one; the primer evolves with the API. From there, your agent composes queries from natural language questions and runs them with pulumi api GraphQuery. Most validation errors list the legal values inline, so an agent that re-reads the primer on rejection can correct its own queries.

Available in preview

The Context API is available now for every organization on the Enterprise and Business Critical editions. The pulumi api commands shown here need Pulumi CLI v3.243.0 or later. Access uses the same permission as Resource Search, so if you can search resources in the console today, you can query the graph. Results are trimmed to the caller’s permissions. While the API is in preview the contract may change; any breaking changes will be announced in the changelog.

The graph will grow

This launch is a first step. The graph vocabulary is designed to grow without breaking existing consumers, and we plan to bring in more of what Pulumi knows: Pulumi ESC environments, so you can trace which stacks a configuration or secret change reaches; teams and roles, so the graph knows who owns what; cloud accounts; and service catalog concepts from Pulumi IDP, our internal developer platform.

Get started

If your organization uses Neo, it already knows about the latest graph schema. For any other agent, tell it to fetch the primer with pulumi api GetGraphSchema -F orgName=. Then, start asking questions about your infrastructure graph using natural language.

Give it a try today, and share your feedback in the Pulumi Community Slack or through your account team. If there’s a question you want answered that the graph doesn’t handle yet, tell us. That will shape what we build next.

3.259.0 (2026-08-19)

Features

• [cli/new] Show a single confirmation of project, stack, and config defaults in interactive pulumi new instead of prompting for each value #24223
• [cli] Introduce PULUMI_DEFAULT_ORGANIZATION to be able to set the default org #24384

Bug Fixes

• [cli/stack] Announce Created stack when creating a stack against the Pulumi Cloud backend #24280
• [cli] Retry pulumi neo cancellation requests that the service rejects and keep Esc responsive instead of showing "Cancelling..." forever #24267
• [cli/import] Generate a component resource definition when importing local components #24294
• [auto/nodejs] Remove Node.js Automation API output buffer limit #24333
• [sdk/go] Always emit the value and environment keys when serializing esc.Value and esc.Range, matching the fields the ESC OpenAPI contract marks required #24346
• [engine] Fix the engine returning extension package refs for non-parameterised packages against the same base #24347
• [cli/neo] Fix approval replies and mode changes being silently dropped when the outbound event queue is full #24370
• [codegen/go] Fix nondeterministic Go program codegen for objects that mix null and typed properties #24366
• [cli/do] Keep snippets when delete fails, so delete can be retried #24271
• [cli/package] Report every schema validation error when pulumi package add fails to bind a package schema #24367
• [programgen/python] Fix casing of local component outputs #24379
• [cli/policy] Make policy group ls respect the default org #24385

Improvements

• [cli] Explain which state backend pulumi login failed against, where that backend was configured, and how to change it #24322
• [backend/diy] Report the state backend URL as configured when it cannot be opened, adding the resolved form when normalization changed it, and name a local path a state directory rather than a bucket #24335
• [sdkgen/python] Type constant properties as Literal[value] instead of their primitive type #24358
• [cli/plugin] Add --parallel flag to pulumi plugin install #24369
• [cli] Fix progress bar rendering for parallel plugin installs #24372

What

Guided interactive pulumi new shows the proposed project name, description, stack name, and resolved config in a single confirmation block and asks Do these look good?, instead of prompting for each value one question at a time.

pulumi-new-demo.mp4

Why

Nearly every prompt in the guided flow has a sensible default, so the common path is pressing Enter repeatedly. One confirmation lets that path finish in a single keystroke while keeping every value editable for anyone who wants to change something.

How

The flow lives in confirm.go as a confirmedNew value. Accepting creates the project immediately; choosing Change these values re-runs the familiar sequential prompts, pre-filled with the values just shown (config keys declared without a namespace are re-resolved if the project name changes). The guided path is gated on no template argument, no --yes, and an interactive terminal — outside that, and when the default project name is unusable, the sequential prompts own the run unchanged, so scripted and CI usage is untouched. Stack creation and config save go through the same code as the sequential flow, quieted only where the confirmation already showed the value, and Ctrl-C at the confirmation exits with a friendly message.

The TestGuidedNew* suite covers accepting (no further prompts), declining (pre-filled re-prompts), --config-fixed keys never re-asked, secret config masked and encrypted, no-default config asked before the block, friendly interrupt, and fall-through on a colliding default name.

References

Builds on #24320 (config-prompting and stack-creation refactor) and #24280 (Quiet stack creation), both merged

Co-authored-by: Claude Fable 5 [email protected]

3.258.0 (2026-08-17)

Features

• [cli] Add opt-in encryption of stored credentials with a key protected by the operating system, selected with PULUMI_CREDENTIAL_STORE #24212
• [cli/new] Ask for a cloud provider and language in interactive pulumi new instead of listing every template #24226
• [sdk/go] Add policyx.NewStackValidationPolicy and wire up the analyzer's AnalyzeStack RPC so Go policy packs can validate the full stack #24232

Bug Fixes

• [sdkgen/go] Generate valid Go package clauses for schema modules whose names contain hyphens #24288
• [sdkgen/nodejs] Export schema modules whose names contain hyphens under a valid sanitized identifier, including their type namespaces #24288
• [cli/import] pulumi preview --import-file no longer emits unknown values, and pulumi import rejects files that contain them #24261
• [auto/python] Add missing program argument on preview_refresh and preview_destroy stack methods #24274
• [cli/new] Fix cloning templates and repositories into paths containing symlinks with absolute targets #24329
• [cli/do] Fix global project lookup #24334

Improvements

• [sdk/python] Use the resource monitor's advertised feature set consistently throughout the Python SDK #24308

Miscellaneous

• [cli] Rewrite the pulumi login and pulumi logout help text to cover all supported state backends and document PULUMI_ACCESS_TOKEN, --default-org, and --interactive #24319

3.257.0 (2026-08-13)

Features

• [cli] Offer to create a first project after logging in to an account with no stacks #24133
• [cli/do] Auto-assign identifiers to existing stack resources in pulumi do input expressions, and add pulumi do show-resources to list them #24184
• [cli/do] Make "pulumi do <pkg> <resource> patch <name> work in stateful mode, overlaying the supplied inputs onto the existing snippet" #24295
• [cli/state] Implement pulumi state get to show individual resources #24191
• [cli/do] Fall back to an auto-created project and stack under PULUMI_HOME when pulumi do is invoked outside of a Pulumi project #24231

Bug Fixes

• [sdkgen/go] Generated output-form invokes pass their arguments to the core SDK without resolving them first, so invoke dependencies can be inferred from arguments; generated SDKs now require pulumi SDK v3.255.0 or later #24060
• [cli] Make 'pulumi stack history events --summary report the program errors from the language host #24111
• [cli/cloud] pulumi api: repeated -H/--header values for the same header name now all reach the wire, instead of each one silently overwriting the last #24180
• [cli/package] Maintain --server when adding to the packages section of Pulumi.yaml #24189
• [sdk/go] Fix panics in hooks to not crash the entire process #24218
• [programgen/go] for expressions are now generated as Go loops #24228
• [programgen/go] Fix invalid _ := index statement emitted for resources with a numeric range whose value variable is unused #24227
• [sdk/python] Report an error instead of hanging when a Python resource depends on its own parent #24230
• [sdkgen/go] Generate the missing Go input types for resource input properties that are deeply nested collections of object types #24236
• [programgen/go] Rename properties that collide with reserved names (e.g. elementType) the same way SDK codegen does, instead of emitting uncompilable code #24235
• [cli/display] Show the value being added when a refresh or provider diff reports an added property #24245
• [cli/plugin] Track when a plugin was last run so pulumi plugin ls reports an accurate last-used time on all platforms #24251
• [engine] Show secrets in diff display when --show-secrets is passed #24253
• [cli] Exit promptly when a command is cancelled while an HTTP request is being retried #24276

Improvements

• [sdk/nodejs] Improve error message when resource registrations are still pending when pulumi exits #24082
• [cli] Pass the invoked command (e.g. pulumi new) to the browser-based login/signup flow so Pulumi Cloud can attribute signups to the command that triggered them #24192

Miscellaneous

• [sdkgen] Extension-parameterized packages now namespace their resource and function tokens under their own package name rather than the base provider's #24143
• [java] Upgrade java to v1.35.0 #24202
• [backend/diy] The deprecation warning is now an error. PULUMI_DIY_BACKEND_IGNORE_DEPRECATION_WARNING is now PULUMI_DIY_BACKEND_IGNORE_DEPRECATION_ERROR. #24216
• [java] Upgrade java to v1.36.0 #24243
• [sdk/dotnet] Upgrade dotnet to v3.111.1 #24249