← Software Engineering Daily
Software Engineering Daily
Building AI Agents on the Frontend with Sam Bhagwat and Abhi Aiyer
00:57:04
Most AI agent frameworks are backend-focused and written in Python, which introduces complexity when building full-stack AI applications with JavaScript or TypeScript frontends. This gap makes it harder for frontend developers to prototype, integrate,
Loading summary
Transcript105 lines
- [00:01]
A
Most AI agent frameworks are backend focused and written in Python which introduces complexity when building full stack AI applications with JavaScript or TypeScript frontends. This gap makes it harder for front end developers to prototype, integrate and iterate on AI powered features. Mastra is an open source TypeScript framework focused on building AI agents and has primitives such as agents, tools, workflows and rags. Sam Bhagwat and ABHI Iyer are co founders at maastra. They join the podcast with Nick Nisi to talk about this state of front end tooling for AI agents, AI agent primitives, MCP integration and more. Nick Nisi is a conference organizer, speaker and developer focused on tools across the web ecosystem. He has organized and emceed several conferences and has led Nebraska JS for more than a decade. Nick currently works as a Developer Experience Engineer at Work os.
- [01:14]
B
Welcome to Software Engineering Daily. Today's episode features the founders of Mastra and I'd like to welcome to the show Sam Bhagwat and ABHI Iyer. How's it going guys?
- [01:23]
C
Hey, great to be here.
- [01:25]
B
Great to have you. Sam, why don't you go first and introduce yourself.
- [01:29]
C
So probably I'm best known for being the co founder of Gatsby and I worked at a few startups around the valley before that as an engineer. But I'm also the author of a book called Principles of Building AI Agents and now the co founder and CEO of Mastra.
- [01:48]
B
Nice. Well welcome to the show. Happy to have you. And I've definitely heard of Gatsby. Abby, why don't you introduce yourself?
- [01:55]
D
Oh yeah, I'm ABHI Iyer. I'm the CTO and co founder of Mastra. We have also have a third co founder. He's not here. His name's Shane. Just want to put the pour one out for him. Yeah, and I used to work at Gatsby as well very early on and that's how Sam and I met. And then I also worked at netlify because we got acquired by them. I'm sure we'll get into that, but that's how I got here.
- [02:15]
B
Nice. So yeah, just digging right in. How did you come together on Mastra? Was it something that was born out of something that you worked on Gatsby or. Yeah, I'm just curious how it got started.
- [02:26]
C
Probably the best way of saying it is that it was born out of frustration. So after Gatsby and sort of like we left netlify at various points but we were working in building a CRM and we Kind of thought that, like, we thought we did a lot of fun building dev tools and we were going to build something new, but it actually turned out that as we were building the AI parts of that CRM, which we called Kepler, and we were building this CRM for all three of us together for about like nine months or so, we started using building the AI parts of Kepler and using the kind of TypeScript AI libraries that were available at the time. And it just didn't feel like any of them were up to snuff.
- [03:05]
D
Yeah, yeah, we were pretty exhausted from doing dev tools for so long, so we thought like a CRM game would be a great place for us, which we slowly realized that it probably wasn't.
- [03:17]
B
What time frame is this? Like around what year?
- [03:20]
C
This was in October of last year, so October of 2024, when we kind of decided to pull the plug on the CRM and start building Master instead.
- [03:29]
B
Nice. Okay, so AI has been around for a while, like in its current form, ChatGPT and all of that. And the rise of agents is coming. And one thing that's very notable, and we should talk about what Mastra actually is, but before we get to that, it's written in TypeScript, which a lot of AI tooling right now is written in Python. So what was your drive to buck that trend and go with Typescript?
- [03:53]
D
I think originally it was just super self serving because we were trying to build AI features into our product that we were building and we were all TypeScript engineers and very much in this industry and community for so long. And the minute that you also. Maybe we're devtool snobs a little bit, but we did give things a fair shot. And in the fair shot meeting, like we actually tried to implement other people's libraries and there was a point where you were like, anytime you as a DevTools person, you think like, I'm just going to go fetch from OpenAI directly and just do this stuff myself. And then the amount of people like us telling us the same thing, it was just like a natural thing. Like we had to do this and it has to be in Typescript because that's what we. The whole point of what we were trying to do in the first place.
- [04:40]
B
Nice. Yeah. Being in Typescript was a major appeal to me. Just looking into it and getting started and playing around with it because it was one less thing that I had to be a complete novice at which all of the agent stuff when I was getting started was complete. Don't know what I'm doing And if I threw another language on top of that, then I really wouldn't know what I was doing. But it kind of helped to ground me a little bit and get going. So from there, let's talk about what Mastra actually is. How would you describe it?
- [05:05]
C
So Master is a typescript framework for building AI agents. And that means we have all of the primitives that you need, right? Whether that's sort of an agent, like running in a loop, whether that's like a workflow graph, whether that's sort of evals and tracing memory tool, calling RAG a local dev playground. You can build kind of an agentic feature into your SaaS app. You could build a whole new agent from scratch that's like, aimed at a specific industry or pain point. You could do sort of like internal automation of various types of workflows with LLMs and building like tooling to do that within your organization. We've seen folks build all sorts of interesting, fun use cases, whether that's like a personal email manager, like someone or Japanese community. Sort of built some anime generation, like, and anime sort of like writing and analysis. It was pretty neat to see what they were doing there.
- [05:57]
D
When we first started building the framework, we only had a couple of primitives. And we realized that there's just so many things that you have to understand when you're doing quote unquote, AI engineering. And so, like, we may have started Monster with like two primitives, like tools and agents. And that was cool. Then we slowly realized, like, oh, there's this RAG thing. Oh, like people need workflows. And then the number of primitives grew, but they had to be in a very sensible way. And then we learned that a lot of people were learning AI engineering through Mastra's primitives because we're essentially self documenting and educating people what exists.
- [06:36]
B
Yeah, definitely. I definitely fall into that camp of learning what all of these tools are and primitives through what Master provides and like, why I would use that. And I will say, for the longest time, like when I was getting started with it, I just couldn't for some reason wrap my head around what the heck an agent actually is. Could you give a description of, in your words, what an agent is?
- [06:59]
D
I was at a panel where they asked the same question. So I want to give the same answer, which was mine was very stupid and poetic, and everyone on the panel had a different answer. But I think the thing that we're trying to do at Maastra is to make this new wave of agents, which is a loaded term which is just like a box of compute and intelligence. Right. But he put it down. So like, an agent has a lot of things that defines intelligence. Like, an agent can speak, it can execute workflows which are like, for a human, maybe a playbook or might be muscle memory. You have memories as humans, so do agents. So we're trying to reflect the human intelligence through our primitives. And I think that's what really an agent is, allows you to do all that stuff. But the other people in the panel, they were like, oh, it's just a loop. Yeah, you know, so it is a very loaded term.
- [07:50]
B
Great. So the confusion that I had was like, how is an agent different from just like chatgpt, like a prompt? Is it just like a chat tool with some fancy prompt on the beginning of it? Is that like how it gets started? And when you're talking about the loop, is it that where I ask a question or give it some text, it responds and then we go back and forth and that's the loop.
- [08:14]
D
Yeah, that's. See, this is where it gets super loaded. Because some people could define an agent as one LLM call that maybe has like tools on it. And in that case, if you're using ChatGPT, ChatGPT has like internal tools that it calls because you don't really expose your own tools there. So then you could say, you know, that interaction is an agentic interaction. I think it gets more agentic when there are multiple turns that are happening in one request. So for example, I ask it to do something with unstructured data. Right. I'm using just, just a prompt. And then now there's a reasoning section that has to happen of like, what do I need to do execute? And then also what do I need to return? Which then may cause other type of interactions or other requests that need to happen. So, yeah, I think it's very much in a spectrum and that's kind of how we think of it here. It's like agentic is a spectrum. It could start as just like LLM calls, it could progress, it could into structured workflows where you are the puppet master and you're calling all the LLMs, but the steps themselves are who knows what's going to happen. Right. Because it's agentic. Then you get into this middle ground where you have maybe a single agent that does a bunch of things and orchestrates stuff by using its LLM and its tools. And then finally you get like the AGI thing that they sold us a year ago, which is you can just do unstructured thing to a network of agentic components, and magically all this stuff will just happen and the world will become a better place. So it's totally a spectrum.
- [09:48]
C
Yeah, I love that. And I think, like, if you're doing code execution, let's say, and then you're like, sending the feedback and the error states back into the agent, right? That's like higher on the agency spectrum. There are things that you can. You could score it something higher the more of these, like, advanced elements it has.
- [10:06]
B
And so all of those other pieces, like the workflows, the tooling and all of that, how does that play into, like, does everything start with an agent and then it kind of goes into those from there? In Mastra specifically, I would sort of.
- [10:18]
C
See them sort of like, put it that, like, you have these different primitives that you could kind of compose in interesting ways. So, for example, agents by themselves have to decide which tool to choose. And so, for example, agents aren't very good if you give them more than, let's say, eight to 10 different tools, even if you write really good tool descriptions. And so, for example, you could maybe you could group the tools that you're giving an agent into two different categories and like, wrap them into maybe two workflows. So you could have an agent that's calling workflows. You could also have, like, a workflow that's sort of doing an agent handoff, where sort of like one agent handles perhaps asking the user for some requirements, and then like, we hand it off to like, another agent that's doing code generation. So it's sort of like, see them both as, like, within Mastra, how it works is that, like, they are these separate primitives, and then you can compose them in any way you want. And I think that's really like the power, well, of two things. It's the power of AI engineering in general is having these different kind of primitives that you can compose in interesting ways. But it's also the power of master as a framework.
- [11:21]
B
When you say composing them, is that what workflows are like, composing all of these tool calls together, or how does that work?
- [11:28]
D
Yeah, so for composing them, like all the primitives in Master. So we'll start with agent, for example. And agent can have tools. It could also have workflows that get executed as well. And essentially those get executed as another tool that it has in its arsenal. Right. From the reverse perspective, a workflow, you can start with a workflow and for a step of a workflow can just. You can Pass it in an agent, or you could pass it a tool. Because now these steps are, you're in control. So now from that perspective, you're in control. You're doing a very deterministic thing. Our workflows do have control, flow and branching, et cetera, that you need. But the steps themselves are leveraging the agent primitive. If you really want to just YOLO it, we have a primitive called agent network where you pass all the primitives in there and then you just pray and then that's kind of what happens.
- [12:22]
B
So all of that is to try and bring some determinism to the task that an agent is trying to do.
- [12:28]
D
Yeah. So the reason why we kind of came up with workflows in the first place as an important primitive is that at the time especially, and even now, the models aren't good enough to just execute complex workflows. And a lot of the times the engineers that we're talking to to pretty much extract all these features out from when we're talking to them, they actually know what they want to do. So why do you need to prompt anything? You just write some code. Like, just because you could use a LLM doesn't mean you have to. Then we learned like it's what they're executing at the points of the graph that they know that they're going to. It's that during the execution is where they want to do like LLM calls or anything like that. At the beginning, our workflow system was super trash too, because we didn't really think it was that important. And almost sam, remember we almost didn't want to do it at all.
- [13:16]
C
Yeah, we debated that and we're like, well, maybe you should just use ingest or temporal or another kind of workflow engine. But one of the reasons we decided to build our own was that we saw that in AI engineering having this kind of workflow parameter that has tracing built in, that has a development environment where you can test it and replay it, is relatively more important because you're wrapping these non deterministic agents, these non deterministic LLMs, and being able to just kind of observe what's going on at every step is really important because usually in software engineering, if something is returning different output depending on, hey, if I ran my CI at 11pm versus 3pm and I had some like time zone issue that only came up if UTC is different than PST or whatever, right? Like we call that like non deterministic and we say that's a bug. But in AI engineering it's actually Just part of the game because you're working with these LLMs that are inherently non deterministic. And so you have to add all these like guardrails around them to get them to. They're very powerful, obviously we all know they're very powerful, but you kind of have to add these guardrails around them to get them to behave properly. And the idea that we have in Master of the structured workflow graph and this primitive that we have is one way that we do that.
- [14:28]
B
So let's take a step back and help to paint a picture of when someone might reach for Master or reach for creating their own agent workflow. Maybe start with an example of a great idea that you've seen or a great intro into this that you've seen as people adopt Mastra.
- [14:45]
C
Sure, yeah. So I'll give like an example of a company that we know very well. They're building something to generate CAD diagrams for like they're working in the aerospace industry and they're ingesting these like hundred page long PDFs of part manuals and stuff. And then you need to kind of like link these things up in some sort of electrical circuit depending on the capacity and the wattage and the voltage and all this kind of stuff. And you can kind of ingest some of the stuff from the manual. But this is obviously like, it is kind of a task that you need to extract a bunch of information, feed it into like an LLM in a creative way and feed the right amount of context. And so sort of using Master to wrap a bunch of these pieces and components in order to do that. So that's like a fun example where like hey, it's like OMS in sort of like a novel industry. Another one that comes to mind, there's another company that's using IT Master. They're sort of making software for veterinarians. So if the veterinarian is going and looking at your dog, when you bring your dog into the vet, they're sort of like talking to you and they're making notes verbally and it kind of translates the transcript of the conversation and the things they're saying. And it sort of takes that and it kind of generates like action items in their task management system that they built into their software. And you can imagine how you sort of wrap an LLM where you can kind of take this like raw text and end up with some sort of structured data at the end of the day, like delineating like a list of tasks or representing like a particular like CAD diagram.
- [16:12]
D
Yeah, when we first started in Y Combinator, we were in like the batch that everyone was focused on verticalized agents. And so those were our first users trying to build verticalized agents. And that's where we learned what primitives need to be created to serve them. And so a lot of our initial real world use cases came from people doing either bridging the real world to the AI through like back of house or some type of office type of thing, or they're trying to do like assistant co pilots in other industries, aerospace and stuff. Since then, it's been all over the place like internal tooling and things that Sam mentioned. Like, it's just kind of exploded from there. Kind of glad that we did the vertical agent stuff first because then we came to the market with a lot of primitives that people kind of learn over time.
- [17:05]
A
You're a professional software engineer. Vibes won't cut it. Augment code is the only AI assistant built for real engineering teams. It ingests your entire repo, millions of lines, tens of thousands of files. So every suggestion lands in context and keeps you in flow where other tools stall. Augment code sprints. Unlike Vibe coding tools, Augment code is built for shipping to production. And you don't have to switch tooling. Keep using VS Code, JetBrains, Android Studio or even Vim. Don't hire an AI for Vibes. Get the agent that knows you and your code base best. Start your free trial@ augmentcode.com can you.
- [17:45]
B
Define what vertical agents are so you.
- [17:47]
C
Can think about any of these kinds of real world industries? Maybe you're in finance, maybe you're in defense or manufacturing, and you have a lot of things that are like, specific to your particular industry. And so there's a lot of SaaS that, like, maybe it's a SaaS for like manufacturing, or maybe it's a SaaS for aerospace, or maybe it's a SaaS for finance. Specific workflow in finance. And so like, the difference obviously is like, now we're making agents that can work on and autonomously create complete tasks within that. Or they can be co pilots who assist humans in solving tasks, rather than just being a software that can kind of record, hey, I did X thing, I did Y thing, and a human is checking off all the items in the checklist. Like maybe the agent can generate the checklist, maybe the agent can complete some of the items in the checklist. So it's a software, but it's kind of doing work for people or helping them accelerate their work within their Industry.
- [18:40]
D
Yeah. And they were telling us like the target salary range, there's like two levels to it. You're trying to replace like the 50 case USD salary or you're trying to replace the highly skilled labor salary like 200k or whatever. So you got like these two groups of people working on both ends of that skilled labor section.
- [19:00]
C
But I think like more broadly speaking, like some of the first folks we had using Master were doing these kinds of things. But since then, more broadly a lot of people are like, hey, I'm trying to help the salespeople inside my company process a lot of the information they're trying to process faster and they'll build an assistant to help them do that.
- [19:16]
D
Right.
- [19:16]
C
And that's kind of the internal tooling stuff. Or they'll have like an existing SaaS app at scale and they say, well I need to build in an agentix screen to help people like find information within the SaaS app. And it's not just some sort of chatbot or on the side. It's really like a full screen takeover where it's like, okay, I'm going to go through and I'm going to go do some research that's like very specific to this kind of field and then I'm going to like summarize that and like check the results of that. So anyway, so they're building kind of these screens within like their software applications that they're working on that kind of have these agentic capabilities and copilot capabilities. But it's sort of like an existing SaaS app that's running at scale. And then I think also like there's just a lot of people that, you know, if we like rewind back to 2016 or 2017, a lot of people were kind of using Gatsby to build personal blogs and portfolio sites, right? And then if you fast forward in that world, the Jamstack world or whatever, people started using Gatsby and they started using Next and they started building maybe an E commerce site or they started building their company's website with Gatsby and with Next. Right. And I think like there's a lot of people that are just, hey, I'm playing around with these technologies and I created like, you know, our co founder Shane created like a storybook app where it would like generate stories for his daughter, his three year old daughter, right. And it sort of like wraps the image and generation capabilities from OpenAI and it's just such a cute thing. This is totally a story you could go read Piper. This is Amazing. There's a lot of these kinds of use cases too, where people are just playing around with it for our own fun and benefit and games.
- [20:49]
B
That's awesome. I definitely need to steal that storybook idea. That would be great. So, yeah, just thinking about it in terms of that, because I feel like that's a good. Everyone understands stories, and there's lots of ways that you could approach that. I've, of course, done that with my kids, where I just. I give chatgpt. Here's a list of things that my kids want in the story, plus here's maybe a lesson that I want to teach them, like, oh, be nice to your little brother, or things like that. And then it can generate a story from that. But this is going deeper where it could actually create a book with images, and the images could make sense between pages, and you have to sort of.
- [21:24]
C
Keep the characters maybe consistent right through. You're not just generating five different images that are disconnected from each other. You. You need to have consistent character representation across the story. You have to have consistent narrative formatting. There's a lot of thought that goes into creating it in that kind of level of quality that you can kind of build into your agent.
- [21:41]
B
That's fascinating. Yeah. And there's a lot to that. I'm just trying to think of how I would get started with Mastra, and you have a lot of these primitives, I guess. How do people who are getting started with it learn how to orchestrate all of them together? Is that something that the docs cover really well? Is it just kind of intuitive as you get in there? Is it kind of like trial and error?
- [22:01]
C
It's both and all the above.
- [22:03]
D
Yeah, it's definitely all the above kind of thing.
- [22:07]
B
So.
- [22:07]
D
Okay. At Monster, we think docs is our second product. It's like, as important as anything we built. And in doing so, that, I mean, Community as well, is another product. But, like, in doing so, the docs have to be super good. So we try to make our docs amazing. We think they're decent, so we still have a long way to go. But then we started seeing a trend of people are just hanging out in their ides, so we should meet them where they are. So we made an MCP docs server so you can, like, get the docs into your IDE and ask questions and stuff. You can also ask it to write code for you. And that was a good way to introduce people to Mastra. But then eventually, even with the docs and stuff, they don't teach you Architecture, they don't teach you essentially what to do. So we created another extension of the MCP docs, which is the master course called Master 101. So you can actually take a master class from us within your IDE through the monstera Doc server. You just say if you have it installed, you just say start course. And then it'll go through a bunch of chapters that our co founder Shane, meticulously developed to kind of teach Mastra. And then that's another place that we're once again second product. Right. We're consistently iterating on how do we educate people where they are.
- [23:31]
C
So actually features that like you wouldn't even think about is that that course can speak to you in whatever language you speak. Right. It can speak to you in French, it can speak to you in Japanese because it's the LLM teaching you. Right. So as far as we can tell, it's the first course released as an MCP server in the world. Maybe someone else did it, but we aren't aware of it and no one else has been able to tell us, like, hey, someone else did it first. So we think we're the first.
- [23:57]
B
What a brilliant idea. I hadn't considered using MCP like that. And just I guess to ask like a more technical question on that, like the MCP piece of that is that like keeping track of your state through the tutorial or through the course. So it's like, I'm not going to give you step two until you've shown me that you've completed step one. And all along the way it can help you debug that because it's just using the LLM to do that. Is that kind of what the MCP is providing to it?
- [24:22]
D
Yeah. And like, if you give us your email, of course, so we can show you the results and stuff, but then from there we're just tracking your course state. And you could always reference it. You can always say like, oh, I'm done with all the courses and stuff, and go through it and stuff. But yeah, that's all there. People can track their progress. It looks really nice too.
- [24:41]
B
Nice. And is that built with Mastra?
- [24:43]
D
It is, yeah.
- [24:45]
B
Nice. So that answers another question.
- [24:47]
C
Yeah. When MCP started taking off, we created like an MCP or MCP primitive. So you can build an MCP server, you can build an MCP client, you can build those using Master. And we see a number of folks doing that.
- [24:59]
D
We got so lucky on the MCP hype because it was like January or November, actually, because for Masha we were thinking like, oh man, we're going to need to get all these tools and then we're going to build a bunch of tool integrations. And then we discovered mcp like the next day, and we were like, should we just do this instead? And then we just took a bet and then it was good. So we had like MCP support from the beginning.
- [25:22]
C
Everybody was releasing MCP registries and we were like, what if we just. Our friends are releasing MCP registries. What if we released an MCP Registry Registry and then that went viral on Twitter? I think maybe it was the meta ness of the joke, but lots of people were like, well done, guys. Like, here's the thing is that's actually like. It was like a joke that became a feature in a way, because tool discovery for MCP is like a real thing. And like, you know.
- [25:49]
D
Yeah. And Anthropic is making a Registry API. So I don't know. Like, a lot of things we do are meta on purpose because that's the way we think and we're a framework, so it has to be meta. But it's also really funny. And it's also funny because you don't know if we're serious or not, because we are kind of serious, but we're also kind of not. You know, the Registry Registry was epic because people were like, wow, what a great idea. And we originally released that as kind of like a joke.
- [26:17]
C
You know, we got lots of inception memes. I want to go deeper.
- [26:23]
B
All the best tools are like that.
- [26:25]
C
If you die in this, you die in real life.
- [26:29]
B
There's a couple questions that came out of this that I wanted to ask. So on the MCP side, MCP stands for Model Context Protocol. It's a way to give an LLM or like an MCP client, Claude desktop, Claude code cursor, any of those. The ability to act on your behalf or to get information from sources that it may not have information from, but also actually go and execute tools. But at the end of the day, it's just like a rest endpoint that the LLM knows how to hit and get data, send data to and get data back from. My question is around that you said that you're on there from day one. How does that relate to, I guess, the tools in Maastra? Is that the same thing? Are they different? Because I think of MCP a lot as like tooling, but should I think of Maastra tools in the same vein or are they different?
- [27:18]
C
One way of thinking about that is that an MCP server, like an agent is like a container for tools. But you could imagine if you have a bunch of tools, you could put them into an MCP server and you could just give it to your local windsurf agent or whatever and sort of see like, hey, how does the windserve agent interact with these tools when I put them in an MCP server as a container and give it to them, Great, that's what the MCP primitive is. But because it's this decentralized way of interacting with tools that you don't control, people have created these MCP servers that wrap tools to access GitHub or Notion or all these interesting third party services. And because there are now all this, you know, we as devs like we have to write lots of integrations to do our job, but we hate writing the integrations and nobody wants to write integrations. And so like in some ways like these MCP registries have ended up being kind of like this decentralized integration hub that now your agents, your master agents can interact with. Because your agent can like take in MCP servers and if you like feed in an MCP server as like a tool essentially it will be able to access any of the tools contained in that remote MCP server that someone else maybe wrote that you maybe had nothing to do with. But someone else created this functionality and wow, now my agent is even more powerful because it can use all this third party functionality that someone else has kind of built.
- [28:41]
D
Yeah, the low key benefit of that is the MCP server doesn't have to be written in JavaScript. You could use tools from all over the communities that serve your purpose, but you still connecting from your JavaScript written agent or you know, application. But we do support you writing your own tools of course, so you can write your own functions for tools and they work. We think of MCP like a better NPM now for this, but there's no governance there just yet. But yeah, you can also just use import from NPM and then make your own tools as well, but might as well just go on the MCP train.
- [29:17]
B
Yeah, nice, I love that. It's like so much extension for free effectively for all of this. That's awesome.
- [29:25]
E
Building agentic AI apps isn't just about choosing the best. LLM agents need short term memory, long term recall and lightning fast retrieval. Without it, you're left with clunky prototypes that never scale. You know, redis the world's fastest caching solution. It turns out fast data is the key to good context and good context is essential for fast accurate memory. It's what makes AI agents actually work with your data. Redis for AI the right infrastructure, the right tools, the only way to scale. Learn more@redisio genai.
- [29:58]
A
Have you tried building a text to SQL chatbot? If your AI agents don't understand your data, its definitions, queries and lineage, they're forced to guess. And bad guesses mean risky assumptions. That's where SelectStar comes in. SelectStar automatically builds an always up to date knowledge graph of your data, capturing metadata like lineage, usage and example queries. So whether you're training an AI model or deploying an agent, your AI can answer with facts, not assumptions. Stop the wrong SQL queries before they happen. Learn more@SelectStar.com.
- [30:37]
B
The other question I had that came out of that the discussion around your docs was like treating docs as a second product. I have used the Mastra docs MCP immediately. It was like night and day difference adding it and then it just knew everything and made it really easy to get up and going and it knew what I wanted to do and it knew what the capabilities of Mastra were right out of the box. My question is that's great when I know what I that I want to use Mastra. My question is like around, you know, being a dev tools company and like having this new ish dev tool that may not be like, you know, in the memory of LLMs, like it might have come out after their training dates. Right. How do you see that? How do you see marketing a dev tool in today's age? As you're consistently getting more and more people that are not going to go to Google to ask, you know what, what kind of tool I should use to build an agent, they're just going to ask ChatGPT or Claude. Is that something that you think about?
- [31:33]
C
We think about it a lot. I mean honestly, this is kind of our second time go rounded. One of the great things about open source is the community and the fact that people can build things and share them with other things. Part of the community is also you can show up at AI Engineer in SF and it turns out someone else is running a workshop on Master and showing people how to use Master and you're like, holy crap. Like I'm showing up at a conference and someone else is running a workshop on this tool that we all built. This is crazy and this is amazing. We also like wrote a book and this was just kind of like this idea that came to us one day when we were just kind of like so the book is called principles of building AI agents. It's again, like, it's 140 pages and kind of just walks through all of the. Like, what is rag. What is prompting? How do you write good prompts? How do you. What is an agent? You know, what are the kind of, like, tool calling it walks through, like, all the kind of core. Core concepts that also just kind of came after. We'd done a lot of these kinds of, like, whiteboarding sessions with other people that were trying to build agents. And we'd just kind of have these interesting conversations and have these. We'd kind of. Every time we had that, we'd share some insight. People like, oh, wow, this is really interesting. I didn't think that maybe I should be splitting up this, like, one LLM call into, like, 12 different LLM calls. Instead of trying to, like, have this one LLM call decide whether these 12 pieces of information, maybe I should just parallelize them and split, you know? And so, like, we just had so many of these conversations, and we were like, gosh, it feels like everybody's figuring out how to do this, and maybe we should just write a book at it. And I write pretty fast. And so we already had docs that were kind of like an outline and kind of a taxonomy almost of those different concepts. Except when you're looking at docs, it's kind of 20% explanatory text and 80% code. And so we just kind of took that, but then flipped it where we expanded the explanatory text, where it was like 80% explanatory text. Text and kind of 20% code and some historical background. And it was like a couple of weekends, and we kind of kept writing and kept writing and kept writing. Then all of a sudden it was like 90 pages, and we're like, okay, I guess this is publishable. So we published the book, and the reception has been really incredible. I think a lot of people have said, like, hey, I keep hearing about agents, but when I kind of read the book that you guys wrote, it kind of all made sense to me, and I actually understood how I would do this. I think the receptionist has just been like, we've been really kind of humbled, and we try to pass out a lot of copies of books at events.
- [33:50]
B
And such now can confirm the book is great. I put a lot of pieces together in my mind. So, yeah, plus one on that.
- [33:58]
D
For the LLM SEO technical bits, though, we do do LLMs, TXT and full text and all that stuff. And then it's pretty much kind of our game there. We're starting to get into like ChatGPT responses now, but that's probably just because we're kind of all over the Internet right now. There are actually companies in our YC batch that job is to help you get onto LLM's responses. Like, that's their business. So there's probably a whole little playbook that they have to do there.
- [34:30]
B
Yeah.
- [34:31]
C
One of the things too is just about the models basically scan the Internet right when they're doing. Especially when you put them in deep research mode, they kind of. They scan the Internet and they pick up what's on the Internet. So you know when your community members. And this happens a lot, right? Like tutorials about Master, like that gets picked up. We didn't have anything to do with that. Someone just got really excited about master and wrote a tutorial. And sometimes that tutorial is in Japanese or whatever.
- [34:53]
D
Right.
- [34:53]
C
Because there's a huge master community in Japan. Well, that's been kind of also one of the biggest things that has probably helped us on that front is just like the community being excited and like writing things that gets kind of picked up. We've talked to other sort of dev tools folks, as you know, at resend, and what basically happens is like when your tool has become the consensus choice among developers, the models can kind of figure that out just by like reading the Internet and seeing how people are describing it. And so when your tool has become the consensus choice, you almost get like an amplification effect. And so I think that's great because, like, what that says is that you should build a great product that, like, people love. If you build a great developer tool that people love using, everyone feels is the right thing. And if you are successful in doing that, then the models will kind of surface that to people who are coming in, asking them.
- [35:44]
B
That makes perfect sense. And so it seems like what we're doing to get your name out there for people to use it, it's all amplified by these tools. And they know how to surf the Internet just like us. So that's good. And then getting into actually using these tools as new tools come out, you're positioned in the perfect spot with your own docsmcp that immediately just gives all of the knowledge to the LLM to help you. So that's great.
- [36:08]
C
One of the other things that's really helped us a lot, we've kind of gotten the band back together from the core team that was at Gatsby, and I think we all working together and we all sort of like we've done this before and so we think we can work together pretty quickly to build great stuff. And so honestly that's probably the biggest thing like working in our favor is just having a lot of great folks that like working together and have built an open source JavaScript framework before.
- [36:35]
B
Nice. Yeah, yeah, for sure. One question I was going to ask is abhi, you mentioned kind of like almost stumbling into mcp, like just being right there at the right time to jump on it. I'm curious if there have been any other decisions or things that haven't panned out so well that you've had to kind of pivot from.
- [36:53]
D
So first thing we did, we tried building a prompt builder, like a utility function that helps you build prompts. This is when prompt engineering was all the rage and actually models at the time were okay with XML tags and stuff but now it really doesn't necessarily matter. So we built something like that and then that's when we really learned that we should listen to our community more because we posted an experimental exploration, we got a bunch of feedback from our and at that time we had nobody really in discord. I'm sure nowadays we get a lot of opinions but like at the time we had like some early contributors that are just like this is why I would never use this. And there was like a bunch of valid reasons and we were like okay, let's just not, let's scrap this. We tried building like a MCP registry ourselves and then we tried to get other registries involved early but then with the lack of anthropic owns, the spec and the governance, it's hard to try to get in there and sort of shake some motion up. So we kind of just did our, you know, the registry registry thing and then we'll maybe revisit stuff like that. The last big one or that I remember is our initial version of workflows would never have worked for what we were trying to do. And so we kind of built it half assly in the beginning and then we kept going on it because we were too far in. Much like many developer teams get into. You're like too, you're too far in and you can't go back and then you realize that you have to just go back and then. So that was like a big time sink for us. But I'm glad we did because now we have a lot of power that we can then use going forward.
- [38:37]
C
So there's been other times it's just taken us the the time to Find the right thing. So like, initially we knew we wanted to work with aisdk, which is the library from Vercel, as a model routing layer. But the first way that we did it was kind of, we were sort of republishing a bunch of their packages with sort of a little bit of a wrapper. The import structure was like too long. And then we were finally like, why don't we just expose their API? So we sort of ripped out our whole model routing layer that had been built on top of their model routing layer and just said like, use their model routing layer while we were trying to figure out how to like with it. But it wasn't the right API, you know that. And sort of like this new workflow engine that we launched in I guess March, like those were the last two sort of like Big RE architectures, like that one was in January. And then the workflows, like we called it VNext at the time was in March. Those are like the two Big RE architectures that we've had to do over the, you know, nine months we've been working on this.
- [39:32]
B
Nine months. That just got me thinking about how different the world was nine months ago.
- [39:37]
C
Yeah, AI time is sort of like two to three or four times as fast as normal time. I think it's just something different is happening in this part of the region. It's like singularity, black hole, something. Time dilation. I don't know what it is.
- [39:50]
B
So you're focused on building these primitives. Right. And I'm sure that things have changed dramatically in the nine months that you've been doing this. Have you found that the choices that you've made have been pretty resilient amongst all of the changes in AI and do you see that trend kind of continuing?
- [40:06]
C
Yeah, I would say like the first generation of AI frameworks like LangChain, what they kind of tried to do is they tried to do a lot of this prompt engineering stuff because at that time the models weren't good enough. And then something flipped around June or July about a year ago where the models were good enough and then the right thing to do was kind of build these like workflow based abstractions on top of that. By when we started working on the problem, we landed on the correct abstraction, which is build the agent abstraction on top of the models, the workflow abstraction on top of the models. The other big thing that has stayed the same over the last nine months or 12 months, but was kind of different than before is that when you're building on top of APIs. You don't need to do any of this sort of matrix multiplication kind of machine learning stuff that a lot of the Python people are doing. Which means that there's not a default language that you should be using. You can use any language. And why not use a language that you can build your whole app? And you know, why not use TypeScript? Even though things are moving quite quickly, there was distinct inflection point. And then we started building on the right side of that. We ended up with the right architecture.
- [41:12]
D
Yeah, it feels like we got a little head start with then like the rest of the world by starting early. And like, every week we have like this channel in our slack called Kindergarten where we like, share all these blogs and white papers that we should read.
- [41:28]
C
And I'll be named that because it was like, hey, we're all going back to kindergarten. Like, we all got to learn this stuff. Like, I think one of the things that to stay up to date in the AI world, you have to stay humble. You have to, like, not think that you've learned it all, because nobody's learned it all. And there's new stuff coming out every week. I think it's hard to not be glued to kind of Twitter X in that world because you're always just like, scanning for what the new model releases. And, you know, there's just a certain set of podcasts that you like, obsessively, like, listen to and whatever, but, like, you stay humble and you stay in kindergarten to.
- [41:59]
D
Yeah. And then when you look at the articles and stuff that are coming, like, and these are like research papers and stuff, a lot of them are coming out before Sam Altman tweets about them. And that's kind of like the signal that everyone else is going to do, like, come into the thing. For example, agent memory. We've been focusing on that since we started the company essentially because we were reading a bunch of white papers on that and it wasn't mainstream yet. And then what did OpenAI do? ChatGPT has memory now, which now made people realize that this is a primitive that exists. So, like, I think we were very fortunate that we had a little head start and also are in the mindset of, like, always learning because we haven't been off yet on our predictions on, like, what's going to happen or, like, what thing is based on what we've read and stuff.
- [42:45]
B
Nice. Yeah, that's very fortunate. And I love the idea of just that Kindergarten channel. I want to adopt that for sure. It's just like Constantly take me back to school. We know nothing. That's one thing. You mentioned the AI engineering World's Fair, talking to people there. It was so great because I realized that everybody who's in the space right now, we're all just learning together and there's so much to glean and so many ideas. I just left there brimming with, with ideas. And what an exciting time to have a great dev tool in that space. The final piece I wanted to touch on was your developer experience. I think that that's one of the major selling points of Mastra. Just in my playing with it day to day. And it's so easy to get going from. The command line utility that walks you through getting set up, suggests a model to get going with and then like, boom, pops you into a browser based environment where you can see the agent, run the agent, see what tools it's calling, see all of the workflows and all of that. How did that come about? Was that like through your experience building Gatsby and other dev tools that you just kind of knew how that was going to go or a lot of trial and error?
- [43:51]
D
Again, there's a funny story behind it and Sam can add some color there. So the first version of Mastra, let's say Mastra Negative one. And at the time, this is like October, right? So at the time, AI products were very much GUI driven. So the nature of having a playground for us, like Monster was not code first. It was actually like JSON structure first. And you'd actually create all the agents and stuff through a UI and all that. And so we showed it to a bunch of people we respected and they just said like, oh, that's cool. And if you're a dev tools builder, anyone says that's cool actually means go F yourself. Really, they're just too polite to tell you that you're doing something stupid. That's cool. Like. And I just knew I was. I remember Sam and I were together and Shane, I was literally distraught. All these people I respected just said, that's cool literally means like they should tell me to go jump off a bridge, right? So I'm just all distraught. We're at the bar, I'm like, guys, I think we have to rebuild everything. And we did, which was the right thing. So it was good. But the, the playground was like, when we changed everything to code code first, we were just thinking like, hey, this playground was pretty cool though, so we should probably keep that in some way. And then Sam, you and Shane kind of have the brilliance behind that. So you guys, you should take over the story.
- [45:05]
C
I think Shane was kind of the one that really pushed for it the most. But to get the playground to work, we had to do a bunch of really kind of crazy bundling stuff. So what you do in the playground, the playground is kind of a visual chat tool. So Monster is a backend tool. You're building the back end of the agents, but then you kind of want to see how it works and see how it responds to different commands. And so it gives you a chat, it lets you see the traces. So it kind of gives you like a tool playground where you can see inputs and outputs. It gives you a screen where workflow visualization. So if your steps have, you have branching or if you're chaining them together, it'll just show you them and then like you can put in a sample input and it'll kind of run them. It's like that inner loop of development, right? You're like, oh, this thing is in the right direction, but I just need to tweak this bit, I need to tweak that bit, I need to add a step here, I need to tweak the prompt there. I need to think about this edge case. And we just do so much of our development loop is that inner development cycle and we just kind of were like, gosh, we were sort of porting our old playground because initially in Monster minus one that we had in October, November of last year, the UI was driving it. In this case it's a read only ui. You're not changing the code. You go to VS code or cursor or whatever to change the code, but you can see how the code that you've written, what it does and you give it this input and like what the output is and then we sort of switched it over that way and we're like, you know, gosh, this feels like it's kind of cool and it like, it really feels like this is something kind of unique and different. But once we kind of like committed to it, you know, it was just like 10,000 little things is the UI details where it like highlights the step in green when the step is running and then it moves on to the next step and the next step in green and you can see the input and output at each step. And like what do you do when you have like a really big diagram and how do you represent like nested workflows and how do you arrange the agent chat and how do you represent the tool call in the chat so it displays visually Differently. And we just sort of went through the iteration and then, like I said, a lot of bundling stuff we had to do because you're exporting your workflows and your agents, right, in a way that you could use it in other bits of the code. But also you have this kind of dev server that's kind of using them and pulling them into to like a different type of environment. So there were some, like, gnarly stuff there that like, Ward from the team had to work on to get it right there.
- [47:23]
D
Yeah, that's a good point to touch on, like the skills that we learned at Gatsby to pull something like this off one, we became Bundle. We call them Bundle Ruskis. If you think about it, there are not many, few people left in the earth that can bundle JavaScript proficiently, as we used to do back in the day. And so we used to do it back in the day. That was like our job. So, like, and we had to do it. How many people had to do it? So there are very few people on the planet who can bundle JavaScript. So that's us. Second is we used to create Gatsby's GraphQL server from all the BS framework code. So we're really good at making servers too. And that's kind of how the playground comes about. We transform the framework into a master server, which becomes the rest endpoint for the playground, which has some gnarly bundling stuff with bundling server JavaScript, but then it allows us to do cool user experiences like that. It also allows you to run Mastra as a server or you could just run it as like an import in your current application. So, like, being good at bundling allowed us to have two different modes of usage.
- [48:25]
B
Nice. I didn't realize that and I agree. I've dabbled in bundling and just get frustrated every moment of it. I think that these tools are very important just from also a learning perspective, being able to put things together and then see it visually like that. Don't discount that. So I think that you're definitely on the right track of just helping through those tools to easily help people like myself who are new to all of this, understand what we're actually building and how it all works together. Kudos on that. I wanted to ask about like Roadmap or Vision for the Future. Things are changing constantly and is it a lot of reactive based on how things are changing in the world with AI, or do you have plans for new features coming to Mastra? Do you want to speak to that.
- [49:14]
C
It'S sort of a variety of a lot of different things. So the core primitives are what our roadmap looks like right now we know what our core primitives are, and some portion of our roadmap is interoperability for our core primos. Right? Some of it is we're working on some new eval stuff right now where we have the concept of this scorer and a score, which we think is much better than these LLMs judge and evaluator kind of tools. But we've built that into the playground, right? And then after that, we have a cloud product and we're building it into master cloud as well. And so it's sort of like, hey, you have these changes in the core that kind of like, you know, ripple out across things. Like we're, we're working, for example, right now on templates, and so like, you know, just walking through kind of like, hey, I want to build a docs chatbot. Here's a starter code repo template code repo for you, you know, to install like a PDF, upload these like, really basic use cases. And it's like, well, okay, cool. We built this, like, library. Now we're going to get the CLI installed. Now we're going to run like a hackathon to get in the community, to get the community to build some templates. We're going to like, have. Get the templates working in Playground, and then the templates have to like, go in, you know, in cloud. So some of it is like that, where you're like, I got to trace this feature across a number of different platforms almost Think about roadmap. Some of it is coming from sort of like externally to us. So like in the space in general, it's kind of two of the biggest problems in like agent building are one problem we call like synthetic evals, which is how do you take this, like raw traces that you're agents and workflows are emitting and sort of turn that into like a set of tests, a set of statistical tests, these evals for your agents. What's the loop that helps you do that? And then another one is like agent learning, which is how do you use those, like, again, that like raw exhaust of kind of like traces and actually improve your agent performance. And given what it did in the past, you know, kind of learn from that, that data. And like, those are sort of like two broad problems that we were sort of like widely recognized in the space problems. So we're like, we're working on various approaches to there, but like that's coming from the space as a whole. We're thinking about this and there's like other folks thinking about this as well and like somebody's going to figure it out over the next few months and we hope, you know, we'll either be the, you know, one of the first ones to do it or like once it's accepted what the right way of doing it is, then it'll be really easy to build that into master. Like one of the kind of the two things, broadly speaking. The other things that we're thinking about are sort of like agent authentication agent, sort of like security guardrails for inputs and outputs. ABHI was talking about our multi agent primitive or agent network. We're working on an event based execution system where you can sort of custom define events and have them kind of like bubble up multimodal support. Whether it's like images and voice, we have some stuff there, but there's going deeper into voice, thinking about video, all these. The frontier of what the models are doing is shifting so quickly. A lot of other bits are the sort of integrations with other kind of their agentic front ends, like Copilot Kit and Assistant UI for example. And we have a lot of work that's work really well with them. And then a lot of the other sort of providers in the space that have sandboxes for code execution and browser use tools, web scraping tools, good integrations there. So I think a lot of it is driven by the ecosystem. A lot of it is driven by the natural development of our own primitives.
- [52:41]
D
We got a lot of work to.
- [52:42]
C
Do, that's for sure. I mean time moves fast, but I think the space is evolving so rapidly.
- [52:49]
B
And it's like, yeah, it's constantly changing, but you seem to have a good instinct for it now. So keep that up, keep it going. Is there anything that I didn't ask you about that you wanted to mention about Mastra?
- [53:01]
C
I think one of the lessons that everybody should have is that kind of something ABHI alluded to earlier. Whenever a new team member onboards, it takes a month or two for them to kind of learn all the agentic kind of concepts and how everything all works together. And we've now watched probably a dozen folks go through this transition and it's just a little bit of time and immersion. And I think, you know, if you're new to this space or if you don't feel like you don't know a lot and a lot of what we said might be these like terms you're like, what are they even talking about?
- [53:29]
D
Right?
- [53:30]
C
Don't be dispirited or discouraged. We've just, we've watched so many people go through this. It's just try to immerse yourself in it. However, you can build something yourself and that's the best way of doing it. You know, hopefully, you know, just use master, like find some toy storybook type project where you can like build it. That would be like cool and fun and interesting and like use that as a vehicle to learn the concepts. You know, read the book, free copy at like monster AI forward slash book. Just like immerse yourself in it for like a month or two months and you know, you'll sort of go from like, I don't know what this stuff is and what are these people even talking about to like, wow, this is like pretty cool. And I, I'm getting the hang of this, right? I think that's our biggest like advice or takeaway for, for folks.
- [54:09]
D
Yeah, we're really dedicated to the education part of this. So like every Thursday there's a master workshop if you want to learn something new. Even things that we learn. Tomorrow we're doing a lesson on background agents with cursor and codecs and stuff. Sometimes it's not even about master. We just like teaching things. And on Mondays I remember back in the day when I was learning JavaScript JS Jabber was so cool. I used to listen to that stuff. So we also do like a live stream agents hour where we talk talk crap with each other about just the things and. And that also gets people. We've had so many new people to the community come through there because they. You're now in the days where you're vibe coding and you're vibe listening to people vibe code themselves and like it's like this whole world that's coming. So I would recommend if anyone's trying to get into this, just come to those things and we're happy to have you.
- [55:00]
B
Nice. Yeah, I will try and be at the next one. That sounds great. How can folks reach out to you or learn more about Maastra?
- [55:07]
C
We're mastraai on Twitter X I'm calcsam. That's C A L C S A M on Twitter. I would say like you can also like npm create monster @ latest and like you know, just kind of walk through that. Then NPM run dev and spin up the dev server and kind of just play around with it, you know, for. For yourself as well.
- [55:27]
D
Yeah, you can find me on X abhi Iyer, and then, yeah, just come join our discord. We interact with the community. So come say what up?
- [55:35]
C
Yeah, please do. It's an exciting time to be a developer. I think it's an exciting time to be building. And there's, like, so many things that we can build now that we couldn't have built, like, even a year ago or two years ago or, like, two years ago. And that's one of the things that just gets me excited is, like, seeing all the cool things that, like, everybody is building, all the cool agents people are building these days and all the cool AI engineering people are doing. It's just. It feels like a world where, like, there's magic, you know, there's kind of like that sort of magical moment when I was learning how to program where I'm like, whoa, you know, I'm doing this right? And, like. But I. I didn't have that kind of experience again until. Until AI, and I think we can all have that kind of experience again.
- [56:12]
B
Yeah, I'll definitely second that. That feeling came back to me learning all of this. It was very exciting and still is. So definitely I'll second your suggestion on that. Thank you for sharing all this knowledge. I love the DX of this tool. I love all of the ideas that you have with the DOC server. I really want to check out this teacher. Mcp sounds really awesome, but most importantly, I'm just, like, really excited about your excitement for teaching this and being open about that. And so I think that everyone can learn a lot from you guys, and I look forward to learning more as we go. So thank you so much for joining Software Engineering Daily. Abhi. Sam, thank you so much. Have a great day.
- [56:48]
D
Thank you.
- [56:49]
C
Thank you, Nick.