# Agents and APIs developer meetup Mumbai recap

We ran the first [Agents and APIs developer meetup](https://luma.com/postman-dev-events) in Mumbai on May 23. I organised it with Neo4j and GitHub User Group Mumbai — four talks from people actually building with agents and APIs, and a room that showed up ready to dig in. ![Developers gathered at the Agents and APIs developer meetup Mumbai on May 23](https://blog.postman.com/wp-content/uploads/2026/06/mumbai-meetup-may2026-photo4.jpg) *The Mumbai developer community gathered for the first Agents and APIs developer meetup in the city.*

## The talks

 [I](https://www.linkedin.com/in/mishra-aanchal/) kicked things off with a practical checklist for making APIs agent-ready, Zaid Mukaddam walked through what it actually takes to build and ship agentic APIs, Karan Chellani got into how to keep agents current on knowledge they weren't trained on, and Prasad Sawant closed out with a live end-to-end build of an AI agent tested in Postman. ### Practical steps to making your APIs agent-ready

 I walked through a seven-point checklist for what I'm calling AI readiness essentials — the specific properties an API needs before an agent can use it reliably: well-documented, rich error semantics, predictability, digestible, reliable and fast, discoverable, and secure. Two of those got live demos. On well-documented and digestible, I showed what the gap actually looks like in practice — what Postman tooling surfaces when your spec is thin versus when it's not, and how an agent's behavior changes depending on how clearly you've described what each operation does and what it expects back. The most time went to secure. I did a live walkthrough using Postman's git-native feature, then went deeper into agent mode — running some complex multi-step functions through an agent and watching how the token costs add up. Token cost optimization isn't something most API developers think about when they're designing endpoints, but once agents start chaining calls it matters a lot: chatty APIs that return more than the agent needs, or operations that require multiple round trips for something that could be one call, compound fast. ![Aanchal Mishra presenting at the Agents and APIs developer meetup Mumbai](https://blog.postman.com/wp-content/uploads/2026/06/mumbai-meetup-may2026-photo1.jpg) *Kicking off with practical steps to making APIs agent-ready.*### Building agentic APIs

 After the Q&A from my talk wrapped up, [Zaid Mukaddam](https://www.linkedin.com/in/zaidmukaddam/) took the floor. Zaid is founder of [Scira AI](https://scira.ai), and his talk was essentially a live build: "give your LLM a POST endpoint and a toolbox." He opened with a sharp contrast between the old world and the new. A chat API returns a paragraph and wishes you luck. An agentic API lets the model decide when to call tools and keeps looping until the task is actually done. To make that concrete, he built a [Hono](https://hono.dev/) server using the Vercel AI SDK with two endpoints — `/generate` for a clean JSON response once the agent finishes its tool loop, and `/chat` for streaming tokens and tool calls over SSE in real time. One thing worth pulling out: `stopWhen: stepCountIs(5)`. Without it, the agent stops after its first tool call and returns — which looks like it's working until you wonder why it never actually completes multi-step tasks. One parameter, but it's the difference between a demo and a working agent. He closed with the production checklist — rate limiting (agents burn tokens fast and don't self-regulate), request logging with tool call traces for when things break at 2am, bearer auth on every endpoint, and timeout handling so a slow model doesn't hold connections open indefinitely. Three lines of middleware between "cool demo" and something you'd actually put in front of traffic. ![Zaid Mukaddam presenting at the Agents and APIs developer meetup Mumbai](https://blog.postman.com/wp-content/uploads/2026/06/mumbai-meetup-may2026-photo2.jpg) *Zaid Mukaddam on the hard lessons from shipping agentic systems at Scira AI.*### Neo4j agent skills: teaching AI what it doesn't know

 From that build, we moved into a different kind of problem — and [Karan Chellani](https://www.linkedin.com/in/karan-chellani-514a6450/), Senior Solutions Architect at Persistent, framed it well: what happens when the model's training data is out of date for the specific thing you're asking it to do? His demo was built around Neo4j's Cypher 25 release, which introduced patterns that Claude simply doesn't know — because its training predates the release. Left to its own devices, Claude generates deprecated Cypher that runs against older driver APIs. You don't get an error, you just get wrong code. Karan showed this directly: the same query, Claude without skills versus Claude with [Neo4j Agent Skills](https://github.com/neo4j-contrib/neo4j-skills) installed. The difference in output was stark. The core idea behind Agent Skills is that you don't need to retrain the model to fix this — you just need to put the right knowledge next to the right task at runtime. The skills inject current Neo4j and Cypher 25 patterns into the context when the agent needs them. He also walked through a GraphRAG pipeline to show the same pattern at scale: the wrong approach versus the right one, with the skills doing the work of keeping the model's reasoning grounded in current reality. Install is one command: `npx skills add neo4j-contrib/neo4j-skills`. The [write-up on Medium](https://medium.com/neo4j/introducing-neo4j-agent-skills-e69958c38dea) goes deeper if you want the full architecture. ![Karan Chellani presenting at the Agents and APIs developer meetup Mumbai](https://blog.postman.com/wp-content/uploads/2026/06/mumbai-meetup-may2026-photo3.jpg) *Karan Chellani on using Neo4j agent skills to orchestrate complex tasks.*### Build an MVP with Architect, extend with Studio, test with Postman

 [Prasad Sawant](https://www.linkedin.com/in/prasadsawant97) from [Lyzr AI](https://lyzr.ai) closed out the day with a live end-to-end walkthrough. He built an employee handbook assistant — the problem being that policy documents are long, HR inboxes flood with the same questions, and employees often don't know what they're actually entitled to. The system has two personas (employee self-service and an HR team dashboard) and three agents underneath: a manager agent that handles orchestration and intent routing, a policy Q&A agent that does RAG lookups against the employee handbook and returns personalised answers, and a ticketing agent that creates and routes support tickets and sends email notifications to both sides. He built it on Lyzr Architect, which wired the orchestration and auto-deployed the whole thing — pushing the full codebase to a GitHub repo so it's immediately extensible. Individual agents can then be updated in Lyzr Studio (swap models, add tools, change prompts) without redeployment. The testing part was where Postman came in. Every agent in Lyzr Studio is API-accessible, and the Postman AI Agent reads those endpoints and auto-generates the full test collection — you don't write a single request manually. Then you run it all with the [Postman Collection Runner](https://learning.postman.com/docs/collections/running-collections/intro-to-collection-runs/). He toggled the responsible AI controls in Studio live — PII redaction, prompt injection guard, safe output policy, unsafe input detection — and re-ran the Postman collection each time to show how the responses changed. Two personas, three agents, four AI safety checks — tested through Postman the same way you'd test any other API. ![Prasad Sawant presenting the Lyzr AI stack at Agents and APIs developer meetup Mumbai](https://blog.postman.com/wp-content/uploads/2026/06/mumbai-meetup-may2026-lyzr-talk.jpg) *Prasad Sawant on building and testing AI applications with Lyzr AI and Postman.*## The conversations in between

 Honestly, some of the best exchanges happened in the Q&A and the time after. What made this one work was the range of experience in the room. Developers building their first agent side project were sitting next to architects who are deploying agents inside enterprise systems. That mix made the questions sharper — "how do I structure my first tool call?" landed right next to "how do you handle agent state across a distributed system?" and both got real answers. Thanks to Neo4j and GitHub User Group Mumbai for all the support in making this a success. [Watch the wrap-up from the Agents and APIs developer meetup Mumbai, May 23](https://photos.app.goo.gl/1CMoRZ2HWjD7hxrUA) *The whole crew signs off — "Agents and APIs developer meetup Mumbai."*## See you on July 18

 The next Mumbai meetup is on **July 18**. Same format — talks from people actually building things and space for genuine conversations. Register: [Agents and APIs developer meetup Mumbai — July 18](https://luma.com/july-mumbai-meetup) If you're outside Mumbai, the meetup series runs globally — check all upcoming events and subscribe to stay in the loop: [luma.com/postman-dev-events](https://luma.com/postman-dev-events) Couldn't make it to this one? All speaker resources from the event are in our [Discord server](https://discord.gg/TvqJ2PR966) — come join the conversation. ---

## Resources

- [Register for the July 18 Mumbai meetup](https://luma.com/july-mumbai-meetup)
- [Upcoming Agents and APIs meetups](https://luma.com/postman-dev-events)
- [Postman Collections documentation](https://learning.postman.com/docs/sending-requests/intro-to-collections/)
- [Neo4j developer documentation](https://neo4j.com/developer/)
- [Scira AI](https://scira.ai)
- [Lyzr AI](https://lyzr.ai)