🧠 Agent Mode Challenge – $250 Prize | 24 Hours

[danny-dainton]

Agent Mode is Postman’s new AI-powered assistant that helps you build, test, and document APIs just by describing what you need. It’s still in beta, and we’re collecting feedback from early users to make it even better.

We want to see how you’re putting Agent Mode to work and how you’d describe its value in your own words.

Prompt:

What’s one way you used Agent Mode this week and how would you explain what it is to someone new?

How to join the beta:

Agent Mode is available in personal workspaces only (not enterprise workspaces).

1. In Postman, go to Settings → AI → Toggle on Agent Mode
2. You’ll see a new Agent Mode option appear in your workspace
3. Try using it in your next request or collection - it’s that easy

How to enter:
Reply to this thread within the 24-hour window with a short message and a screenshot or GIF of Agent Mode in action.

Winner announced Friday. Go!

---

This contest is open worldwide to participants 18+. By entering, you grant Postman the right to feature your submission on our website, blog, and social channels.

[cryosat-physicist-23 (Shubh Dholakiya)]

I used Agent Mode this week to scaffold and refine the Orders API collection for my restaurant POS project. I described the endpoints I needed in plain English (create order, get by ID, list by status, simulate failed payment), and Agent Mode generated the requests, example payloads, and test snippets for me. If I had to explain it to someone new, I would say: “Agent Mode is an AI teammate inside Postman that turns what you type in plain English into working API requests, tests, and docs.” It removes a lot of the boring setup and lets me focus on the actual API design instead of wiring every request by hand.

[lunar-module-geolog1 (JOYSTON MONTEIRO)]

This week I used Agent Mode as my on-call co-pilot: I toggled Settings → AI → Agent Mode in my personal workspace, fed it a failing Postman Monitor run and the related GitHub PR and in minutes the agent (still in beta submitted feedback) triaged the failure, wrote focused tests, generated an OpenAPI patch for the changed endpoints, spun up a mock server and produced a one-page doc update and Slack summary my team could action. Instead of hunting through logs and re-writing tests, I asked one clear instruction “Analyze this monitor failure, produce tests that prove the bug and give a safe rollback plan” and Agent Mode returned runnable test scripts, example requests/responses, a mock to reproduce the bug and a short changelog I pasted into the PR. The whole loop went from frantic debugging to a clean PR and an automatic team notification in under an hour.

Explain it to someone new: Agent Mode is Postman’s AI assistant (beta) that helps you build, test and document APIs by describing what you need think of it as a very experienced teammate who reads your failing runs, writes the tests you should have, drafts the docs and sets up a mock so QA can verify all inside your personal workspace. Flip the toggle, give it the problem and it returns production-ready artifacts plus the human-friendly summary. In my case it caught a breaking schema change before deployment and saved multiple hours and one potential rollback a small change in workflow with an outsized, demonstrable return.

[telecoms-cosmologis1 (Edcleryton Silva)]

How I used Agent Mode: I treated Agent Mode as my “Security Sidekick”. I didn’t want to write boring negative tests manually, so I asked it to roast my login endpoint. It instantly generated a full suite of nasty scenarios: SQL Injection, XSS payloads, and it even wrote a custom pre-request script to generate a ~1MB payload for buffer overflow testing. It did all the heavy lifting (headers, bodies, assertions) so I could just review the strategy.

How I explain it to a newbie: It turns your “intent” into actual code. You tell it what you want to test (e.g., “break this API with bad data”), and it handles the how—instantly writing the JSON, scripts, and checks. It’s like having a senior pair programmer who types really fast.

[gauravsharma-mern (Gaurav Sharma)]

I used Postman’s Agent Mode this week in a hackathon i went to, to rapidly bootstrap a complex, multi-protocol monitoring collection called “Docker VM Live Metrics.”

I asked the agent to create two different requests: one for real-time resource metrics via a WebSocket connection and a second one using the SSH protocol to execute a command on a remote VM and capture network statistics. It analyzed and wrote runnable validation tests (for example - checking that numeric fields like cpu_percent are present and are non-negative numbers), ensuring the quality of the real-time data through ssh.

---

how i would want to explain this to anyone -

Imagine you have to build two complex machines that talk different languages, one machine streams data constantly (like a live video feed), and the other needs a specific command to get a one-time status update.

Normally, you’d have to manually set up all the pipes, wires, and rules (the requests) for both machines, and then you’d have to write pages of detailed instructions (the test scripts) to confirm that the data coming out is correct.

Postman’s Agent Mode is like having an expert engineer by your side. I told the Agent my goal - “Build a collection to monitor my VM using both a streaming connection (WebSocket) and a command-line connection (SSH).”

The Agent instantly drew up the blueprints, set up the connections, and most importantly, it automatically wrote all the required quality-control checks (the tests). It ensured I didn’t spend hours on manual setup and scripting, letting me focus only on the overall monitoring goal instead of the tedious connection details. It saves time and ensures the tests are perfect the first time. its cool, i’d say! :))

[zoyajmdlpf20 (Annie)]

This is my very first blog ever here, so now I’m super excited to see how people react n here’s my shot of how i’d explain what’s Agent Mode to someone new !

If you want to become a serious developer who works smarter than the rest of the crowd, Agent Mode is one tool you need in your bag! Think of it like a genie from the Genie, Make a Wish series (a Netflix drama) that can create a magical Genie API land world for you with just three simple wishes:

Wish one: Create a new CRUD-based API collection for an <>, and include end-to-end documentation for all the endpoints in this collection.

Wish two: “Create a new mock server for this collection and add user flow in flows to validate all the endpoints.”

Wish three: Create a monitor for this collection with these XYZ settings.

( For now please ignore the unhealthy status, I’m agenting a fix for this, tbh in Agent Mode )

And there your go ! you’ve already got the gist! But it doesn’t end here. Play around for more !

Plus, I read this post by Danny and felt it was the perfect spot to test this out, so I added a few more learning shots to this game:

Prompt 4: “Use zod as a validation script to validate the structure of our endpoints.”

---

As a developer myself, I believe we should appreciate every piece of technology that makes our lives easier, becoz behind the scenes, engineers pour their heart, soul, and endless effort into making our world extraordinary picture perfect . So far, it’s a great product!

If you genuinely want feedback on blind spots, here are two things at the top of my list:

1. In Agent Mode, I’d love to see which file it’s actually editing. On average, my enterprise has 2K endpoints exposed for a single application, so before approving, I should know where the edits will go.

2. I’d also love to see some kind of notification when the analysis is done to let me know there’s an update. Right now, I keep toggling back and forth to check out of curiosity.

   

I’m new to this community, so if this project is open source, I’d love to add commits myself for the above pointers! I think that’d be even more fun!

Best Regards,

A soft core frontend developer !

[terieyenike (Oteri Eyenike)]

I am a fan of stock photos and my platform of choice is Pexels. For this week’s exercise of using Agent Mode to craft out an API with its endpoints and HTTP request, I used this prompt to scaffold a new collection:

create a complete api endpoints to search the web for images like how the pexels or unsplash api does.

If I am explain what Agent Mode is like I am five:

With Agent Mode, it allows you to spin up API endpoints that connects to another server on the internet and generate them with natural language. It all starts with a simple prompt and Postman automate the entire workflow with precise accuracy that requires little or no extra tweaking.

P.S.: Agent Mode do not require the rigour of manual input or setup that takes time and effort from the user.

[satellite-meteorolo4 (Agastya Khati)]

I provided Agent Mode with a detailed prompt requesting a comprehensive e-commerce API release health check collection. Agent Mode automatically generated:

Prompt

Create a comprehensive release health check collection for an e-commerce API. I need: 1. CRUD operations for Products, Orders, and Payments endpoints 2. Negative tests: invalid IDs, missing required fields, boundary values (0, negative numbers, 1MB payloads) 3. Security tests: SQL injection in search endpoints, XSS in product descriptions, auth token validation 4. Performance assertions: all endpoints must respond within 500ms 5. A monitor that runs these tests every 10 minutes post-deployment 6. Auto-triage logic: categorize failures by severity (critical=failed payment, warning=slow response, info=missing optional field) 7. Mock server that simulates different failure scenarios for testing 8. Auto-generate OpenAPI documentation with all test cases 9. Postman Flows that validate the complete order workflow: create order → add payment → verify order status 10. Include a pre-request script that generates realistic test data (customer IDs, order amounts, timestamps) Make it production-ready with best practices.

1. CRUD API Endpoints

• Products: GET /products, GET /products/:id, POST /products, PUT /products/:id, DELETE /products/:id
• Orders: GET /orders, GET /orders/:id, POST /orders, PUT /orders/:id, DELETE /orders/:id
• Payments: GET /payments, GET /payments/:id, POST /payments, PUT /payments/:id, DELETE /payments/:id

2. Security Tests

• SQL Injection in Product Search with payload: '; DROP TABLE products; -- ​
• XSS in Product Description
• Auth Token Validation
• Missing Auth Header
• Expired Token Simulation

3. Negative Tests

• Invalid Product/Order/Payment IDs
• Missing Required Fields (for Products, Orders, Payments)
• Boundary Value Tests
• Invalid Order Status

4. Performance Tests

• Bulk Product Fetch
• Bulk Order Fetch
• Bulk Payment Fetch

5. Workflow Tests

• Complete Order Workflow (Create Order → Add Payment → Verify Status)
• Order Status Verification

6. Request Payloads

• Realistic JSON examples: { "name": "Test Product", "description": "A high-quality test product", "price": 99.99, "stock": 100, "category": "Electronics", "sku": "TEST-SKU-001" }

7. Infrastructure

• Pre-request scripts for test data generation
• Post-response test scripts with assertions
• Collection-level documentation
• Headers and authentication setup

How I’d explain Agent Mode to someone who’s never used it:

You know that tedious part of building APIs where you’re basically a robot? Clicking “New Request” 30 times, copy-pasting the same test scripts, trying to remember every security edge case, and organizing everything into folders? Agent Mode is what happens when you get to stop being the robot.

Instead of manually wiring up your entire test suite, you just… tell it what you need. Like, “build me a comprehensive release health check with real security tests, performance checks, and multi-step workflows.” Then you watch it generate 30+ production-ready requests—complete with SQL injection payloads, XSS attempts, pre-request scripts, and assertions—in the time it takes you to read this sentence.

It’s not just autocomplete. It’s auto-everything. The boring, repetitive stuff that normally eats your afternoon? Done. The security tests you’d probably forget to write? Written. The workflow scenarios that require passing data between requests? Fully scripted.

Think of it as pair programming with someone who loves boilerplate, never gets bored, and works at the speed of thought. You focus on the actual API logic; Agent Mode handles the grunt work.

The real kicker? This isn’t just scaffolding—it’s ready-to-run, enterprise-grade infrastructure. I went from a blank collection to a full e-commerce test suite I’d confidently show in a production environment before my coffee even got cold. That’s the difference between AI-assisted and AI-accelerated.

Postman

[joint-operations-as1 (Ekram Zafar)]

How I Used Agent Mode This Week

I used Agent Mode to validate a dynamic array-based API that accepts three parameters: nums, k, and x. My goal was to test a logic-heavy endpoint that calculates the x-sum of subarrays — a task that usually requires manual setup, payload crafting, and test scripting.

Instead of building each request by hand, I simply described what I wanted:

“Send array nums, value of k: 6, value of x: 2 to the specified endpoint.”

Agent Mode instantly understood the structure and intent. It:

• Generated the request with the correct method and endpoint

• Inserted the array and parameters into the body

• Added headers and authentication automatically

• Confirmed the action in natural language

• Displayed the JSON payload and response in real time

This saved me from manually toggling tabs, writing JSON, and validating the payload — all of which I’d normally do step-by-step.
How I’d Explain Agent Mode to Someone New

Agent Mode is like having a Postman-native AI teammate who understands your API goals and builds everything for you — requests, payloads, tests, and even documentation — just from your description.

You don’t need to remember syntax, switch tabs, or copy-paste boilerplate. You just say what you want, and Agent Mode responds with a fully functional request, ready to send.

It’s not just autocomplete — it’s auto-everything:

• It understands your intent

• It scaffolds your logic

• It validates your payloads

• It documents your flow

Whether you’re testing a complex algorithm or validating a deployment, Agent Mode handles the grunt work so you can focus on the logic.

[navigation-observe27 (Dhanvantari)]

This week, I used Agent Mode as more than just an API helper and turned it into a deployment auditor for my whole workspace. With a natural language prompt, it mapped out every service and endpoint, flagged missing environment variables and secrets, and ranked which changes could break the most parts of my system. It even showed critical gaps, like hardcoded API keys and missing tests. The visual impact map made it super clear which variables and endpoints were risk hotspots before I shipped anything. Thanks to Agent Mode, deploying went from risky to reliable in minutes instead of hours of manual review.

AI-Driven Workspace Readiness Auditor

1. Agent Mode helped me quickly visualize how changes to environment variables ripple across my entire workspace, identifying risky dependencies and missing secrets before deployment.

2. This proactive risk mapping saved hours of manual checks and gave me real confidence to ship safely.

[dotaadarsh (Aadarsh)]

Fast Prototyping with Postman Agent Mode, Flows, and Mock Servers
This week, I leveraged Postman’s Agent Mode to turbocharge my development of a personal health and relationship care dashboard for my girlfriend. My goal is to automate everything from symptom tracking to wellness reminders and calendar planning - then rapidly test and demo the entire workflow using Postman’s mock server and Flows.

Workflow Highlights:

• Conversational API Generation: I described my dashboard’s requirements in natural language (“Build endpoints for menstrual symptom logging, schedule medication reminders, fetch gallery images from Google Photos, and sync a shared Google Calendar.”). Agent Mode instantly generated a full set of API endpoints, request/response models, and even suggested extra features like analytics and mood logging.

  

• Automated Test Data Generation: Agent Mode generated comprehensive scenario-based test data for my endpoints (e.g., high, medium, and low severity symptom logs).

  

• Automated Documentation Creation: Agent Mode automatically documented my API endpoints and their example requests/responses, making it easy for others to understand and use the dashboard API.

  

• Environment & Workflow Automation: It generated environment variable templates for both local and production API URLs. This allowed me to instantly switch my requests between local development and the deployed server without manual edits.

  

• Dynamic Data Simulation & Automated Workflows: Agent Mode helped me simulate a full month of health & wellness calendar events for my dashboard using the Collection Runner. It auto-generated a pre-request script for the “Create Calendar Event” endpoint, producing diverse event data (appointments, reminders, checkups) for every day, making it easy to stress-test, validate, and showcase the dashboard at production scale.

  

• Flows for Multi-Step Automation: With Agent Mode and Postman Flows, I efficiently automated complex health workflows in my dashboard: Symptom Logging & Health Trend Analysis and Proactive Daily Wellness Reminder System.

  
  

• Mock Server for Instant Frontend Testing: Agent Mode automatically set up a comprehensive mock server for my Health & Wellness Dashboard API. It filled every key endpoint with realistic example responses - covering multiple, single, and empty states for symptoms, medication reminders, events, and gallery images. Using the public mock server URL, I was able to: Test and demo the dashboard frontend with dynamic data.

  

• Fix Issues & Troubleshooting: When I encountered a 404 error while testing my “Retrieve Symptom History” endpoint against the mock server, Agent Mode diagnosed the problem and helped me resolve it fast:

  Diagnosis: Agent Mode quickly identified that the error was due to a missing saved example in my collection for the mock server - it wasn’t a problem in the backend code, but a mock configuration issue (“mockRequestNotFoundError”).

  Solution: Agent Mode walked me through adding a saved example response for the endpoint. By manually creating a realistic JSON example and saving it, the mock server now returns proper responses for testing and development.

  Agent Mode also provided options for switching between environments and base URLs, ensuring seamless transition between mock and real API endpoints.

  
  

---

Agent Mode, Explained for Beginners

Agent Mode is Postman’s built-in AI helper for working with APIs. You just tell it what you want in simple, everyday language - something like “create an endpoint to log health symptoms” or “run tests for multiple reminders.” Agent Mode takes it from there, building the endpoints, writing the docs, generating test data, and even fixing issues along the way. You don’t have to worry about all the technical bits or repetitive coding. It turns your ideas into working API pieces quickly, making the whole process easy and approachable for anyone.

Agent Mode is a game changer, making API development smarter, faster, and genuinely more enjoyable. I’m excited to discover how others are using this feature.

Thanks!

[suraif16 (Suraif Muhammad)]

This week I used Agent Mode on a small CRUD demo API I’m testing. I had a simple GET request for /students, and instead of manually writing tests, I asked Agent Mode to generate checks for the status code, JSON format, and a few key fields like id, name, and email. It created the script instantly, and I only had to make one small change before running it. It saved me a few minutes when I was in a rush.

Agent Mode, Explained for Beginners

Agent Mode is basically Postman’s built-in helper for working with APIs. You can describe what you want in plain language — things like “write a quick test for this endpoint” or “create an example request for this feature” — and it handles the technical bits. It can draft requests, build tests, tidy up documentation, and even spot issues in the flow you already have. You don’t have to repeat the same setup tasks or switch between menus.

What I like most is how it turns small ideas into something usable almost immediately. It removes a lot of the repetitive work and makes the whole process smoother and quicker. It’s a genuinely handy addition, and I’m interested to see the different ways others are using it.

[ileolami]

I’m currently working on a project where the documentation for the collection is inadequate and disorganised. This collection comprises 50 endpoints, and manually editing each one would be an exhausting and time-consuming task. To streamline the process, I plan to utilise Agent mode, a tool I’ve successfully employed before, to assist with the editing. This approach will hopefully save me significant time and effort.

[taejaalag]

When our team launched a new healthcare API handling patient data, I used Agent Mode to ensure we met strict security and compliance requirements from day one.

This week I used Agent Mode to build a complete enterprise API testing suite covering security, performance, business logic, and compliance validation in one automated workflow.

Comprehensive Testing Automation:

1. Full CRUD API Testing Suite:

• Generated complete REST endpoints for products, orders, and payments with proper CRUD operations
• Built realistic JSON payloads with validation for all data types
• Created negative test scenarios for invalid IDs, missing fields, and boundary conditions

2. Advanced Security Testing:

• SQL Injection Detection : 40+ exploit payloads across basic, union-based, time-based, and error-based attacks
• JWT Token Security : Algorithm validation blocking ‘none’ attacks, token tampering detection, signature verification
• Authentication Bypass Testing : Expired token simulation, missing auth headers, privilege escalation attempts
• Data Exposure Prevention : PII leakage detection, database information scanning

3. Performance & Workflow Validation:

• Load Testing : Bulk operations simulation with concurrent user scenarios
• Business Logic Flows : Complete order workflow (create → payment → status verification)
• Integration Testing : Third-party API handoffs and webhook delivery validation
• Performance Benchmarks : Response time validation under normal and attack conditions

4. Compliance & Monitoring:

• Regulatory Validation : PCI-DSS controls, GDPR data handling, audit trail integrity
• Health Monitoring : API availability checks, dependency status validation
• Automated Reporting : Security scoring, compliance status, executive dashboards

Technical Impact:

• 100+ production-ready tests covering the entire API testing lifecycle
• Zero-touch test generation from simple natural language prompts
• Enterprise-grade validation that would normally require multiple specialized tools
• Real exploit simulation with stored attack payloads for manual verification

Time Transformation:

Replaced 1 week of manual testing setup involving security engineers, QA testers, and compliance reviewers with a 15-minute automated generation that produced more comprehensive coverage.

How I’d explain Agent Mode to someone new:
“It’s like having an entire quality engineering team that automatically translates your API requirements into executable security tests, performance benchmarks, business workflows, and compliance checks. Instead of manually building each test type across different tools, you describe what you need to validate, and Agent Mode builds the complete testing infrastructure - turning weeks of specialized work into minutes of automated generation.”

[gbadebo-bello]

Submissions are now closed! Thanks to everyone who joined this week’s challenge.

We’ll review entries and announce the winner tomorrow.

Drop a on your favorite submissions below.

[gbadebo-bello]

Challenge Winner!

Huge thanks to everyone who joined this week’s Agent Mode Challenge.

Congrats to @navigation-observe27 for sharing how they are using Agent Mode; they’re taking home $250 cash.

Next challenge lands on Wednesday.
Stay tuned!