🤖 Agent Mode Challenge – $200 | 24 Hours Only

[gbadebo-bello]

The weekly community challenge is live! One winner gets $200 cash.

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.

This week, we want to see what you can do with it and what you think.

Prompt: Use Agent Mode to make your workflow easier or faster, then share what happened.

Need ideas?

• Ask Agent Mode to fix an error or explain what went wrong
• Have it write tests or generate docs for one of your requests
• Try creating or updating an API spec using natural language

You don’t have to get it perfect, it’s still in beta! Just show us what you tried.

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 if you want

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.

Winner announced Friday. Go!

[navigation-observe27 (Dhanvantari)]

Agent Mode: Turning AI Into My API Regression Watchdog

As a new user, I wanted to test Agent Mode’s real-world strengths by creating an automated workflow that checks for breaking API changes. Could Agent Mode act like a regression watchdog and help me recover when things go wrong?

Kickoff – Collection Creation
I started by asking Agent Mode to create an “API Regression Watchdog” collection with three public APIs:

OpenWeatherMap (weather for Delhi)

NewsAPI (top headlines for India)

CoinGecko (Bitcoin price)

It responded instantly, organizing the requests and even prompting me for the right API keys.

Adding Smart Tests
Next, I challenged Agent Mode to write true regression-protection tests:

It added status code checks. Validated that every expected key and JSON schema was present for each API This gave each request enhanced, strict automated tests.

Simulating a Real Failure
To mirror a real-world dev experience, I changed the NewsAPI endpoint intentionally, causing schema and status code failures. Agent Mode immediately detected the issues, provided a precise summary of what broke, and listed out test failures and likely causes for each.

Failures and passes are clearly reported per request

Root causes (like missing keys and bad statuses) identified

Changelog and Automated Diagnosis
I then asked Agent Mode to generate a markdown changelog summarising what failed, which schemas broke, and the last known good versions. The AI generated a detailed, readable changelog embedded in my Postman documentation mimicking the workflow of a professional CI/CD pipeline, without any code.

Recovery Attempts – Hitting Real Limits
Finally, I pushed Agent Mode to auto-recover the broken NewsAPI endpoint. This uncovered a real permission limit. I’m in Viewer mode, so it couldn’t actually save endpoint changes or rerun new tests. Instead:

Agent Mode gave step-by-step manual instructions with exact fixes.

It offered schema snippets and suggested forking to a workspace where I’d have full edit rights.

No silent failures, just clear next steps and educational guidance at every turn.

When I started using Agent Mode, it genuinely felt like having a smart, collaborative teammate by my side. It handled everything from creating tests to diagnosing API issues, turning natural language into instant results. What impressed me most was how it owned its limits when I hit a permission wall; it didn’t just stop, but coached me through what to do next. No guesswork, no frustration. If Agent Mode receives full auto-repair in the future, it will be a real game-changer for anyone building or maintaining APIs.

[material-geoscient17 (Harshit)]

Agent Mode: Turning GitHub API Visualization into a One-Click Insight

As an active Postman user, I wanted to see how Agent Mode could help me simplify API data visualization and reduce repetitive scripting work.
My goal was simple — can Agent Mode convert raw JSON into a visual chart faster than doing it manually?

---

Setup – Testing with GitHub Users API

I started with a simple yet popular public endpoint:
GET https://api.github.com/users/octocat

This API returns GitHub user details such as followers, public repos, and gists — perfect numeric data for visualization.

---

Prompt – Creating the Visualization

I opened Agent Mode and asked:

“Visualize this response as a chart summarizing key numeric fields.”

Within seconds, it generated a Post-response visualization script that automatically produced a horizontal bar chart of key stats like public_repos, public_gists, followers, and following.

When I re-ran the request, the visualization appeared perfectly under the Visualize tab — clean, well-formatted, and data-driven.

---

Observations & Technical Feedback

Agent Mode performed very well, but a few observations stood out:

• Two-step workflow: currently, you must execute two requests — one to generate the visualization script, and another to apply it. Combining this into a single workflow would improve efficiency.

• UI Contrast: in dark mode, some visualization bars and labels have low contrast, slightly reducing readability.

• Speed: generation and script placement were instantaneous — no need to manually code anything.

---

Impact

Agent Mode helped me eliminate manual scripting and focus on interpreting results instead of coding visualizations.
For quick data insight tasks, it feels like having a built-in data analyst right inside Postman.

---

Overall Takeaway

Agent Mode is an impressive productivity tool for developers who visualize or test APIs frequently.
With small UX and workflow optimizations, it could become a one-click automation engine for all routine Postman tasks.

[shravaniraut175 (Shravani Raut)]

My Submission for the Postman Weekly Challenge ~ Agent Mode Beta

I explored Postman’s new Agent Mode using my live deployed project BudgetIQ (a personal finance management app hosted on Vercel).

For this challenge, I tested my deployed endpoint:
POST https://budgetiq-pro.vercel.app/

Using Agent Mode, I asked:

“Explain what this API endpoint returns and how to document it.”

Agent Mode instantly analyzed the response, detected that the endpoint returns an HTML response with status code 200, and generated a detailed documentation summary including the expected behavior, request type, and content type.

This saved me valuable time I’d normally spend manually writing endpoint documentation.
It clearly shows how Agent Mode can assist in API documentation generation and response analysis, even for production-deployed projects.

Screenshots attached below showing my Postman request and Agent Mode’s AI-generated explanation.

Overall experience:
Agent Mode is an impressive assistant for developers it understands context, explains API behavior clearly, and automates documentation in seconds.

[nemsadzeana (Ana Nemsadze)]

Place Suggestion

I love doing small, fun projects that I can sometimes use later in life. Sometimes I want to hang out with my friends or even wander around alone, but I have no idea where to go especially since I have to consider the weather.

Using this agent was fun to build a project that suggests a place to visit based on your location and the weather!

What I Did

1. Location Detection Online, I found an endpoint that returns your location information when you send a request. I asked the agent to send the request, grab the city value, and validate that the response status code was 200 and the response was not empty. Once the city value was grabbed, it was set as a collection variable.

• Endpoint: https://ipinfo.io/json

2. Weather Retrieval After grabbing the city, it is automatically passed to https://wttr.in/{{city}}?format=j1 to get the current weather description. The weather description from the response is also set as a collection variable. The status code and non-emptiness of the response are validated.
3. Place Suggestion Based on Weather The third and final service was the most logical and the most fun:

• Endpoint: Nominatim Demo}+in+{{city}}&format=json&limit=1Categories are mapped to weather descriptions, so the category is automatically selected based on the weather. The city is passed from the collection variable. The response is limited to one place to visit (but this can be manually changed). The response code and non-emptiness are validated. In any case, the suggested place, along with its address, is console logged.

---

Reflections

Postman Agent is a fun tool to work with for creating quirky and fast flows. However, to make it work effectively, you need to know exactly what needs to be validated and how. Even though it automatically generates code, it still needs to be reviewed to see if it can be written better.

Sometimes the agent had issues passing variables in the query, so I had to manually fix them. It took me a bit to get used to the way the agent worked, since each request has its own window when I was working on one request and trying to find prompts from previous requests, I couldn’t see them. Additionally, sometimes the tests it generated were automatically pasted in the correct position of pre- or post-request scripts, but other times I had to manually copy and insert them myself.

Since it’s still in beta, I think the features it offers are lovely, and when it advances, it will be even more amazing! I don’t see it as a tool that will entirely replace writing test cases, but rather something that will enhance the process.

[lunar-module-geolog5 (JOYSTON MONTEIRO)]

Agent Mode: Instant Test Coverage Dashboard

When I first tried Postman’s Agent Mode (beta), I wanted to see if it could go beyond explaining responses, could it build a complete test intelligence layer for my APIs?

So I used the Postman Echo collection and gave it one instruction:

“Add tests for all collection requests and show a visual summary of coverage by endpoint.”

Agent Mode went to work instantly. It generated robust test suites across every endpoint, covering:

• Status code assertions (2xx, 401/403, 204)
• Response time under 2000ms
• Content-Type and header validations
• JSON schema checks for echo responses
• Cookie presence tests for cookie endpoints
• Method verification and encoding checks
• Conditional logic for endpoints returning expected failures

Then, it created a new collection-level post-response script that aggregates results into a coverageReport variable and even added a new request, Coverage Summary, which visualizes results in a table and donut chart.

After running the collection, I could open “Coverage Summary” and instantly see real-time test coverage for every endpoint no code, no setup, just insight.

Results:

• 3× test coverage improvement (7 → 24 endpoints tested)
• 4+ hours saved per regression cycle
• 40% fewer missed edge cases during release

Reproduce this yourself:
In Agent Mode, type:

“Add tests for all collection requests and show a visual summary of coverage by endpoint.”

Agent Mode didn’t just generate tests it created a complete coverage dashboard that engineers can use immediately.
Next, I plan to extend this with CI integration so coverage reports auto-update in every pipeline run.

Screenshots

1.Agent Mode Interface

2.Coverage Summary Dashboard

[orbital-module-engi1 (Astha Jhawar)]

Agent Mode: Turning Documentation Dread into a 5-Minute Task
The Challenge
I had a working e-commerce API collection (auth, products, cart) with zero documentation. Team kept asking “what does this do?”

What I Tested
Prompt 1: “Document my entire collection”
• Generated clear descriptions, parameter details, and response schemas
• Felt human-written, not generic AI
Prompt 2: “Create test scenarios for signup → login → browse → cart”
• Built chained requests with variables
• Added assertions and business logic comments
• Made the collection an interactive tutorial
Prompt 3: “Set up dev/staging/prod environments”
• Hit permission limits, couldn’t auto-create
• But provided exact JSON snippets and clear instructions
• Educational, not just automated
Surprise Win: “What breaks if I change product ID from integer to UUID?”
• Scanned entire collection in seconds
• Flagged 7 URLs, 3 tests, 2 examples, dependencies
• Saved me an hour of manual searching

The Verdict
Agent Mode transformed documentation from a dreaded chore into something I’d actually do proactively. When it hit limits, it taught instead of failed. That’s the AI teammate I want.
Future wish: Auto-detect schema drift and alert when docs need updates.​​​​​​​​​​​​​​​​

[taejaalag]

Agent Mode Feedback

---

I tested Agent Mode on various things like writing simple tests, debugging 400/404 errors and workflows like chaining requests with variables. It performed amazingly, handling everything almost perfectly.

I asked it to build a GitHub-to-Slack bug reporter, it wrote a perfect script that filtered nested labels and posted a summary.

I also asked it to generate a JSON Schema for a response and write a single test to validate it, which it did perfectly, using the Ajv library for strict schema validation.

The overall experience was amazing but I faced some issues like it hung once and I had to resend the prompt, and the chat UI makes it hard to tell my prompts and its answers apart. Also, since it generates almost everything correctly, it would be better if there was an option to “Approve all” changes in the code at once instead of clicking “Approve” for every single step.

Apart from these the Agent is very helpful.

[terieyenike (Oteri Eyenike)]

postman weekly challenge submission using Agent mode beta.

for this challenge, i am using the spacexdata endpoint:

GET https://api.spacexdata.com/v4/launches

the idea behind this is to try the following:

• create a visualization table
• add test scripts to check if response code is 200, has 5 items, and each item includes specific data from the JSON.

my prompt are:

add a visualizer to get launches to render a clean table

create a test scripts to check that the following: - The response code is 200 - The response has 5 items - Each item includes ‘name’, ‘date_utc’, and ‘rocket’

if i was to do this manually, it would have taken a significant amount of time to write the code. but with the agent mode, the turn around is swift because of its embedded model that assist in making this possible.

[satellite-meteorolo4 (Agastya Khati)]

Spent today actually playing with Postman’s new Agent Mode and ngl it’s kinda insane how much things it can automate if you push it right
I wanted an API for managing students + assignments (create students, add assignments, list them, etc). Normally that means:

• write OpenAPI spec manually
• build endpoints
• mock them
• write test cases
• add validation flows
• handle example responses
  So I just asked Agent Mode to scaffold the entire API from scratch.

It:

• generated the OpenAPI spec
• created the full request collection (students, assignments, submissions)
• setup the folder structure
• and auto-added test assertions (status code + JSON checks)
  I was stuck in error and i just hit debug with ai and agent fixed in seconds
  I personally loved that the sonnet haiku 4.5 is available rn and also we can configure mcp servers too
  It’s already amazing in beta can’t imagine how good it’ll be at launch
  

[mreccentric (Sagnik Chakraborty)]

Test Suite Speedrun: Agent Mode Generated 18 Assertions Across 3 APIs in Under 20 Minutes

What I Built: A complete 3-API test suite covering:

• Weather data (Open-Meteo API)
• Cryptocurrency pricing (Coinbase API)
• Random data validation (Cat Facts API)

---

Phase 1: Collection Setup

Created a fresh collection called “3-API Test Suite Speedrun” with three public API endpoints.

---

Phase 2: Agent Mode Test Generation

Request #1: Weather API

My Prompt:

Write comprehensive automated tests for this weather API request including: 
- Status code validation
- Response time under 2000ms
- Schema validation for temperature_2m and wind_speed_10m fields
- Check that temperature is a number
- Check that wind_speed is a number

Result: Agent Mode instantly generated 6 comprehensive assertions validating status codes, response structure, data types, and performance benchmarks.

---

Request #2: Bitcoin Price API

My Prompt:

Create automated tests that verify:
- 200 status code
- Response time under 1500ms
- JSON structure has data.amount field
- Amount is a valid number greater than 0
- Currency field exists and equals "USD"

Result: Agent Mode generated 6 more assertions with proper nested JSON validation and edge case checks (amount > 0).

---

Request #3: Cat Fact API

My Prompt:

Add tests to validate:
- Status is 200
- Response has "fact" and "length" properties
- Fact is a non-empty string
- Length matches the actual fact length
- Response time is under 1000ms

Result: Agent Mode generated 6 assertions… but here’s where it got interesting.

---

Beta Reality Check: The Bug

Two tests failed:

1. Property assertion had incorrect syntax
2. Response time exceeded 1000ms (network variability)

What I Did:

• Analysed the generated code and identified the assertion syntax error
• Fixed the property validation logic manually
• Adjusted response time threshold to 2000ms for real-world reliability
• Re-ran tests successfully

The Takeaway: This showed Agent Mode’s current beta limits AND gave me hands-on experience with the test code structure. Having 95% accuracy that saves 20 minutes is still a massive win. The error was educational, not blocking.

---

Phase 3: Failure Diagnosis Test

To test Agent Mode’s diagnostic capabilities, I intentionally broke the Weather API by changing the endpoint to /WRONG_ENDPOINT.

My Prompt:

Analyze these test failures. What went wrong? Provide a detailed diagnosis with root causes and suggested fixes.

Agent Mode Response: Immediately identified the 404 error, explained the root cause (invalid endpoint), and provided step-by-step instructions to fix the URL.

After restoring the correct endpoint, all tests passed again.

---

Phase 4: Collection Runner Results

Ran the complete collection through Postman’s Collection Runner to validate the entire test suite end-to-end.

---

The Results

18 total assertions across 3 diverse APIs
~120 lines of test code generated automatically
25+ minutes saved vs. manual test writing
Smart error diagnosis when things broke
95% accuracy (1 syntax bug out of 18 assertions—fixed in 2 minutes)
Real beta testing experience with honest feedback

---

What Impressed Me The Most

Context awareness: Agent Mode understood the differences between weather data, financial APIs, and random text endpoints, generating appropriate validation logic for each without me specifying data types or structures.

Conversational workflow: Instead of Googling “Postman assertion syntax” or copying boilerplate, I described what I needed in plain English and Agent Mode handled the implementation.

Error diagnosis: When I broke the Weather API intentionally, Agent Mode didn’t just say “tests failed”, it pinpointed the 404, explained why schema validation broke, and gave actionable fixes.

---

What Could Be Better

Edge case suggestions: Would love Agent Mode to proactively suggest additional validations I might have missed (e.g., “Should we also check for negative temperatures?” or “Want to add rate limit handling?”)

Code explanation toggle: An option to have Agent Mode explain why it chose certain assertion patterns would be great for learning.

Syntax validation: The Cat Facts test had a syntax error—a pre-generation validation check could catch these before inserting code.

---

Real Talk

This wasn’t about getting perfect AI-generated code. It was about speed, learning, and workflow transformation.

Before Agent Mode: 40 minutes of writing boilerplate, debugging syntax, cross-referencing docs.

With Agent Mode: 20 minutes of conversation + 2 minutes of fixing one bug = production-ready test suite.

Even with one syntax error, Agent Mode turned tedious test writing into an interactive experience. The bug became a teaching moment, not a blocker.

For a beta product, this is exactly the kind of assistant I want—fast, mostly accurate, and honest about its limits.

---

Final Thoughts

Agent Mode feels like pair programming with an AI that knows Postman inside-out. It’s not replacing my testing skills—it’s amplifying them by handling the repetitive parts so I can focus on strategy.

If Agent Mode adds proactive suggestions and self-validation in future updates, it’ll be unstoppable.

Can’t wait to see where this beta goes!

---

~ Sagnik

[zjamadar (Zoya)]

Jumping into the challenge at the last minute, here’s what I accomplished:

I set up several APIs for Azure DevOps and used Agent to generate documentation for each one. This allowed me to share the setup with the team and create an automated workflow to manage and track task alerts across my organization.

[dotaadarsh (Aadarsh Kannan)]

Automating Secure Prompt Detection, Visualization, and Documentation with Pangea Prompt Guard & Postman AI Agent Mode

For the Agent Mode challenge, I focused on the [Prompt Guard API]( Postman ) from Pangea Cloud - showcasing how security testing, multi-prompts, sanitization, visualization, and documentation can be fully automated with the help of Postman’s AI Agent. Here are the highlights from my workflow:

1. Batch Body Generation & Visualization
   By sending attack and clean prompts in batches, I used Agent Mode to automate request body construction and visualize the entire detection workflow. Multiple Prompts, Immediate Insights:

   The AI Agent generated a formatted table that highlights the role, prompt, detection status, confidence, and type - malicious prompts are colored for quick review.

   
   

2. Automated Test Case Generation
   Agent Mode instantly produced robust test scripts to flag injection/jailbreak attempts and verify passing/failing scenarios.

   Smart Test Criteria:
   Tests automatically check the JSON response for keywords like “Malicious Prompt Detected”, “Jailbreak”, or “Injection”, and fail/passed based on detected flags.

   
   
   

3. Sanitized Prompt Suggestions
   To go beyond detection, Agent Mode helped me automate sanitized prompt recommendations. Now, whenever a malicious prompt is flagged, users see a safe, alternative suggestion.

   Benign Output for End Users:
   Sanitized prompts summarize the intent safely, removing risky directives.

   

4. Chart-style Visualization
   For easier analytics, I asked Agent Mode to visualize results as charts with status, detection confidence, and timing. This dashboard-like summary is perfect for auditors and security teams.

   

5. OpenAPI (Swagger) Documentation Generation

   Using Agent Mode, I automatically generated a complete Swagger/OpenAPI spec for the Prompt Guard endpoint, ready for integration or API review.

   

6. Instant Mock Server Generation

   Finally, Agent Mode created a Postman mock server for my Prompt Guard endpoint—making it possible to test, demo, and debug the workflow even before deployment.

   

Key Takeaways

The Postman AI Agent handled:

• Body generation for batch prompt testing
• Automated test creation for detection success/failure
• Visual analytic dashboards for quick threat review
• Suggesting sanitized safe outputs for end-users
• Generating full API documentation
• Setting up live mock endpoints, ready for frontend or QA teams

This end-to-end workflow boosts productivity, visibility, and security—all with just a few prompts in Agent Mode. I think this postman agent mode is a game-changer. By minimizing manual work and maximizing automation, Postman Agent Mode lets me focus on what matters most: building secure, scalable, and innovative API systems.

–

Observation

Behavior of the \n Command in Postman Agent Mode . It starts to rewrite the name and description of the collection.

Quick Links Not Generating Properly in Postman Agent

While using Postman Agent Mode with the Prompt Guard collection, I noticed an inconsistency with the “Quick links” section on the right panel.

Just thought this might help the team. Thanks!

[material-saganist-12 (Saran Kumar)]

My Experience with Postman’s New Agent Mode

I recently explored Agent Mode in Postman, and it genuinely changes the way we build and test APIs!

Instead of manually configuring requests and writing scripts, I simply described what I wanted in plain English — and the AI handled the rest.

Here’s how I used it step by step

---

Created API Requests using Natural Language

I asked:

“Create a GET request to fetch all users from https://reqres.in/api/users with query param page=2.”

Agent Mode instantly created a new request with the correct URL, parameters, and headers — ready to send. No need to manually type or configure anything.

---

Auto-Generated Test Scripts

Next, I prompted:

“Add tests to check if the response code is 200 and the user list is not empty.”

Within seconds, Agent Mode added this to the Tests tab:

pm.test("Status code is 200", () => pm.response.to.have.status(200));
pm.test("User list is not empty", () => {
  const data = pm.response.json().data;
  pm.expect(data.length).to.be.above(0);
});

I even asked it to add a validation for each user’s email field — and it appended that test too. Super intuitive!

---

Debugged Errors with AI Guidance

I intentionally removed an API key to trigger a 401 Unauthorized error and asked:

“Why am I getting 401 and how can I fix it?”

Agent Mode analyzed the request, explained that an Authorization header was missing, and suggested adding:

Authorization: Bearer <token>

This was a great help for quick debugging without manual guesswork.

---

Generated Documentation Automatically

To wrap it up, I said:

“Generate Markdown documentation for this request.”

Agent Mode produced clean, formatted API docs summarizing the endpoint, method, parameters, and expected responses. I could directly copy this into my team’s Confluence page!

---

Summary

Overall, Agent Mode feels like an intelligent API teammate that understands context, explains issues clearly, and helps automate repetitive API testing tasks.

It makes the workflow smoother — especially for quickly:

• Creating and modifying requests

• Writing robust Postman tests

• Debugging and explaining errors

• Generating human-readable documentation

[gbadebo-bello]

That’s a wrap!

This week’s challenge is officially closed. Thanks to everyone who jumped in.
While you wait, drop a on your favorite replies to help us pick a winner.

Winner announced Friday.

[gbadebo-bello]

Challenge Winner!

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

Congrats to @dotaadarsh for their workflow on batch generating request body and visualizations, generating automated test cases, etc. They’re taking home $200 cash.

We had lots of brilliant submissions this week but ultimately can have just one winner!

Next challenge lands on Wednesday. Stay tuned!