POST/CON 25 Keynote Recap

June 4, 2025

Imagine this: the AI landscape is a massively multiplayer open world role playing game—on expert mode and Postman is the co-op partner you need to win. From powerful new tools to agent-ready workflows, here are the biggest takeaways from the POST/CON 25 stage.

At a glance: Product highlights from POST/CON 25

No time for the full quest? Here are some of the highlights:

Spec Hub: Structure your API design at scale—with governance built in
Postman API Network: More features to distribute your API like a product to developers and agents
Postman Insights (Open Beta): Track how your APIs are used in real-time and evolve with confidence
AI Tooling Suite: Build agent-ready tools, automate workflows, and scale AI development with Postman’s new suite of intelligent features
Agent Mode (Join the waitlist): Automate workflows, debug requests, and move faster with your new AI teammate
Postman Ecosystem (Preview): Bring essential tools directly into your workspaces to accelerate development

Watch the full keynote here:

Welcome to the new game mode

Software development today isn’t just fast-paced—it’s multiplayer and machine-powered. Teams are building APIs across stacks and orgs, and increasingly, not just for humans, but for AI agents that act autonomously.

That’s why we structured our POST/CON 25 keynote like a game—because building for today’s AI landscape feels like an MMORPG…with no easy mode and no pause button.

Each level reflects a stage of the modern API lifecycle—from design and testing to orchestration and automation. And at every stage, developers face real challenges: fragmented workflows, disconnected tools, unpredictable agents. Postman’s latest releases are built to meet those challenges—helping you move faster, scale smarter, and stay in control.

Here’s what we launched at POST/CON 25—and how it upgrades your dev stack for the AI era.

Level 1: The Fragmented Workflow

You want to build an API. But first, you’ll need to hunt down a spec from a dusty Confluence page, a test script in someone’s fork, and a doc last updated “final_v4_REAL_THIS_ONE.pdf.”

We called this boss the Disconnected Stack. And it’s been slowing down teams for too long.

Here’s how Postman helps you beat it so that you can build, test, and deploy APIs faster with fewer handoffs, better alignment, and specs that scale.

Mission 1.1: Design, Prototype, Iterate

Objective: Turn an idea into runnable APIs your team can build on, fast

Collections: Your starter kit for designing APIs by doing

Postman Collections let you design, document, test, and share real API workflows—before the backend is even built. They’re structured, executable, and instantly shareable.

You can mock endpoints, add examples, and validate behavior—all in one place. That means frontend teams can start building while backend teams are still sketching out logic.

No more spec drift. No more guessing. The result? Faster cycles, fewer blockers, and a consistent foundation teams can actually build on.

npm and JSR Support: Bring your favorite packages into your API workflows

Postman now supports external packages for dynamic request handling directly inside the API Client. Whether you’re transforming payloads, validating data, or enhancing test logic, you can do it with the tools you already use.

The result? Cleaner scripts, faster iteration, and fewer jumps between tools.

VS Code Extension: Build and test APIs inside your editor—no alt-tabbing required

Postman fits right into your development environment. With our updated VS Code extension, you can design and test APIs without breaking focus. Import .env files, reuse test scripts, and keep your collections up to date—all from inside VS Code.

The result? Fewer errors, tighter feedback loops, and more focus for every dev.

Once you’re ready to go from prototype to production, it’s time to load the next mission.

Mission 1.2: Build, Test, Deploy

Objective: Define production-grade specs, keep work in sync, and ship with confidence

GitHub Integration: Keep your specs and source in sync—automatically

Sync collections with your repo in real-time. You can pull in changes, run tests locally or in CI/CD, and even review pull requests with visual diffs.

Everyone—QA, backend, partners—stays on the same page. This means faster reviews, fewer regressions, and smoother handoffs from code to production.

Jira Cloud Integration: Log and track API issues right from Postman

Catch a bug in a request? Create a Jira Cloud issue with pre-filled context in one click. Track its status without leaving your workspace. It’s issue reporting, streamlined.

The result? Faster triage, clearer context, and fewer bugs slipping through the cracks.

Spec Hub: Structure your API design at scale—with governance built in

When your API outgrows ad-hoc collaboration, Postman gives you Spec Hub: a dedicated space for writing OpenAPI and AsyncAPI specs with validation, live previews, and versioning. And because it syncs with collections, updates propagate automatically—no manual upkeep required.

This means less drift, better compliance, and specs that actually keep up with your teams.

Now your API is:

Designed collaboratively
Built with clear expectations
Tested before code ever ships
Deployed with confidence

You’ve taken down the Disconnected Stack. But alignment is only the beginning.

Now it’s time to scale your impact, by making your APIs discoverable, adoptable, and ready for change.

Level 2: The Distribution Disconnect

Even the best-built API won’t make an impact if no one can find it. The Invisible API lurks in outdated wikis, buried docs, and broken onboarding. Teams fly blind. Partners miss changes. Agents stall.

To beat this boss, distribution has to become productization—not a side quest. Here’s how Postman helps you scale adoption, reduce duplication, and stay ahead of change across teams, partners, the developer community, and AI agents.

Mission 2.1: Distribute and Collaborate

Objective: Help teammates, partners, other devs, and agents discover, understand, and adopt your APIs

Organizations (Private Beta): Structure your teams like your company actually works

Flat team structures create sprawl, oversharing, and confusion. Organizations lets you group teams by department, apply role-based controls, and delegate admin rights at scale.

It brings clarity, security, and control as Postman usage grows across your org. Private beta coming soon for Enterprise customers.

Once your org is unified, the next step is reuse. The Private API Network lets teams promote stable, well-documented APIs to a shared internal catalog, so others can discover and build on them.

Less duplication. More reuse. No more “didn’t we already build this?”

Slack + Microsoft Teams Apps: Keep your team updated—right where they already work

With real-time API activity alerts in chat, teams get notified the moment something changes—no follow-up threads or missed updates. Comment, fork, share context, and stay in flow—without ever leaving Slack or Teams.

This means faster feedback loops, fewer silos, and smoother handoffs across teams.

Partner Workspaces: Co-build with partners—without stale zip files or email threads

If your API is powering co-branded features, Partner Workspaces let you build, test, and debug together. Live collections. Secure access. Real-time updates.

And now with SSO, access controls, and a central Partnerships page, managing external collaborators is easier and safer than ever.

This means faster onboarding, stronger collaboration, and less risk when working across orgs.

Postman API Network: Distribute your API like a product—to developers and agents around the world

With 100,000+ APIs and 18,000 publishers, the Postman API Network is the world’s largest hub for public and partner APIs. Verified teams, featured placements, and onboarding tools help your API go global.

This means broader reach, faster adoption, and a trusted first impression—whether your user is human or agent.

Notebooks (Part of Postman API Network): Turn docs into interactive, end-to-end tutorials

Onboarding takes more than a README. Notebooks combine documentation, examples, and live calls into one seamless flow. A dev—or an AI agent—can see how to authenticate, see how requests behave, and test workflows in context.

This means faster onboarding, fewer support tickets, and APIs that are easier to adopt—by humans and agents alike.

Activity Feeds (Part of Postman API Network): Keep API consumers in sync—before things break

When your API evolves, your consumers should know instantly. Activity Feeds alert them to new versions, added endpoints, or breaking changes—and surface those updates across Postman, Slack, and Teams.

This means fewer surprises, smoother updates, and more reliable integrations—no matter who’s consuming your API.

Your API is used by teams, built on by partners, explored by the community. You’ve made it discoverable, now comes the next mission.

Mission 2.1: Monitor and Evolve the API

Objective: Stay in control of your live system—no matter who’s calling your API

Postman Insights (Open Beta): Track how your APIs are used—and evolve with confidence

With one step, drop in the Insights agent and get real-time visibility into your API’s traffic, behavior, and performance—without configuring dashboards or wiring up telemetry.

The result? Faster root-cause analysis, fewer fire drills, and more reliable APIs in production.

Repro Mode (Part of Insights): Debug failures instantly—using the actual failed request

No more guesswork. Repro Mode captures the full request—headers, auth, payload—and opens it directly in the Postman request builder. Click. Investigate. Fix. All in the same workspace.

This means faster resolution, less back-and-forth, and happier teams on both sides of the bug.

Postman Monitors: Set API patrols to detect issues before they reach users—or agents

Create monitors to check endpoints every few minutes and alert you on failure. It’s like having scouts deployed across your systems, keeping workflows safe—even when no one’s watching.

The result? Fewer outages, faster recovery, and more confidence in every deployment.

After beating Level 2, your API is:

Discoverable across your org and beyond
Adopted by teammates, partners, and external devs
Monitored and evolving with real-time feedback
Agent-ready—with onboarding flows and machine-readable structure

You’ve made your APIs discoverable, adopted, and reliable. Now it’s time to bring it all together—where design, distribution, and automation converge to power intelligent systems.

Level 3: The Orchestration Crisis

Now, the game changes. AI agents don’t just hit endpoints—they expect structure. One bad spec or broken token, and everything stalls.

This is the Inconsistent System: where workflows break, agents hallucinate, and devs debug things they never built. To beat this boss, you need more than documentation, you need orchestration.

This isn’t just a harder level, it’s a whole new game mode. Postman is helps you build intelligent systems that scale with teams and with agents

Mission 3.1: Build AI Tools from the APIs You Already Have

Objective: Turn your collections into agent-ready tools

AI Agent Builder: A unified suite for building and deploying intelligent agents

Postman now includes an endgame toolkit for building agents at scale—without jumping between tools or maintaining custom code. From configuration to deployment, the AI Agent Builder brings everything together in one seamless workflow.

This means faster agent delivery, less custom code, and a clear path from prototype to production.

Model Context Protocol (MCP) Server Generation: Turn any existing API into an MCP server with a single click

MCP Server Generation turns your collections into structured, agent-consumable tools. It provides context, access rules, and schemas—so agents don’t guess what’s possible. They know. And they execute accordingly.

This means faster setup, safer automation, and a smoother path to production-ready agents.

MCP Requests + AI Request: Test agent behavior with the same clarity you test APIs

Inside Postman, you can now simulate agent logic using first-class support for MCP. Paste in a config. Load your tools. Inspect the results. It’s visual, it’s safe, and it’s YAML-free.

The result? Faster iterations, safer testing, and less friction between prototype and production.

Model Comparison Template: Evaluate multiple models before deployment

Want to compare Llama vs Claude vs Gemini on your CheersFriend refund logic? This template lets you run prompts side-by-side and tune agent behavior before it hits production.

This means better results, less trial-and-error, and more confidence before anything goes live.

Postman Flows + Flows Actions: Orchestrate and deploy intelligent workflows—without code or infrastructure

Flows let you design agentic systems that span APIs, LLMs, triggers, and business logic—all from a visual canvas that’s inspectable and programmable.

With Flows Actions, you can now deploy any workflow to Postman’s cloud with one click. No provisioning. No servers. Just scalable, API-triggered services you can run on demand or on a schedule.

The result? Faster automation, lower infrastructure cost, and fewer tools in your stack.

MCP Server Network: Find trusted tools for agents—no guesswork required

Building agents starts with reliable APIs. The MCP Server Network is a curated public workspace of verified, ready-to-use MCP servers for popular APIs like Stripe, Notion, and Google Maps.

Developers can build faster with confidence. Publishers can make their APIs discoverable and agent-ready—without bespoke tooling or integrations.

This means higher reliability, faster agent development, and less risk across the board.

Agent Mode (Join the Waitlist): Your new AI teammate—built into Postman

Agent Mode is a conversational agent inside Postman that doesn’t just guide you—it takes action. It can send requests, build collections, write tests, and fix broken workflows using the same tools you already use.

And soon, it’ll extend beyond Postman with APIs and MCP—giving you automation that scales as far as you need.

The result? Shorter dev cycles, fewer bottlenecks, and scalable execution—without scaling your team. Join the waitlist.

You’ve built intelligent systems:

APIs are structured, secure, and agent-ready
Agent workflows are orchestrated and observable
You’re building faster, debugging smarter, and scaling with confidence

The Inconsistent System has been defeated.

The levels may be complete, but your campaign is just getting started.

Postman Ecosystem (Preview): Bring essential tools directly into your workspaces

Customize your stack with integrations, gateways, SDKs, and security tools to meet every team where they work, and extend everything you’ve built.

This means faster delivery, stronger security, and fewer blockers between teams and tools. If you’d like to build an app and join the Postman Ecosystem, you can now apply for early access.

Dive Deeper

Want to go further into each level? Explore the extended breakdowns to see what the real challenges look like in practice, and how teams can overcome them:

Game Complete

We wrapped up POST/CON 25 with a game theme—but the message goes beyond metaphors: the API and AI landscape is evolving fast, and Postman is already built for where it’s going.

From design to distribution to intelligent orchestration, the tools are here. And if you’re using Postman today, you’re already equipped to start building what’s next.

Now it’s your turn to play. Jump into the community to share what you’re building, earn your first certificate, and unlock real-world rewards. Contribute. Get certified. Level up your API reputation.