Mastra Workshops
Join the Mastra team and expert guests for live workshops that teach you how to build and deploy AI agents and applications.
Upcoming workshops
Past workshops
September 17, 2026
60 minutesBuild and Own Your Software Factory
Coding agents have made every engineer more productive, but most teams still run them as isolated workers on separate laptops. That makes it hard to see what is happening, share context, steer a teammate’s session, or keep work moving after someone closes their computer. Engineers still spend too much time restarting agents, repeating codebase conventions, and going back and forth on reviews. [Mastra Factory](https://mastra.ai/factory) is an open-source, configurable software factory that brings your team’s agents and development work into one shared online workspace. Work flows in from tools such as GitHub, Linear, and Slack, then moves across a Kanban board from intake and planning through building and review. Your team can follow active sessions, inspect the conversations behind a change, provide direction, and keep a human-controlled gate around plans and pull requests. In this workshop, we’ll build a Factory, connect it to a real repository, and show how agents move an issue from initial investigation to a reviewed pull request. We’ll also take you inside Shipyard, our own deployment of [Mastra Factory](https://mastra.ai/factory). Over one three-week period, Shipyard authored more than a quarter of the pull requests merged into Mastra. We’ll explain how we use it to ship an open-source project, including handling repository issues, reviewing contributions, and coordinating work across the team. **We'll cover:** * Setting up and owning an open-source Factory, including models, authentication, storage, sandboxes, and deployment * Bringing work in from GitHub, Linear, and Slack, then moving it through investigation, planning, building, and review * Configuring stages with specialized agents, skills, rules, and workflows, including alternative coding harnesses through ACP * Following and steering shared agent sessions, preserving implementation context, and running pull request review in a separate linked session Join us for a live demo of Shipyard and a new Factory built with real code. You’ll see the complete path from issue intake to reviewed pull request and have the chance to ask questions directly to the engineers who built Mastra Factory. *** **Hosted by** * Alex Booker, Developer Experience, Mastra * [https://x.com/bookercodes](https://x.com/bookercodes) * [https://www.linkedin.com/in/bookercodes/](https://www.linkedin.com/in/bookercodes/) * Abhi Aiyer, Co-Founder and CTO, Mastra * [https://x.com/abhiaiyer](https://x.com/abhiaiyer) * [https://www.linkedin.com/in/abhi-aiyer-aa41bb42/](https://www.linkedin.com/in/abhi-aiyer-aa41bb42/) _Recording and code examples will be available to everyone who registers._
September 10, 2026
60 minutesMCP is so back! Build Tools for the Agents Your Users Already Use
Your users may not want another standalone agent. Increasingly, they want the agents already embedded in their workflows, including coding agents and desktop clients, to work directly with your product. MCP provides a standard way to expose your application’s capabilities to those agents. The protocol’s new stateless model is also designed to simplify deployment and scaling. In this workshop, you’ll build an [MCP server](https://mastra.ai/reference/tools/mcp-server) that turns an existing application or API into tools external agents can discover and call. You’ll design effective tool interfaces, connect them to MCP-compatible clients, and prepare the server for production. You’ll also get a directional look at Mastra’s work on the next generation of MCP and what the changing specification means for builders. We’ll cover: * How to decide between building an embedded agent and making your product accessible through MCP * How to design clear tool descriptions, schemas, outputs, and errors that agents can use reliably * How to expose tools, workflows, and resources through an MCP server, then connect them to existing agents * How MCP is evolving toward stateless requests, simpler serverless deployment, and interactive flows without long-lived protocol sessions Join us for a live demo with real code, practical guidance for making your product work with the agents your users already prefer, and the chance to ask questions directly to the team building Mastra’s MCP support. *** **Hosted by** * Alex Booker, Developer Experience, Mastra * [https://x.com/bookercodes](https://x.com/bookercodes) * [https://www.linkedin.com/in/bookercodes/](https://www.linkedin.com/in/bookercodes/) * Daniel Lew, Engineer, Mastra * [https://x.com/ShlomesLew](https://x.com/ShlomesLew) * [https://www.linkedin.com/in/dslew/](https://www.linkedin.com/in/dslew/) _Recording and code examples will be available to everyone who registers._
September 3, 2026
60 minutesBuild an Eval Loop for More Reliable Agents
Every team building agents runs into this sooner or later. The demo works, the first users are happy, and then someone changes a prompt or upgrades the model. Something quietly breaks three tool calls into a workflow, and nobody catches it until a customer does. Gut checks are fine while you’re prototyping. They fall apart in production. So does reading traces one by one once you have real traffic. At that point, you need an eval loop: a consistent way to score what your agent does, catch regressions before you deploy, and learn from the traces you’re already collecting. We’ll start with a short, practical introduction to evals. You’ll learn what scorers do, when to use an LLM judge, when a deterministic check is enough, and how scoring fits into the day-to-day process of building and maintaining an agent. Then we’ll get into the code. Most of the workshop is live demos, including building an eval loop in Mastra and reusing the same scorers for offline tests and production monitoring. We’ll show how to catch regressions in CI, run experiments over datasets, and find useful patterns in production traces without inspecting them one at a time. We’ll cover: * Mastra’s built-in scorers for accuracy, hallucination, and tool-call correctness * Fast, deterministic checks that do not require another LLM call * Custom scorers for behavior specific to your agent * Regression tests with runEvals and your existing test framework * Dataset experiments for comparing prompts, models, and code changes * Mocking tools with side effects so experiments stay repeatable * Sampling, tags, and metadata for filtering large volumes of production traces * Scoring live traffic and turning useful traces into new dataset items We’ll work through real code throughout the session. Bring the eval problems you’re dealing with, too. The engineers who built Mastra’s evals, datasets, and tracing will be there to dig into them with you. *** **Hosted by** * Alex Booker, Developer Experience, Mastra * [https://x.com/bookercodes](https://x.com/bookercodes) * [https://www.linkedin.com/in/bookercodes/](https://www.linkedin.com/in/bookercodes/) * Yujohn Nattrass, Engineering, Mastra * [https://x.com/YujohnNatt](https://x.com/YujohnNatt) * [https://www.linkedin.com/in/yujohn-nattrass/](https://www.linkedin.com/in/yujohn-nattrass/) _Recording and code examples will be available to everyone who registers._
August 27, 2026
60 minutesGive Your Agent a Computer
Most agents hit a wall - they can call an API or query a database, but they can't actually work with files, run code, or act on the results. Give them a filesystem and a [sandboxed execution environment](https://mastra.ai/docs/sandbox/overview), and suddenly a whole new class of problems becomes solvable. But that opens up harder questions. How do you isolate users and tasks? Where does persistent state live? How much freedom can you safely give an agent without exposing your infrastructure? In this workshop, we'll build agents with Mastra that can create and edit files, run shell commands, install dependencies, and use execution results to decide what to do next. We'll cover how sandboxes and filesystems work together, when to use local development versus remote execution, and what state should survive between runs. You'll see practical patterns for handling uploaded files, generated artifacts, and agent-created outputs. We'll also dig into the architectural problems - isolating users and tasks, preventing state leaks, choosing where persistent files live, and safely giving agents enough freedom to be useful. By the end, you'll have a mental model for designing agents that can work with files and execute arbitrary tasks safely, plus patterns you can adapt to coding agents, data analysis, document processing, and other agentic applications. *** **Hosted by** * Alex Booker, Developer Experience, Mastra * [https://x.com/bookercodes](https://x.com/bookercodes) * [https://www.linkedin.com/in/bookercodes/](https://www.linkedin.com/in/bookercodes/) _Recording and code examples will be available to everyone who registers._
August 20, 2026
60 minutesImprove Your Agent with Trace Intelligence
Reviewing traces one by one makes it difficult to identify the patterns that matter most. [Mastra Trace Intelligence](https://mastra.ai/docs/mastra-platform/trace-intelligence) analyzes completed agent traces across four dimensions—user goals, outcomes, agent behaviors, and sentiment—then clusters recurring signals into themes. In this workshop, you’ll learn how those themes can help you understand what your agent is actually doing, see common behavior across many interactions, and compare the patterns associated with different outcomes. Trace Intelligence also lets you inspect representative traces, follow themes across snapshots, and compare how their share changes over time. This gives you a systematic way to turn production trace patterns into better-informed improvements, select useful traces for evaluations, and check whether changes improve the user experience—the practical agent improvement loop described in Mastra’s [Trace Intelligence announcement](https://mastra.ai/blog/announcing-trace-intelligence). Trace Intelligence is currently available in private beta for enrolled Mastra platform projects. The workshop will equip you to interpret its themes and relationships without mistaking association for causation. *** **Hosted by** * Alex Booker, Developer Experience, Mastra * [https://x.com/bookercodes](https://x.com/bookercodes) * [https://www.linkedin.com/in/bookercodes/](https://www.linkedin.com/in/bookercodes/) * Daniel Lew, Engineer, Mastra * [https://x.com/ShlomesLew](https://x.com/ShlomesLew) * [https://www.linkedin.com/in/dslew/](https://www.linkedin.com/in/dslew/) * Eric Pinzur, Engineer, Mastra * [https://www.linkedin.com/in/epinzur/](https://www.linkedin.com/in/epinzur/) _Recording and code examples will be available to everyone who registers._
August 13, 2026
60 minutesBuild Dynamic Workflows
AI development is moving toward agents that can create the orchestration they need, not just execute predefined steps. This workshop introduces Dynamic Workflows in Mastra: agent-created workflows generated from unstructured input that you can inspect, save, retrieve, and run repeatedly. By retaining the expressive capabilities of user-coded workflows, they can coordinate agents, tools, code, state, and human input—helping you move from an idea to reusable orchestration without manually wiring every step. *** **Hosted by** * Nik Aiyer, Engineering, Mastra * [https://x.com/nik\_aiyer](https://x.com/nik_aiyer) * [https://mastra.ai](https://mastra.ai) * Brandon Barros, GTM Engineering, Mastra * [https://x.com/brandonlbarros](https://x.com/brandonlbarros) * [https://www.linkedin.com/in/brandon-barros-60a97a148](https://www.linkedin.com/in/brandon-barros-60a97a148) _Recording and code examples will be available to everyone who registers._
August 6, 2026
60 minutesBuild Your Own Software Factory with Mastra Factory
A software factory coordinates agents across the software development lifecycle—not just code generation. Work moves through explicit stages for intake, triage, planning, implementation, and review, with persistent context and clear points for human input. In this 60-minute workshop, you’ll explore how [Mastra Factory](https://factory.mastra.ai/) structures that process in an open-source, agent-powered software delivery environment. You’ll see how its opinionated workflow connects issues from GitHub or Linear to repository workspaces, persistent coding agents, implementation plans, code changes, and pull-request reviews. You’ll examine: * How work progresses from an issue to a reviewed implementation * Why implementation and review use distinct agent sessions * Where human-controlled gates keep planning, approval, and merging in your hands * How Mastra’s typed workflows, memory, scheduling, tools, and observability support a governed, auditable process You’ll leave with a practical model for designing your own software factory around measurable stages, shared context, and human oversight. *** _Recording and code examples will be available to everyone who registers._ *** **Hosted by** * Alex Booker, Developer Experience, Mastra * [https://x.com/bookercodes](https://x.com/bookercodes) * [https://mastra.ai](https://mastra.ai) * Abhi Aiyer, Co-Founder and CTO, Mastra * [https://x.com/abhiaiyer](https://x.com/abhiaiyer) * [https://mastra.ai](https://mastra.ai) _Recording and code examples will be available to everyone who registers._
July 30, 2026
60 minutesBuild Multiplayer Agents with Mastra Channels
Many agents are designed for one user at a time. Real work usually happens in shared spaces, where multiple teammates interact with the same agent over time. In this workshop, you’ll learn how to build that kind of shared, multi-user agent with Mastra Channels, using surfaces like Slack, Microsoft Teams, Discord, and Google Chat. You’ll see what changes when an agent has to operate inside an ongoing team conversation instead of a single private thread. Different people jump in, ask follow-ups, add missing context, or shift the direction of the work, and the agent needs to stay coherent as that happens. We’ll make the Mastra connection explicit by looking at how Channels plugs agents into these platforms and how Mastra handles thread context and multi-user awareness. We’ll ground that in practical patterns like a team using a Slack agent over time, support or ops workflows where several people participate in the same thread, and internal coordination that unfolds across shared conversations rather than isolated prompts. You’ll come away with a clearer sense of how channel-based agents differ from single-user agent patterns, and how to design them so they stay useful when the conversation belongs to a group, not just an individual. **What to expect**A practical workshop on building multiplayer agents with Mastra Channels, with a focus on shared context, ongoing team conversations, and the design choices that matter when one agent serves many people. *** **Hosted by** * Alex Booker, Developer Experience, Mastra * [https://x.com/bookercodes](https://x.com/bookercodes) * [https://mastra.ai](https://mastra.ai) * Caleb Barnes, Engineering, Mastra * [https://www.linkedin.com/in/caleb-barnes/](https://www.linkedin.com/in/caleb-barnes/) _Recording and code examples will be available to everyone who registers._
July 16, 2026
60 minutesBuild Durable Agents That Run for Days with Mastra
Request and response only gets you so far. In this workshop, you’ll learn how to build agents that can keep working for hours or days — agents that survive interruptions, pick work back up after delays or failures, and continue making progress instead of starting over each time. Using Mastra’s new durable agents feature, you’ll explore what it takes to move beyond one-shot interactions and build agents that can persist through restarts, waiting periods, and new incoming information. You’ll get a practical sense of how durability changes the way you design agent systems when the work depends on time, external tools, or events you can’t control. We’ll ground that in concrete use cases: software factories where work moves from issue to code to review over time, monitoring and ops agents that stay active as conditions change, back-office agents that work through queues across many steps, and agents that need to wait, follow up, or continue once other systems are ready. **What to expect**A practical introduction to Mastra’s durable agents feature, why survivability matters, and how to start building agents that can keep running long after the first request. *** **Hosted by** * Alex Booker, Developer Experience, Mastra * [https://x.com/bookercodes](https://x.com/bookercodes) * [https://mastra.ai](https://mastra.ai) _Recording and code examples will be available to everyone who registers._
July 9, 2026
60 minutesBuild Realtime Voice Agents with Mastra
Voice agents are having a moment, but building one that actually feels responsive is a different problem from building a text agent. In this workshop, you’ll learn how to think about realtime voice agents in practice — where latency comes from, how memory changes the interaction model, and what it takes to make an agent feel fast enough to talk to. Misha will walk through a live voice agent built with Mastra and LiveKit, including a new integration that connects voice calls directly into Studio. You’ll see how the agent joins a call, responds in realtime, uses working and observational memory, and handles state without blocking the interaction. This session will also cover some of the practical tradeoffs that show up once you’re in the weeds: when lower-latency models outperform newer ones, how to record memory asynchronously, and how to avoid common footguns when building voice experiences on top of agent primitives. **What to expect** A practical walkthrough of how to build and reason about realtime voice agents with Mastra, with specific discussion of latency, memory, Studio integration, and where LiveKit fits into the stack. *** **Hosted by** * Misha, Engineer, Mastra * [https://x.com/mnightingale28](https://x.com/mnightingale28) * [https://www.linkedin.com/in/michaellitchev/](https://www.linkedin.com/in/michaellitchev/) * Alex Booker, Developer Experience, Mastra * [https://x.com/bookercodes](https://x.com/bookercodes) * [https://mastra.ai](https://mastra.ai) _Recording and code examples will be available to everyone who registers._
July 1, 2026
60 minutesBuild a Software Factory with Mastra
Shipping software is already a factory — even if it doesn’t feel like one. If work comes in through systems like Jira, Linear, GitHub, or production alerts and moves through review, coding, deployment, and follow-up, you already have a repeatable delivery loop. The question is where AI can help that loop move faster and with better quality. In this workshop, you’ll get a practical view of what a software factory actually is and how Mastra fits into it. You’ll see how agents and workflows can help automate steps across the software-delivery lifecycle, how long-running work can coordinate tasks that unfold over time, and how tools and integrations can connect that automation to the systems your team already uses. You’ll also get a clearer sense of why this matters in production: automation is only useful if you can understand and trust it. Mastra’s observability, traces, logs, and metrics make it possible to see what your software factory is doing, debug failures, and scale the parts that are working. **What to expect** A higher-level session on how teams are thinking about software factories in practice, where AI can realistically fit into the loop, and how Mastra provides the building blocks to orchestrate, observe, and grow that automation over time. *** **Hosted by** * Shane Thomas, CPO and Co-founder, Mastra * [https://x.com/smthomas3](https://x.com/smthomas3) * [https://mastra.ai](https://mastra.ai) * Alex Booker, Developer Experience, Mastra * [https://x.com/bookercodes](https://x.com/bookercodes) * [https://mastra.ai](https://mastra.ai) _Recording and code examples will be available to everyone who registers._
June 30, 2026
60 minutesPatterns for Production AI Agents
Most teams building agents today are still figuring out what "production" actually means. Over the last 18 months, Mastra has worked with thousands of teams shipping agents — from SaaS companies embedding AI in their products to Fortune 500 platform teams triaging millions of alerts. In this webinar, Mastra CEO and Co-founder Sam Bhagwat shares the patterns that separate agents that demo well from agents that hold up under real users, real data, and real cost constraints. **What to expect** Sam will walk through a taxonomy of the three kinds of agents teams are actually building in production: customer-facing, internal, and developer platform. You'll hear how SaaS companies like Indeed are building personalized agents over proprietary data — and the cost optimization and accuracy challenges they hit during rollout. You'll see why large institutions are going off-book to find high-impact automation opportunities in clinical trials, government RFPs, and enterprise search across tens of thousands of employees. And you'll learn how platform engineering teams are wrapping Mastra into internal agent platforms — blessed paths that let hundreds of developers ship agents without reinventing primitives. This isn't a tutorial or a product walkthrough. It's a direct look at what's working in production right now, drawn from real teams and real deployments. Whether you're evaluating where to place your first bet on agents or trying to scale what you've already built, you'll walk away with a clearer picture of where the opportunities are and what it takes to ship. *** **Hosted by** * Alex Booker, Developer Experience, Mastra * [https://x.com/bookercodes](https://x.com/bookercodes) * [https://mastra.ai](https://mastra.ai) * Sam Bhagwat, CEO, Mastra * [https://x.com/calcsam](https://x.com/calcsam) * [https://mastra.ai](https://mastra.ai) _Recording and code examples will be available to everyone who registers._
