The New Postman is Here: AI-Native and Built for the Agentic Era

Today, we’re introducing a new Postman platform built for the agentic era, with a full-stack of capabilities to help teams take their APIs from dev to prod for internal, external, and agentic use. It integrates directly with Git-based workflows and introduces several new capabilities: Git-connected Workspaces, an API Catalog that serves as a management plane for APIs and services across an organization, and an updated Private API Network for internal API distribution.

Over the past several months, we have been shipping at a blazing pace, and today marks a dramatic leap forward. We’re consolidating these improvements alongside some entirely new capabilities, all informed by a simple reality: AI agents are driving a platform shift. Similar to what happened with cloud and mobile, this shift is changing what infrastructure needs to look like underneath.

Agents are systems that are built on top of APIs — both deterministic (non-LLMs)  and probabilistic (LLMs). Unlike pre-AI software that followed deterministic code paths, agents take probabilistic actions — they decide at runtime what to call, when to call it, and how to chain calls together. This makes APIs the authoritative interface between agents and the real world. If an agent gets bad data from an API or an API is unreliable, the downstream effects compound quickly.

To succeed in the agentic era, engineering teams need APIs that are reliable, well-documented, and stable enough to be consumed by systems they don’t fully control. At the business level, companies are having to make harder decisions about which APIs to expose, which to protect, and how to price access.  Importantly, these decisions matter more when your API is serving an agent that might call it thousands of times a day rather than an application used by humans.

APIs have always been hard to build. They sit on top of stacks of underlying services, sometimes hundreds of them, and changing them without breaking consumers is a real engineering problem. As APIs become load-bearing infrastructure for agentic systems, getting this right becomes more critical. Postman has been part of the development and testing workflow for APIs across most of this history. What we’ve heard consistently from teams is that they need more: a single place to see all their APIs and services, tighter integration with how they already write and ship code, and the ability to enforce governance and reliability standards without doing it manually at each team.

Millions of developers already rely on Postman today. The new capabilities described below are how Postman meets what agentic development actually requires, for them, and for every team now building the systems that depend on APIs to work.

A new development experience

The new Postman app is Git-Native from the ground up. This means developers can work in Postman on the same branch they’re writing code on, alongside their IDE, and the Git-Native architecture enables Postman to work in offline conditions too.

We are also introducing new code-based local mock servers that can run locally as well as in the test loop with your CI system. This new mocking framework enables a level of flexibility that wasn’t possible before with just static mocking. Mock servers can now be made much more central to the development experience towards designing new APIs or services or stubbing out dependencies.

Postman Specs and Postman Flows are also integrated into the local workflows, and all your assets are versioned alongside your code. The new Collection v3 format makes this practical: instead of JSON blobs, collections are broken into constituent YAML files that are easy to diff, easy for humans to review, and easy for AI agents to read and write.

Expanded multi-protocol support

Modern systems rarely rely on a single protocol, but most tooling still treats each one separately. Postman now lets teams organize HTTP, GraphQL, gRPC, MCP, MQTT, WebSockets, and AI requests in the same collection and automate and validate workflows across HTTP, GraphQL, and gRPC in Collection Runner, with more protocols coming. The result is system-level testing that reflects how systems actually behave end-to-end, without the coordination overhead that comes from validating each part in a different tool.

A more capable Postman CLI

The Postman CLI now lets developers run the same collections, tests, and mocks locally and in CI without reconfiguring workflows for each environment.

Historically, local tests and CI pipelines live in different tools, which means local tests get rewritten for CI, mocked dependencies can’t be reproduced in pipelines, and gaps in coverage show up only after a commit. When the same workflows run in both places, failures surface earlier and the class of bugs that only appear in CI largely disappears.

The CLI also handles publishing, pushing artifacts to the Postman cloud for distribution through private, public, and partner networks.

Postman AI and Agent Mode

Postman AI operates as both a coach and an active participant in your workflow. Developers can use it conversationally, task it with completing workflows end to end, and have it work directly on the codebase to fix errors, generate server stubs, or produce client code. Postman assets can be created from scratch just by pointing AI at your code.

The core of this is Agent Mode, an AI that works across Postman and connected repositories. It acts on your existing data, editing and updating collections, tests, and mocks, and building new ones that follow your organization’s standards. Because it works natively with every Postman capability, developers save time at each step without switching tools or changing how they work.

Additional capabilities can also run through Agent Mode. AI Test Generation automatically adds contract, load, unit, integration, and end-to-end tests to APIs, reducing manual test creation, increasing coverage, and catching regressions before they reach production. AI debugging brings the same intelligence to Collection Runner, monitors, and performance runs. When a test fails, Agent Mode can diagnose the root cause and propose a fix directly in the run results, cutting the time developers would otherwise spend inspecting requests, variables, and environments one by one.

A more organized UI

Postman users told us they want a clean, information-dense design that adapts to their workflows and can expand as their needs change. Our new interface is built around that, with several structural changes that keep the core of the product intact.

The centerpiece of the new UI is a unified workbench. Collections, environments, specs, flows, and local mock servers can now live together and be organized however makes sense for the work at hand. Panels in the left sidebar can be shown, hidden, or created as the workflow demands, so developers can work across everything relevant to their development process at once instead of switching between separate contexts. Agent Mode ties this together by operating across multiple entities simultaneously.

Cloud services, including cloud mock servers, monitors, and insights, also get their own dedicated panel rather than being folded into the same view as local objects.

The history panel has been expanded to include modified elements alongside requests and collection runs, making it easier to track changes while working with Git. And a new file editor lets developers edit and create files directly in the Git folder connected to their workspace. Git workflows are native throughout: there’s a code editor, a terminal, and a new modifications UI for pushing and pulling changes without leaving Postman.

The new API Catalog

Most engineering organizations today have no single place that answers basic questions about their APIs: What APIs do we have? Are they tested? Are they compliant with our standards? How are they performing in production?

This information is scattered across Git repos, CI dashboards, APM tools, wikis, and tribal knowledge. Platform engineering teams spend significant time just assembling a picture of their API landscape, and that picture is usually incomplete and stale by the time it’s assembled.

The new Postman API Catalog solves this. It is a live operational layer for API portfolio management that functions as a system of record that stays current because it is directly connected to where your APIs are built, tested, and run.

The API Catalog gives engineering teams a single pane of glass for every API and service in their organization. Through the catalog, teams can observe their entire API landscape irrespective of the infrastructure those APIs have been deployed into, and across all the environments they run in.

The catalog is not just a list. It incorporates API governance, so central teams can enforce design rules. It provides analytics so leadership can measure API health at scale. And it is built to be AI-native. Using Postman’s Agent Mode, users can talk to the catalog in natural language to understand their system architecture, investigate metrics, or troubleshoot when something breaks.

Example queries

1. “Which APIs in production don’t have an OpenAPI spec?”
2. “Show me all APIs owned by the payments team that failed CI this week.”
3. “What are the upstream dependencies of the checkout service?”
4. “Which endpoints have P95 latency above 500ms in staging?”
5. “Are there shadow endpoints in the user-auth service?”

Agent Mode has access to the full catalog data model, so it can reason across governance, testing, and runtime data in a single query. Users can go from inspecting a problem to implementing a fix instantly.

Postman Private API Network

Postman’s Private API Network has been updated on both the publisher and consumer side.

For publishers, changes from Git now sync automatically to the network via the Postman CLI, so the network stays current without manual updates. Structure is handled through the new Organizations capability: every workspace published to the network is automatically grouped under the team that owns it, keeping things organized as the network grows.

Reporting has also been consolidated. Internal, partner, and public workspace analytics now live in a single destination instead of being spread across multiple pages with inconsistent views. The charts have been cleaned up as well. Engineering managers can get a clear picture of API usage and value across the organization without hunting across different parts of the product.

For consumers, a new UI introduces a purple badge to identify approved workspaces in Search and Agent Mode. Agent Mode is now available across the network surface, so consumers can query documentation and find the right APIs conversationally rather than manually browsing. The result is an internal API landscape that works as a live storefront for both humans and agents, discoverable, governed, and always in sync with the source.

Enterprise Organizations

Organizations give enterprises a way to group multiple Postman teams under a single organization, aligned to how the business is actually structured. Identity, access, and resources are managed centrally, while individual teams retain the autonomy to move at their own pace.

At scale, most enterprises face the same challenges: workspace sprawl, accidental oversharing, and no clear picture of who can access what. With Organizations, org-level governance paired with team-level management means admins get the control and auditability they need without becoming a bottleneck for every team that wants to ship.

Get started with these features today

All of these features (and more) are available starting today, and you can check out our documentation to read more about how they work. If you’re an existing customer, you can upgrade by going Settings (gear icon) > App Settings > Update, or grab the latest version from  our downloads page.

New to Postman? Sign up and start building.