# Ship Code at Scale with Grok Bot and Cursor

Channel: Grok
Video: https://www.youtube.com/watch?v=lpi-9F5KJJo
Duration: 57 min
Language: English
Words: 10115
Transcript page: https://viewrankai.com/tools/youtube-transcript/lpi-9F5KJJo

---

[0:02] All right. Well, I do want to be mindful of everyone's time. We've got a lot of content to get through and everyone will receive the recording afterwards, but to kick us off, my name is Zoe Barns-all super excited to be here with everyone today. Welcome to scaling engineering workflows with Grok Bot and Cursor. I'm from our super intelligence

[0:23] deployment team here at SpaceX SI. I'm joined today with Ryan. Do you want to quickly introduce yourself? Yeah, how's it going everyone? I'm Ryan and I am a senior field engineer here at SpaceX. I'm based here in Chicago and yeah, excited to be talking with you all going to give you all a lot of insight into what we see with our customers,

[0:46] what we've seen deploying it internally. You'll get a whole bunch of the behind the scenes details here today. All right, we've got about 50 55 minutes left in the session. Ryan will be focused on talking through the topics and leading the discussion, but if you guys have questions, please feel free to drop them in the chat. I'm here to help answer them and to surface any to be answered live. So with that,

[1:11] I'll pass it to Ryan to get started. All right, let's do it. All right, well, we'll start here. Yeah, safe harbor statement, forward-looking. I won't do the the speed reading thing, but yeah, these reflect our plans, it could change. Yeah, so now to jump in. So like I said, I'm a field engineer and so I kind of look at this and before this I've been a founder, I've been a PM, I've been an engineer. So I've I've been in a lot of different roles and one of the things that I wanted to kind of go over going through this is cuz I work with a lot of

[1:46] our customers on actually implementing this, adding this into their adding AI in general into their workflows, whether that's coding, whether that's Grok Bot, which which get into later. But one of the things that I want to point out that's like the most common thing I see that, you know, from my vantage point is that before AI, everything was much more

[2:07] linear in flow. Uh you would get some sort of request in, right? You would have a requester who requests it. You'd have someone who then triages that request. Um you would have a PM maybe make a spec or something for actually fixing it. Um and then you have your designers. Maybe they're in Figma, maybe they're back-end designers. They're doing things in um you know, doing back-end designs,

[2:33] architecture designs, things like that. Uh then it finally goes to build. And so all of those things had to happen before build because historically, you know, building took much longer. It took much more effort. Um and then it goes through review, QA, ship, etc. And so I think where a lot of people are today is there's still that same flow, but now you have sort of AI kind of worked into

[3:00] various of these in different ways. Sometimes all of that is connected with one tool or a suite of tools, which we're going to talk about today. Um sometimes it's a little bit more disparate or you have MCPs that allow you to kind of uh bridge things together. But I think even a lot of companies that have some or all of these leveraging AI to speed things up have it leveraged, but still in this kind of like pipeline linear fashion. And so one of the things that I was going to talk about today was how this um has kind of changed in some ways uh from this relay where someone reports

[3:37] and like maybe it takes 2 weeks, right? Someone reports, someone triages, someone does the mocks and the reviews, someone builds, someone reviews and QAs. And and again, even with AI, that can be kind of slow. What we do now here, and I think, you know, uh to the point of this this talk is that you can definitely grow this, speed things up if you kind of rethink the way that you have to organize thing, so where it's not necessarily as linear, but you have a lot of different people working together, and between the people, the bots, and everything else, and you're able to kind of see what it looks like when a team

[4:20] works together. So, I wanted to show an example. I chose this one just cuz it's there's nothing you know, too uh Yeah, it's it's a pretty straightforward one. So, here we had some basically wanting to there was a bug that I found, wanted to fix this bug, and I reported it, right? The first thing is that we have a bot that jumps into this thread, and before anybody even touches it, they're able to go through, they're able to review what's actually in my request, and say whether or not they agree that it's an

[4:56] issue that needs to be fixed or not. Then from there, the cool thing here is that we have a designer, we have a senior engineer, and so we have multiple people kind of jumping in this thread, and this is like a pretty simple one. Basically, they're supposed to be like a little icon here that shows that this is a team bot, as

[5:14] there is now. But, yeah, you know, I reported this, the designer's able to say something, and then the thing that happens here is our engineer hires the team bot spot. It's going to be a really annoying name for me to say, but basically for our team's bot feature, he has created a team bot that is focused on reproducing issues. It'll tell you actually Slack triage, linear bugs, things like that. And so, basically, you know, this bot takes a crack at it, This bot goes ahead and shows a screenshot of the issue that it's talking about and the fix that it's talking about. He's able to just ask the designer, "How does this

[5:57] look?" This is something that's also cool in this flow. This designer then comes in and is like, "Ah, you actually missed an edge case when there's a really long name, right aligned appended icon, what does that look like?" And so, the bot says it's a good question. Um you see here another piece that real time he's able to kind of um steer the bot or tell it, you know, not to do something for the future. And then finally, we get to the end. We see this edge case as well when you hit command and uh this pulls up. It still looks good. And so now, you know, he can say

[6:31] you did good Grok Bot. This got merged and I was able to say, "Thank you." And this whole flow, I think historically could have taken, you know, a day, 2 days, maybe you accidentally merge it the first time um without that extra accounting for the command key or something like that. So maybe this turns into two PRs, two reviews, etc. But this took from 8:41 a.m. to getting merged by, you know, basically an hour and a half later. And so that's kind of the uh the benefit of being able to have a human, two bots, uh you know, another human all working together in a flow that's like not this

[7:09] linear flow anymore. You can kind of just go ahead and build the prototype and sort of like work backwards from there uh which speeds things up a lot. All right, I see a lot of immersion in the chat. I guess yeah, let me pause there for a question. Uh any or or for a

[7:23] second, any questions, Zoe? Um so one question that actually just came up was, "Do we even use ticketing tools anymore or are we just doing everything in Slack?" Uh so yeah, great question. So interesting enough there, we do actually um let's see if I scroll up here. We do actually put this into linear, but this is a Yeah, that's a great question. This is another point that I think what that solved before. A lot of times people are using this more for like documentation, I think now. Now, you know, it's obviously still really important. Um, let's say two other people had recorded this issue as well. One of the things

[8:05] that this bot will do is not only triage an issue, but also deduplicate. So, you don't end up in a situation where if 20 people report this, we have 20 issues and now someone has to go in and clean them up. Like, it would add it to this issue. Um, and so we still document in it everything. You can still jump into linear and and do things from linear as well using cursor. But, um, yeah, great

[8:28] question. Um, cool. Well, yeah, I'll keep going there. Yeah, so so I guess that's kind of a good segue there from, um, well, I guess yeah, before I get into that, we get so many of these a day. So, that one took like an hour and a half of full cycle time, but even as you saw there, uh, we were able to basically, um, you know, John has basically, I

[8:54] guess there's two Johns here. Engineering John has basically designed this bot in a way where you can just ask it this. It has a whole bunch of skills and rules and things behind the scenes. And so, what we're going to do over the rest of today is, uh, we'll we'll actually recreate both of these bots in Grok Bot so you can kind of see. I think these are really good ones to start with, uh, with whatever your org and your

[9:16] engineering, uh, practice looks like. But, then I'll also kind of unpack what's happening behind the scenes because obviously, this bot is able to run the repo. It knows, uh, without a whole lot of instruction here. For example, it showed both a light mode and a dark mode version of this, um, you know, of this fix. And so, I'm sure at some point it only maybe did one and then you add to the skills, "Hey, uh, you forgot dark mode. Next time make sure you show me both." or something like that. And so, anyways, we get so many of these a day. Uh, I did just like a quick sample 74 from

[9:54] internal feedback, over 100 on X. Uh, we do listen to all that. So, feel free to continue, uh, posting there. And then, uh, many from customers as well. And so, uh, also had my GrokBot pull these numbers. Um, but yeah, the the general gist of this is that if we're getting, you know, 214 of these a day, you know, imagine that it was taking a full day to get through this cycle as opposed to an hour. Like now that's like 200 full days of cycle time as opposed to 200 hours

[10:26] and, you know, it becomes unmanageable. And so, this is how we're able to, I know someone at the beginning said it looks way better this at the beginning or end of this month even than it did a month ago. And, uh, you know, that's how we're able to do it. I'm sure you all have seen, uh, this post. If you haven't, uh, definitely go check it out from Lauren, um, talking about how she ships 200 2,000, sorry, good PR's. Uh, I think it even got higher than that after she posted this. But, um, but yeah, that's that's how that becomes possible because now, you know, once you create

[10:58] one of these bots that's able to function like this and you put the right guardrails around it, you're able to multiply yourself out many, many times. Um, and so, you can have multiple threads of these bots working on things. And like the big idea here is that when you're scaling, um, an engineering org, you just need to be able to say, one, the judgment piece. So, it'd be something like, how do we reproduce

[11:22] bugs? You know, what is done look like? Those types of things. So, those things that we've all been doing as engineers and non-engineers before, you now just have a way to package that into a sort of specialist as a skill of how to do the job, feature context, some memory, and then some guardrails, and then you can basically multi-thread that across many different channels to be able to do a lot of things

[11:49] a lot of things at once. So, yeah, so so this kind of jump, I mentioned that you know seeing this with customers, you've probably seen this curve if you've gone to any of our other sort of talks here, but this just I think kind of conceptually shows the progression of how much more productive you can be and hopefully that example I just showed shows an example of that of where even if you have AI in your IDE and you're kind of pushing some agents along, the fact that before you know, John could have been sleeping before anyone says anything, the fact that this agent is awake, ready to jump in, ready

[12:27] to take the first pass at this is what allows you to go from you know, this kind of like 2x in productivity gain to 5x to 10x and so on and so forth is because you can basically kind of automate these more complex jobs with that packaging and then you sort of go from a human driving every unit of work to a bot sort of owning this loop and you can kind of go from not only just automating a complex job, which is what in that case the team bot spot was able to do here, automated job, but now it's almost like staffing a function, staffing an

[13:05] engineer who is capable of reproducing the issues, sending you a message on Slack, asking for follow-ups if it has any follow-ups, things like that. And so, that's how you really get into these and we've seen you know, way more than this as well in terms of that. And the last thing I'll show before I get into the actual demo and start showing some stuff in the product is uh this sort of concept of the maturity curve and actually I'll pause for questions after

[13:35] this as well. So as you basically you can't just one day ship something that you trust thousands of agents to go off and like do a bunch of really sophisticated tasks on their own. There is a pop process of kind of building trust. I stole this from Lauren. I like her quote, you should be more ambitious. Cuz yeah, a lot of people are running you know five agents, 10 agents. I saw there was someone who posted in here they got a hundred running and I'm sure they're probably using some of these techniques. But yeah, the the way that it kind of and this is sort of how it like

[14:10] naturally evolves in a lot of cases is that you sort of start off being more exploratory. And so this is where Grokbot really changed the way that you can give some guidance to a bot but also give a bot a little bit of autonomy and I'll show what that means in the sense of like it having its own computer and its own browser and things its own connections, things like that. But that's kind of for maybe your first one to five agents. Then what we're seeing now pretty recently we released our team bots which allows you to basically move

[14:43] into this phase of being able to share. And so now maybe of those 10 bots that you've created, you have one that you really like that you think, "Hey yeah, this is something that the rest of the team can use." In this case for example, John being a designer could absolutely in the future call on this team bot spot and be able to you know do exactly this thread potentially without even needing a engineer in the loop depending on how well it's engineered and and what our practices are internally. And so that

[15:13] gets you from like the 10 to 20 range. And then there's one more thing that I want to show that even though you know this is very Grokbot focused talk here to some extent. The whole platform is is all layered on top of each other. So, GrokBots have access to cloud agents, um and then our cloud agents have access to, you know, other abilities. And so, we do have something called the uh the

[15:38] BDK, which is the Bot Development Kit. I'll put some docs in or maybe uh Zoe, if you could put some uh docs into the chat here. Um and so, we have the Bot Development Kit, which essentially allows you to take what you've done with these bots, and if you do get to a stage where you want to like essentially turn that into code, we have a method for you to be able to um sort of like replicate the flow of a more uh exploratory

[16:05] GrokBot, and you can bring it into code. You can get evals out of the box, things like that. And um and yeah, and and that can be uh extremely helpful as well. Okay, so let me pause there for any questions before we jump into the demo here. Uh one interesting question came in is, especially now that we're talking about GrokBots and they have this longer-lived context, what are you finding is the most effective for actually getting the bots to perform in terms of um the inputs, the different tools that they're

[16:38] using, skills, etc.? Yeah, I mean, I think the uh the fun part about this is uh especially as someone who's a you know, an engineer as well, there's a lot of engineering work still to this day. I think that the benefit of GrokBot is that like you can kind of just talk to it in plain English, and even though you're not, you know, creating a skills file that you're like committing to GitHub and things like that, because it has that memory, uh you can basically just talk to it plain English, add those guardrails around it. You'll actually see uh when I go through the example here in a little

[17:18] bit. Let me see if I can find a quick quick example of this. I want to say, was it in here? Yeah. So, yeah. So, here for example, I'm going to show you how I created the demo that I'm about to show you. And and yeah, and so here there are a couple times where it made some mistakes and I just like simply say, you know, add a skill to do this, add a skill to do that. And so, every time you kind of steer it back in the right place, the benefit of memory is that it also remembers, you know, the skills and when it needs to use them even better than

[17:51] when you just have for code for example, you have your description and they can decide to use the skills based off of that. I think this it's actually much better at knowing when to use skills and how to use them. Cool. Any other ones we should answer? Well, let me go through the UI and there'll probably be some questions around this as well. Okay. So, here is

[18:17] Rock bot. I assume many of you and also judging from the chat have seen this before, but just in case this is your first time, I'll try to do like a quick high-level overview of what we're looking at here. And so, basically you'll have your primary bot. This is something we introduced I guess everything somewhat recently. But but the ability and this bot has the ability to be really proactive and and yeah, and so it will it's kind of

[18:46] like an orchestrator, a chief of staff. Also, for those who have gone to the other sort of talks of this series, I am a very boring namer except for Jarvis who is my orchestrating bot. I tend to just name the bots whatever they actually do. Some people choose to give them really fun names and you can give them cool icons and generate stuff here. So, Uh,

[19:10] you can have fun with it as well. Uh, I'm just a little boring with it. But, uh, so we have our team bot here. And so actually, uh, I did do a little bit of setup here just so that you can kind of see what it looks like. Um, most of what I want to show is actually going to be, uh, on the along the lines of how we interact with these in Slack and being able to kind of explain the difference between those different kind of bots that I mentioned earlier. But, the first thing that your primary bot is going to ask you is just, you know,

[19:35] "Hey, I'm your personal assistant. I can help you work. Uh, what would you like to call me?" Um, and uh, and then it will, uh, yeah, basically just talk to you. I was like, "I want to connect to GitHub first." Connected here, and that was all I did with this bot. Now, something I want to point out here is that these bots are like what you're looking at here are not individual, like single conversations like you may be

[19:58] used to in other, like coding tools. These are actual sort of entities. They're long-lived. Uh, you think of them as doing a particular job. Uh, they can merge multiple PRs. They can, you know, you think of them almost like you would a co-worker. And they have their own details, their ability to set routines. So here, for example, um, if I can I could say, uh, "Every Monday at, uh, 8:00 a.m. I want you to give me a summary of last week's, um, you know,

[20:35] stuff and what I have to do this week." Um, so again, this is, uh, what someone was asking. You just talk to it in plain English. And uh, and so every morning it can go and do this. Um, as a quick side note, I I know I had mentioned this before some people joined into the room. Like I have a bunch of my This is just a demo account. Um, maybe if we have time at the end, I'll show my actual one. But actually have a, uh, a mobile app that I have a team of bots that have been running this mobile app totally autonomously for the past, um, I think

[21:06] probably like 2 months, I would say at this point. Um, and every morning I put them in a group chat and have them do a stand-up where they tell me what they worked on, what new ads they came up with, they publish the ads to Instagram, all sorts of stuff. But, uh, but yeah, the their ability to be, uh, you know, exist that way, talk to each other as well. So, in this case, for example, I have my different bots talking to each other and then they have their details, they have a library of pages and files and things that they've come up with. And then most importantly,

[21:40] I think, um, was it in this one? My computer's asleep, let me wake it up. They have a computer and so this is just a browser that's in the cloud, um, that I could take control of or they can take control of so that they can do anything. So, like, I could teach this bot how to play Wordle, for example, if I wanted

[21:59] to. Um, or I could teach it how to surf Grafana dashboards, which is what we are going to do for this demo. Um, so before I get into that, I just want to see are there any questions about the UI, um, yeah, UI or anything that I showed here? Nothing on the UI. I'd say go go for it

[22:20] with Grafana. Okay, so what I'm going to actually show here, um, and actually even better. So, this presentation that I've been showing you so far, um, is in Figma. So, uh, all these slides that we've been showing or I've been showing so far are here. Basically, what I did was I took this bot and, uh, the presentation bot, um, I connected it to Figma. So, I went to connect apps and so this is where you can either connect to, um, some of the skills that some of your teammates have created. Um, I could connect to Jira, I could connect to Grafana, I could connect to, uh, Notion, Slack,

[23:03] Teams, Outlook, whatever your tools are, you can connect these bots to those tools so that if I do ask it to give me a summary every day, it's able to go and do that. And so now for this demo, what I wanted to show was um here's another thing actually by the way, a nice feature um that will happen automatically for some requests, but you can also ask it more specifically um I wanted it to show a diagram of what the Grafana repos look like. And if you're not familiar with Grafana, it's like an

[23:35] open-source charting library. Um the reason I chose this one is one, I used to work there. Uh a lot of good good friends there. And um because I think this is a good example of one of the most common use cases that I see early on for both um Grokbot and also for uh the BDK bots, which what like I said, we'll get into a little later. Um Grafana has many repos. They have uh metrics, they have logs, they have traces, and each one of those UIs is in its own separate repos. And then each one of the databases behind those UIs is in yet another repo. Um and so this uh

[24:14] let's say uh you know, you're running all of these and you're running all these open-source, an issue could land in any of these. Or for their case, if they have an alert that comes in, they may need to route that alert to the right team or uh route a PR to the team. And so even a lot of people who have sort of moved up that trust curve of being of wanting to trust AI more, they're like, "Okay, well, I trust my AI within the context of its individual repo, but when you're going to like scale this to an entire org, it's like we have 800 repos. How does my AI know,

[24:51] you know, I give it a request in Slack or Teams, how does it know where to route that, whatever?" And so this is one of the the really common ones that we run into. And so, what I did here was I created a new bot. Uh I just came up here, created a new bot, called it routing bot uh because it does routing of things. And so, uh first thing I did was I actually asked it to talk to the presentation bot, get a full list of repos that are part of this demo, and your job. And uh and so, yeah. So, here if I wanted to give this the job of

[25:24] routing a ticket, uh you know, here it's actually going off. It's talking to the presentation bot. It's figuring out uh what repos are the search space. And we'll actually come back to this one a little bit later, but you can kind of see here that it's it's already determining what all of those repos are. And in kind of a meta sense here, um it knows that because I gave it this presentation, and these slides and details about this repo are in this presentation. Um now, for the other bot, uh we'll come back to the uh routing one later cuz I think that's something that uh can be a little bit more

[26:01] deterministic, and so I'll show how you do something more deterministic with that one. For this one, this is something that is a little bit more uh like fluffy or unclear. And this is the reprodu our repro, not repo, but repro bot. And so, what I did here was I created a bot, and I wanted this bot to

[26:22] just be good at reproducing an issue. And so, uh created the bot, it asked me, "What you want me to do?" I went ahead and published this as a team bot. We'll come back to that later. Um but first, I just wanted to see out of the box, given no details whatsoever, um can you reproduce this issue? And so, here it goes. It looks up the issue. I said, "Let's connect to GitHub." Um apparently, there was um I was already connected to GitHub, but it was unavailable for some reason. And so, interestingly, because this has its own computer, it was able to go out to that

[26:57] computer and say, you know, "Hey, I want to go reproduce First of all, I want to go find this issue, and then I want to reproduce it." And so, here, funny enough, Grafana hosts a sort of just like play version of their website. And so, it tried to reproduce the issue on their play version of the website. So, I had to steer it. I was like, "No, do everything locally." And added a skill that in the

[27:20] future you should do everything locally. And so, this goes to answer someone's question earlier about how do you, you start to put guardrails on it? There's no way that it could have known to start locally. But now, in the future, everything I do, it's not going to try to go to this public website, it's going to run it locally. So, then it starts

[27:38] doing that. Um and so, now, here's another concept that I um we don't have time to get like too deep into. Um but, it then started to run it locally. And because it has its own computer, it actually tried to, you know, download all the packages, use my uh GitHub uh credentials that I connected earlier to actually build this locally. Um but, something that we do have is uh this concept of a cloud agent environment. And so, this is um you know, obviously still exists today, but uh this is through Cursor itself. And so, basically what that is is we create uh for your repo so that every time you

[28:19] want to like spin up a task so that you don't have to spin it up from scratch, downloading dependencies, and um uh environment variables, secrets, uh MCP connections, all those things so you don't have to do them in real time. Uh we basically create these cloud agent environments. So, this already had a cloud agent environment that it existed in. So, I added another skill to tell it to use that. And then, uh uh, you know, fast forward through, um and it was able to work its way through, finally uh, reproducing the issue. And this is an

[28:53] actual issue from the, uh, Grafana repo. Uh, they fixed it super fast, but, um, this was an actual issue that I showed, um, let me see if I can find it. Uh, while I do that, yeah, here we go. Um, so this was an actual issue, like I said, Sonoplus first repo, you can go look at it. Um, but yeah, the the issue itself was that, uh, these little ellipses make it hard to actually read the names, and, um, yeah. And so basically this was able to then go in, reproduce that issue inside of Grokbot. And so here you have it, and you can see it has the three dots, and,

[29:38] um, and yeah. And so, uh, this starts off at on that like, uh, explore part of the curve that I was showing earlier. Um, so here, where you're kind of just exploring, and so if you wanted to reproduce something for you locally, for one of your repos, uh, that's totally fine. But now if you want to, you know, expand this to all of your repos, uh, what I did to do that was, uh, for my single bot, I hit the share button up here, hit share with your team, and now this kind of upgrades this bot, now that I've put a couple guardrails on it, from a personal bot to

[30:14] a bot that anybody at my team who goes into, um, who goes into here can see a bunch of bots, and I can actually see a bunch of other bots that my team has created as well, if my other teammates have created bots. And now everybody has access to this ability to reproduce issues, uh, inside of, uh, these eight

[30:34] repos. All right, let me pause there for questions before we get into the Codify section. This question I saw a little bit earlier, but someone was asking, how do we decide when we want to build a bot via Grokbot or use something like BDK? Great question. So, uh yeah, actually honestly that's a great transition into our next session. So, so basically with this, I was able to when when you're using this kind of like a more ex- when you're in this more exploratory phase. So, in this case, it was kind of straightforward to reproduce that issue. I'm actually working on an issue in our like main Grokbot repo

[31:21] right now, where uh you know, basically fixing something where if you have like a really complicated VPN setup, um making it more hardy that Grokbot is able to work like the app itself is able to work on more complicated VPN setups. And to do that, uh reproducing this issue that I just showed you is pretty straightforward,

[31:43] you know, just run the repo and show it. To reproduce that, it needs to use that virtual machine that it has. Um again, it has its own computer here. It needs to find some kind of way to replicate all kinds of really complicated, sophisticated VPN network setups in order to properly test, right? And so, in that case, um giving the bot a little bit of leeway to spin up and and again, these are sandboxed into their own like virtual environment, so um and you can add all sorts of controls for like the blast radius there. But um yeah, uh we have all the controls in place that it's

[32:21] totally fine. And so, then it's able to figure out, you know, what packages it may need to download to mimic a certain kind of VPN or something like that. And so, in that case, it makes sense to use Grokbot. Um and then obviously, when you when uh you share it, it's kind of the same thing. It's just everybody has

[32:38] access to whatever that is. When you kind of want to go a little bit further and use the BDK is when you want these different pieces. So, the So, again, just to to zoom out for a second, the BDK actually in this example that I was showing before, this is actually two kinds of bots. Sandy is more of a is the triage agent, which is why I I saved the routing for later because that is a good BDK task, whereas this team bot spot is created by Grokbot. And again, it's because this one there's like new things emerging all the time that with this feature and so

[33:19] this bot has a little bit more flexibility. This bot is very very rigid in what it does because we have this bot answer every single one of the of the things that come in. You'll see that bot is the first line of defense to actually answer what happened. So, in that case, we need a little bit of determinism. We need it to be somewhat verifiable. So, being able to use some sort of eval. So, if you're running this at massive scale, we can start to figure out like is there what is the best model to run this on or things like that. And so, like I said,

[33:55] I'll get into what the BDK looks the code version of this looks like. So, yeah, if you want predictable costs, if you need them to be long-lived, they both share this. But then, you can develop the BDK locally in code. And so, for example, for something that requires routing, right? You can with the BDK, you can set up a set of evals that decide when I want to route a thing, is it always going to route to the proper place? And so, I'm going to show both of these side by side here. So, So, is another um uh, just like a, uh, dummy Slack repo. And so, here, that team bot that I

[34:37] created earlier, um, sorry, jumping around here. So, that team bot I created earlier, I can go here and, uh, I can just tell this team bot to go message in a Slack channel, and because this team bot has been added to Slack, um, it's able to come in here and say, "I reproduce this issue." It comments here, um, and so, you can see

[34:58] the reproduction in Slack. Now, the BDK version of this ex- So, basically, I cloned this exact same thing, but I did the BDK version over here, and so, you can still see that this is reproduced, but this version, this bot itself lives in code. And what that code looks like is, you can almost think of it like, uh, Ruby on Rails, um, except this is like your, your bots on

[35:26] Rails. Um, and so, here, you come with this out of out of the box as like all these different kind of primitives, this concept of tools, skills, MCP connections, host connections, sub agents, channels, hooks. Um, and so, here, you can basically scope all of these different things to this particular bot, um, and have evals that come out of the box for it. And so, basically, this will allow you to make sure that, um, you know, whatever skills that you add to this bot are directly

[35:57] scoped here. Any, uh, hopefully that answers your question. I know it's kind of a long-winded answer, but yeah, but basically, when you need pure kind of determinism, or if you want to do some sort of evals and things like that, that's where you would, uh, leverage the BDK over a Grok bot, because even for this, um, uh, if I, yeah, even for this, um, it's able, there's two things happening here. So, a request came in that says service names cut off all services

[36:32] is Pyrsoscope dropping part of the name. And so, the first bot is able to come in here, classify this as a bug or not, and then you can see here that it's actually telling you what percentage it gave on this routing decision. And so, here it's like I think there's a 73% chance that this belongs in this repo, there's a 27% Sorry, 27% chance it belongs in this repo, and then 00000. And so, this is a good example of the kind of thing that even though I have my like reproduction bot over here, um this one is going to be much better if I want to be able to like debug in a more,

[37:14] let's say like an incident scenario or something, why it routed something a certain way. And if I want to fix this for the future, now I can go into this is actually um that repo in code. I could actually like go into the instructions here for example, um or this bot itself, and I can actually write some code that helps steer it more properly, deploy a new version of this bot, and all of this ends up inside of a like dashboard where you get um you know, logs and metrics and traces and observability around these agents and why they made the

[37:53] decisions that they made. And so, in this case for example, if I go to evals and I go to Let's see. routing evals Let's see, router cases. So, yeah, so in this case for example, I could go through and this is actually what I did. I had Rockbot go through all of those um Yeah, all those different repos and basically take a uh issue name from one of those repositories and then it knows what repository that came from and then I created an eval suite that makes sure that with the given system prompt that this bot is able to correctly route um and you can make it 10, you can make it 100, you can

[38:42] make it 1,000 of the issues that were in that that repo and uh and you can then use that to do this. And also what you'll notice here that these are actually two BDK bots that are again in the same thread talking to each other. One is focused on routing, one is for focused on reproducing. And so this is how you can then kind of start to chain these agents together in a way where you have one um yeah, you have one that's focused on routing and then you have one that's focused on reproducing and then maybe you even get even more specific like uh in this example where you have one

[39:19] that's specific for reproducing uh issues for a very specific repository. Um depending on what your organization is like, you may have different needs for like an iOS app for example rather than a back-end application. And so you can start to really scope these down and and optimize them at different levels. All right, let me pause there. BDK, any

[39:46] questions here?

[39:52] Let's see um where is the dashboard? Let me see. Because this is a demo instance, I just want to make sure I'm not going to show uh let's see, dashboard. Deployed agents. Um yes, this shouldn't have a yeah, this should be good. Um so yeah, so once you do So basically, uh, you can run these locally. So yeah, this is also what it looks like, um, inside my terminal. So, for example, for this,

[40:26] uh, repository, I can say npm run eval. It's going to run a whole host of evals, and it's going to look basically like a test suite where it figures out, you know, where did these all, uh, get routed to. And so, in this case, you can actually see 48 out of 50 passed. And so, it looks like maybe there's a couple that I may need to, uh, to fix here. Um, but that's an example of what it looks like. And so, when you're done, you would just I I forget the exact command, but it's going to be, you know, like BDK deploy, um, and then you would say like whatever

[40:55] the, you know, bot whatever the bot name is. And once you deploy it, it's going to show up here inside of your, uh, your cursor window. It's going to show up under deployed agents. And so, then, um, let's see. If you click into this, you'll be able to see how many sessions did it have, what MCP connectors did it have, whatever logs it had, um, who deployed this last. So, here's the current deployment, um, by Anina. Um, let's say some other person made a change to this code and redeployed, or you have it as part of your CICD pipeline, you'd be able to see all of

[41:30] that here. Um, and so then, after you see it, you can actually even see one of these sessions. Um, I don't know if any of these are actually like real data happening. Um, but if it is, you'll be able to even see, for example, Oh, yeah, maybe we get lucky here. Yeah, so then you'll see something like this, which is

[41:49] a trace of this particular agent run. Um, the user started it, it was thinking here, the assistant helped, it had these tool calls, etc. And you can even see the chat that this agent So, underneath this BDK, at the root of it is our cloud agents and our I mean, I guess technically the cursor SDK, but, uh, but yeah, but basically like our cloud agents and there are um you know, sort of the inference and all that eventually gets buried under these various layers of abstraction to the point where you can come in here and you can say uh right now this is just uh watch only, but you can if you're

[42:28] running this locally for example, you could talk with this agent and be like, you know, how would you improve yourself in the future or something like that. Um and you can see the the raw data here as well. Great question. Uh anything else on that? Yeah, here is uh actually just yeah, taking it back to here. I think this is actually a really good um uh people who I've shown this to, I think this really helps kind of depict why it's like it's it's pretty nuanced, the value that the BDK has cuz like you can do all of this with raw APIs for example. Like you can use just

[43:13] like the Grok API or Claude or whoever and you could theoretically chain all of these things together. Um but it becomes a lot more plumbing that you have to put together on your side. So in this case for example, if you wanted to set up this kind of pipeline that is going to enrich a Jira ticket and then it's going to figure out who the owners are, then it's going to open a PR and then it's going to post that CI to Jira. Um even if you were just using the the plain like cursor automations, you would have to, you know, set an output of one to be the

[43:48] input to the other and then the output of the other to be the input to the next one. If you wanted a human to be involved in the loop, like you kind of just have to uh implicitly put that in, whereas with the BDK, you can explicitly say just like, you know, bot, you're alive as an entity, just wait here for a day, a week, however long it takes for someone to confirm, and then you can proceed

[44:14] forward with like the next steps. Um but yeah, you would have to do all of these, you would have to manage all of your secrets, you would have to um manage all the credentials, all those kinds of things. And with BDK, um yeah, you can just deploy this straight to Slack and and just basically um I think it's even another command and like, you know, BDK like Slack add, and it just adds this bot to your Slack

[44:39] instance or Teams instance or whatever. Um and so, this is the ability to like really define a full workflow, and and that's where if we go back to this, it's kind of like, you know, if you uh chain them all together, you can kind of get to that like 5x stage, but once you are leveraging the BDK, uh leveraging Grok bots, having the different BDK agents talking to each other and working together, that's where you start to get into this uh kind of like staff of function phase, where you're able to do multiple things um

[45:15] concurrently.

[45:21] All right, let me pause there. I know we're starting to get close on time here, almost wrapping up. But yeah, any questions? Let's see. There was a couple of questions earlier um asking a bit about persistent memory in in Grok bot and how we're thinking about that as well. Mhm. Yeah, so uh the details are uh very Yeah, I don't know how deep it's worth to get into today, but um basically, we've done a lot of things behind the scenes to make it so that these bots have like some sort of memory management

[46:05] system that they're able to use. I personally have not run into any issues and like I said, I use these bots plenty and I haven't run into any issues there of being able to yeah, like context and dealing with context management and things like that. Yeah, I think that's one of the the benefits of using a tool like Grokbot is that it's sort of already built in. So, we don't spend much time thinking about it because the bot is maintaining its own memories and skills to recall what we've previously worked on and how to do the tasks efficiently and

[46:42] effectively. Mhm.

[46:49] Cool. All right. Well, let me going to kind of get close to the end here, but yeah, just to kind of like recap there. So, typically the way that our that you sort of move along this curve is at the very least starting off with being a little bit exploratory, trying out Grokbot, trying it locally, getting it to do the thing that you want it to do. And then, once it's doing something valuable for you that you assume is something that the rest of your team can use, you sort

[47:20] of like expand this out into a team bot. And then from there, it's sort of like up to you if that's plenty, which we have plenty who sort of stay in that like team bot phase and we can we've put enough guardrails on them that they can operate even hundreds and thousands of those team bots. You also have the option for particular kinds of tasks of making those a little bit more deterministic, turning those into code, and being able to add verification and

[47:51] and versioning and things like that. Cool. So, last thing I wanted to show and then we'll we'll leave it for a couple more questions is these are some of the wins that we've heard from various areas. I showed kind of how you can take a big report, figure out how you can route it to the right place, leverage team bots, cloud agents to be able to actually put that agent into work, rebuilding things, rerouting things, showing you what it looks like, and then if you want to being able to use the BDK for other tasks that are more deterministic and

[48:32] eval. We've seen this across many different industries. And so, even engineering can look many different ways from you know recruiter to travel tech to telecom and we've seen a lot of really really I also had my grok bot kind of sift through a bunch of our notes and and anonymize some of these and show some of the cool wins that we've had in being able to take a lot of these kind of handoffs that I was talking about at the beginning that used to be sort of that linear flow and leveraging the power of these team bots and combination of their ability to spawn up these cloud

[49:11] agents and write code to be able to do much more kind of sophisticated things. And so, here are some other sort of cool stats as people being able to streamline their process, save a bunch of time, save a bunch of money, and mostly just kind of make life much easier. So, um yeah, I would say try this out Monday, Friday. I guess tomorrow's

[49:38] Friday. But Friday or Monday, try out just kind of exploring grok bots, seeing what you can do, and seeing if there's anything that you do regularly that the whole team may need and try to turn that into a grok Bot, see if you can get your teammates to use it, work on it, help you iterate on it. And I think usually once we see people kind of get into this phase, whether that's a bot that then delegates to writing some code, or if it's a bot that's not, um what we typically see is that's where you really start to capture a lot of that value that I mentioned

[50:11] earlier in being able to like streamline systems, make people's lives much easier. Um and uh it's always fun when you when you build a really good team bot and you get to see everybody using it. Um yeah, it's just a a really nice kind of cycle there. And then uh yeah, if you want to codify it, then you can turn it into a BDK agent. But that is all I have

[50:33] for you today. Uh we can leave the rest of the time for questions. Awesome. Thanks so much, Ryan. Um another theme of questions that was coming through was sort of any tips or guidance you have around thinking about guardrails or security for Grok Bot? You know, that's top of mind for a lot of enterprise customers as well. Yes, great question. Um let me pull up what that looks like. So, yeah, there are This is one of the things that we are also, just like as a org, one of the things that we're definitely focused on

[51:07] is continuing to improve this. Um but if you actually open uh on your settings here, you'll see a little Grok Bot tab. And with that, there's all kinds of settings that you can do. Um the ability to execute things on the local computer, the ability to share templates. Um there are a ton of egress routing and egress controls. Um there are a ton of

[51:33] uh controls that you can put on these. Uh maybe you start with an allow list and then you slowly expand that or start with an allow list of which uh MCPs you want them to be able to use, things like that. But there are a lot that you can control here. Yeah, I can we can send some docs in the chat, but basically I would just recommend kind of going through here or having a Grok bot help you go through here and and figure out what sort of matches the security posture of whatever

[52:03] your org looks like. Nice. Um and then this is a nice one. What would be a an easy first entry point for using the BDK? Yeah, those links in the chat I think that my very first thing with the with the BDK was to basically um Yeah, my very first thing was just to create like a PR review agent. I hesitate to say it because we also do have Bug Bot as well that is I would say generally better than most PR agents our PR review agents I should say, but but yeah, I think that's a really good one mostly cuz it's like a really defined task and you're able to

[52:49] Yeah, it's a really defined task and it's pretty straightforward to kind of see how all of those concepts map to series BDK. Oops slash docs slash BDK. Let's try that one. You can kind of see how the concepts map to these to these various pieces. Again, I think this gets much more advanced. I would recommend you know, starting with team bots and seeing how

[53:16] far team team bots can get you. I would say maybe 90% of our bots are team bots and then you know, we occasionally do BDK bots, but obviously we're trialing our own dog food a lot. Absolutely. As well as I believe I shared the docs for BDK already, but there should be some guides and templates online as well. So, that will walk you through how

[53:44] to to do everything. Um and then, I know we're coming close to the end of time. So, maybe we'll end with a fun question I saw come in. Um what is maybe the most creative uh use case you've seen with Grok Bot Ryan? I think someone was asking what is a use case where you think of

[54:02] using like hundreds of bots? Yeah, most creative use of Grok Bot. I'll have to think about this one, too. Yeah, I I don't know. I mean, I think that there's I don't know the most creative ones I've seen. I've seen some that can because they have their own machine, you can even like technically

[54:21] install Grok Bot on Grok Bot's machine. It's like Inception. I don't know what they actually uh you know, needed that for, but I thought that was a pretty interesting one. Um I did tease it a little bit earlier. So, I will show really quickly um my bots in their uh let's see. Um in their morning stand-up. Um and so, yeah, this is like like I said, this is a mobile game that I've created called Rankum. Um every morning I have them do this uh at 3:56 before So, it's before I get up. And you can actually see here uh you know, they're spending money. They're spinning up ads

[54:59] on Instagram. Uh they're running. There's an analytics agent, a bug fixer agent, a tester, a retention engineer, and all of these work together to basically be able to create this game. And um I think I'm up to like, I don't know, something like 10,000 downloads. Um and so, there's a good example in here of it creating ads for Instagram. Um and so, yeah, this is like it. I didn't do any of this. It figured out how to use Remotion. It figured out obviously asked me to upload my, you know, information to Facebook and stuff. Um but it's able to do all of this on the own because I set up this loop of like

[55:40] hey listen here's how much my cost per install is I want you to figure out how to get that down to less and they just you give them the goal you give them the feedback loop and they kind of figure it out. Awesome. You heard it here first folks. Go download Rank up and and see how

[55:56] Brian bots are doing. Yeah. Any any issues you report to the App Store I have a bot that automatically you know spins up a PR for them too. Nice. What about you? Any any creative ones you've seen in our last minute here? Yeah. I mean not as creative as that your system. I think one of the things I'm thinking a

[56:18] lot about is the feedback loops. So I have bots that do everything from help me like review the work I'm doing. Um even things like reviewing some of the calls I'm in and then giving me feedback so I can improve in the future. So I'm thinking a lot about like how to use Rock bot to help me be better at what I

[56:38] do everyday. Nice. But a lot simpler than a full app development team. For now. For [laughter] now. Yeah. But yeah awesome. Well thank you for for listening and and participating. A lot of good questions in the chat. Yeah. Let us know reach out to us comment on X whatever it is and we're happy to help you through

[57:05] your Grok bot journey. Absolutely. Thanks everyone. All right. Bye.

---

About this transcript
Read from YouTube's own caption track and laid out by ViewRank AI (https://viewrankai.com).
ViewRank AI finds the videos already beating a creator's own average on Instagram, TikTok and YouTube Shorts, transcribes them from the audio itself in more than 60 languages, and turns what worked into new ideas and scripts.
Free transcript tools, no account needed: https://viewrankai.com/tools
How to read any video this way: https://viewrankai.com/llms.txt