Team workshop
Build What Agents Want
The Agent-Ready API Team Workshop. Your product's next customers are AI agents. In four working sessions, your APIs and your team get ready for them.
Four sessions, all remote, with up to 20 team members. They learn what agents actually need from your product, working on your own APIs, and finish with a working MCP server and a 90-day agent-readiness plan they wrote themselves. Built on the same material our public students rate 4.8 to 5.0. Vetted by PMs and engineers from Amazon, Microsoft, Google, Netflix, Bloomberg, FedEx and Walmart, customized to your team, in private, matched to your roadmap and your real challenges. It's a deeper conversation than could happen at a public course.
Check if the workshop is a good fit
Have you observed any of these?
Customers ask how you're thinking about agents, and you don't have a solid answer or a roadmap.
Agents and MCP are on your roadmap, but nobody can say exactly what to build, for which capabilities, or with what access.
Ask engineers, PMs, architects what agent-ready means and you get three different answers. The same debate re-runs every planning cycle.
This workshop is built for teams whose public APIs are a real part of the product: customers and partners build on them, and now agents are trying to.
The root cause is that your APIs were designed for human developers, and agents play by different rules. They don't read your documentation the way developers do, so constraints left in prose get missed. They override your schemas, retry when they shouldn't, and quietly fail. And increasingly, that failed attempt is the evaluation: your next customers try your product through an agent before they ever talk to you.
In the first hour of Session 1, your team watches an AI agent try to use your actual API, live. During prep we pick three to five real customer tasks, and the agent attempts them in front of everyone while we score the runs: did the customer's task actually succeed, where did the agent need human help, how many calls and retries did it burn, what did it cost in tokens and time. Most teams are surprised. Everything after that is fixing what they just measured, together, with one framework and one common language.
What you get
- A shared framework and common language — API, MCP, CLI, Skills: what agents want, in what order, and when each surface is the right call. Your API makes the product programmable. MCP makes selected capabilities installable inside the agent ecosystem. Everyone finally means the same thing when they say agent-ready. We focus on agent-friendly APIs and MCP, but if it's apparent CLI, Skills, and Plugins need to be part of your roadmap, we can schedule them as extra sessions.
- Your APIs, scored by your own team — the 12+2 agent-readiness checklist applied live to your actual APIs, written up as standards you keep and reuse on every API you ship next.
- A working MCP server built from one of your APIs — connected to Claude/ChatGPT/Cursor, tested in three different tools, with a starter eval suite so it doesn't silently rot.
- A 90-day agent-readiness action plan — prioritized and owned by the team, because they built it in the final session. Not a consultant's deck: their plan.
- All recordings and materials, licensed for internal use.
The format
Sixteen hours of live working sessions, delivered as four 4-hour sessions, remote, over a two-to-four-week window we agree on during prep. Twenty participants is the sweet spot: big enough to get everyone who touches the product in the room, PMs, architects, engineers, and platform leads, and small enough that people actually talk. We right-size the number for your team, and for the hands-on builds a smaller core group drives the keyboards while everyone else stays in the decisions. The full session-by-session syllabus is below.
There is nothing to install, and no access to your internal systems needed. The live work runs on your public API surface and the documentation you choose to share, or a sandbox we agree on during prep. On your side: put together the participant list and the time slots. We supply a five-question survey that gets everyone in the right frame of mind, and you share links to your API documentation and any tools you want covered.
The syllabus
Four sessions of four hours each, sixteen hours total.
- What agents want from your product. The baseline: how agents actually consume products, and the framework for the surfaces they use. Then the live sessions: an AI agent tries to use your API, in front of everyone. We walk through the demonstrations on your own API wherever access allows, and close by scoring the runs and capturing what failed and why. That scorecard drives Session 2.
- Codify it. Your team turns Session 1's learnings into their own agent-readiness checklist, writes it up as your API standards, then puts the standards to work: designing with an agent Skill and mocking the result, so best practices get practiced, not presented.
- Build the agent surface. Introduction to MCP and when it's the right surface. Then two builds: a guided MCP server first, then one from your own API, connected to Claude and tested across tools. We close with the eval loop: a baseline eval suite for the server your team just built, so it doesn't silently rot.
- Make it stick. How the agent surface gets distributed and maintained. Then the working session that produces the 90-day agent-readiness plan, prioritized and owned by the people in the room. We close with a look ahead at Skills, CLIs, and plugins, the surfaces that come after MCP.
Who teaches it
Emmanuel Paraskakis, founder of Level 250.
I'm Emmanuel Paraskakis, 3x VP of Product Management, now a founder at Level 250. If you built or used APIs in the past 15 years, chances are you've used one of my products. I've led some of the most influential API tools: Apiary (550,000+ APIs), Swagger (750,000+ APIs) and Oracle's first Cloud-Native API Gateway. Before that, I built large B2B API programs at Verisk, Moody's, and Precisely. Today, I advise Fortune 500 CEOs and AI-forward startup founders on API Strategy, Developer Experience, MCP products, and AI agent readiness. I'm also a member of the OpenAPI Initiative and a featured speaker at apidays, QCon and other global technology conferences.
What participants say
Results across workshops, enterprise training, and public cohorts.
Emmanuel has a real talent for consolidating the latest thinking and best practices on software product management and business models, and conveying it to others in a thorough yet easily-understandable way. He's a great source of insight for those looking to move their organizations forward.
Our product and design team found value in Emmanuel's vast understanding of the conventions and histories around API design, and we found the final hands-on exercise of speccing and building a working API and gateway practical and empowering. Recommended to product and design teams with a good foundational technical understanding.
This course helped me fill in the gaps in my knowledge of API product management. I had previously built APIs but didn't have any formal training. Now I have a strong understanding of the major topics, debates, and key issues for building APIs. The hands on section on building API prototypes was especially helpful for getting early feedback.
How do you know it will work?
If your team doesn't leave the final session with a concrete, prioritized 90-day plan they're ready to execute, we'll keep working with you, with a free follow-up session, until they have one.
Engagement
Four 4-hour sessions · remote · up to 20 people.
A 30-minute call with Emmanuel. We'll compare notes on what your team is seeing, answer the hard questions, and decide together if the workshop is a fit. If it is, we'll bring in the right people on your side and find dates that fit your calendar.