Earlier this year, we returned from Postcon 2025 with more than just a shiny award (though being named a Top New API Network was a proud moment for our team). We came back with a clear vision of where APIs are heading and how we need to evolve to serve you better.
At Postcon, one thing became clear to us — APIs aren’t just for developers anymore. They’re becoming execution layers for AI systems, automation workflows, and agents that consume and act on data without a human in the loop.
Here’s what caught our attention and what it means for developers building with APILayer.
The Big Shift: APIs as AI Execution Layers
The most striking theme at Postcon wasn’t about REST vs GraphQL or microservices patterns. It was about APIs becoming the primary interface between AI agents and the real world.
This isn’t theoretical anymore. We saw demos of AI agents booking flights, analyzing market data, and orchestrating complex workflows—all through APIs. The difference? These Postcon APIs were specifically designed for AI consumption, not just human developers.
For us at APILayer, that raised some serious questions: Are our APIs built for humans? Or for the systems acting on their behalf?
It’s a shift we’re now actively building toward. Want to see Postcon 2025’s keynote that inspired much of this thinking? Watch the keynote here.
Table of Contents
What’s Actually New at Postman (And Why You Should Care)
Postman didn’t just announce new features at Postcon. They showed us what modern API development might actually look like.
Here’s what stood out:
Flows + Actions: Visual Workflows Built for Real Developers
Postman introduced Flows — a visual way to build and automate API workflows without writing backend code. Essentially, Postman Flows allows you directly manipulate APIs and observe the data flowing between them. It’s logic-first, API-native, and actually usable for engineering teams.
How we’re thinking about it: We’re exploring Flows to prototype a fraud detection system using IPstack’s Security Module.
- Step 1: Geolocate an IP address.
- Step 2: Score the request based on location risk patterns.
- Step 3: Trigger alerts for suspicious activity via webhook.
With Flows, we’re able to map out this logic, test edge cases, and share prototypes across teams — all before committing to production code.
Learn more about Postman Flows
MCP Generator: Making APIs Understandable to AI
One of the quiet but powerful launches was Postman’s MCP Server Generator — a tool that automatically generates Model Context Protocol (MCP) servers for any API. Model Context Protocol (MCP) is how AI tools understand and interact with APIs. Postman now generates MCP servers for any public API with just a few clicks. This means your favorite AI coding assistant can directly call APIs without you writing integration code.
Why does it matter?
Because MCP is how APIs become usable by AI agents. It lets LLMs understand not just your endpoints, but your API’s purpose, its actions, and how to interact with it autonomously.
Instead of relying on human developers to read docs and write glue code, MCP turns your API into something an AI can work with directly, safely, and predictably.
Design-by-Doing: Building APIs Before They’re Built
Remember when API design meant writing OpenAPI specs in YAML? Postman’s new approach flips this: build a working mock, test it with real requests, then generate the spec.
Now, you can:
- Build a working mock server.
- Prototype real endpoint behavior.
- Test edge cases and responses before backend logic even exists.
- Generate documentation in parallel, automatically.
In other words, design and development merge into a single, iterative process.
How we’re thinking about it:
As an API-first company, we’ve seen how often docs and actual APIs fall out of sync. Mocks have typically been something you build after the fact — if at all.
But Postman’s approach reframes mocks as the starting point, not the end step.
What this unlocks for us:
- Faster prototyping of new APIs and features.
- Shared live endpoints teams can collaborate around before backend builds start.
- Documentation that’s always in step with the actual API — not playing catch-up.
In a way, it’s bringing APIs closer to how products are built: iteratively, collaboratively, and visibly.
How This Shift Is Changing Our Roadmap
At APILayer, we’ve always prioritized building APIs developers can easily work with. But Postcon made us realize that “easy” isn’t enough anymore. APIs need to be ready for AI systems, machine consumers, and task-driven workflows — not just human developers testing in Postman.
That’s why we’re evolving how we think about API design entirely. Here’s what we’re working toward across our portfolio:
1. AI-Optimized APIs, By Default
- Adding MCP support to make APIs machine-consumable.
- Structuring responses to reduce token usage for AI agents.
- Including clear, actionable error messages that support self-correction.
2. Task-Based Endpoints, Not Just Data
- Moving from CRUD-style endpoints to action-based design.
- Example: /detect-fraud instead of /get-ip-info.
- Building APIs around business tasks — not just data delivery.
3. Security-First Development
- Embedding automated security testing (DAST/SAST) from the start.
- Designing APIs with privacy modes (GDPR, HIPAA) as configuration, not afterthought.
4. Better Developer Experience
- Every API packaged with:
- Postman Collections and OpenAPI specs.
- Public Flows and Mock APIs for early prototyping.
- One-click playgrounds in docs.
- Multi-language SDKs (Python, Node.js, Go, Rust).
We’re not there yet. And we have a lot of work to do, but — APIs that work as well for AI agents as they do for developers is the future we’re building toward.
Where We’re Heading (And Why It Matters)
For us at APILayer, Postcon 2025 wasn’t just an event, it was a signal that the role of APIs is changing.
APIs are no longer just developer tools or backend plumbing. They’re becoming interfaces for AI systems, execution layers for autonomous workflows, and the backbone of how both humans and machines get things done.
That shift is pushing us to rethink:
- Are we building APIs for developers… or for the AI agents doing the work for them?
- Is REST enough? Should we explore GraphQL, gRPC, or other protocols where they make more sense for machine consumers?
- How do we handle the token economy? AI systems parse every field, every byte. Are we structuring responses in ways that keep API usage efficient and affordable when tokens, not people, are consuming them?
- What does “good documentation” even mean when your consumer might be an LLM, not a human?
Join the Conversation
We’re committed to making every APILayer API AI-ready, developer-friendly, and security-first — not as buzzwords, but as tangible, meaningful features.
But here’s the thing: we don’t want to build this future in isolation.
If you’re using our APIs — or building systems that could — we want your thoughts:
- What would make our APIs easier for your projects (or your AI agents) to consume?
- Which changes or tools would help your workflow?
- What should we prioritize next?
Winning the Top New API Network award was an honor. But building APIs that power the next wave of innovation? That’s the real goal.
Drop us a message at [email protected] or join the conversation on Discord. Let’s build it together.
