Today I want to talk about templates in

Rockbot. Templates allow you to share

your bots with others and use bots that

others have created in your own app. So,

quick facts about templates. First,

creating a template creates a blueprint

for another user to create a copy of

your bot. That means they're not getting

an exact one-to-one clone of your bot,

which is important because it means

sensitive information and things like

custom code or custom scripts, custom

MCP servers are not included. Now, we do

include first-party plugins and

connectors that are available in

Rockbot, but we'll talk more about that

later and we'll talk more about exactly

what that means. So, when you create a

template, you are creating a copy of the

instructions, a copy of the relevant

memories and skills that your bot has,

and a copy of the plugins. So, I'm going

to walk through exactly how they work.

Let's jump into it. To get started, I

have my Loop bot here. In my Loop bot, I

used to write software at SpaceX.

Um and if I come into the settings here,

what you'll notice is is that there's a

a share as template button in the bottom

right. If I click that button,

what the bot's going to do is package

itself up and make itself available for

you to share with other people by giving

you a link. Now, when you click this

button, nothing's going to go live. So,

don't worry clicking the share as

template button is going to make your

bot public. That's not going to happen.

And moreover, templates are an

anonymized private version of the bot

that you're sharing. You can think about

them like a recipe rather than sharing a

meal. Now, let me explain what I mean by

that. If you're sharing a recipe with

someone, that person then goes and

recreates the meal in their own kitchen.

So, if I give you a recipe, you're going

to create your own version of that meal.

And that version might look a little

different than exactly what I created

when I had the recipe in mind. And the

reason for that is the bot is actually

packaging up a copy of itself that has

all the plugins, the instructions, and

the memories that you created with the

bot. That's explicitly different from

sharing a meal. Now, if I invited you

over to my house to have a meal, I have

a nice little apartment here.

Um we'd be creating the same meal

together. We'd each be interacting with

the same food and the same ingredients.

That's more like an isolated copy of a

bot and that is not what a template is.

So, when I click

share as template, you're going to get

essentially a blueprint for creating

your own bot. We'll talk about the

specifics of what that means later, but

for now, I'll show you what it means to

take that template and install it into

your own environment. So, let's look at

this template as an example.

So, when I created a template for my

loop spot, it read through memories, it

read through skills and routines and

plugins. So, routines are just the

triggers that you might have for a bot,

how often it runs on its own. Um and

then it decided what to keep. So, it

kept memories and plugins and it left

out personal or internal memories. So,

by default, the bot is going to exclude

things that are personal or specific to

you that might not be applicable to a

template. So, it's really on the bot to

create that template. And now we have

our unpublished template. If we click

view details, you can see actually

exactly what's included. So, there's

some context and memories

and some integrations. So, I use

Pystack, shout out Lauren, and GitHub

for this bot. Um now, this bot is also

tightly coupled with the cursor

integration. Um so, what you might

notice when you're creating templates is

that there are other instructions that

you need to give. I'll give you some

tips on that in a second.

This template is not live. We can choose

to make it live for the public or for

our team only. Now, since this bot is

very specific to coding at SpaceX, if I

wanted to share it internally, I might

select team only.

Clicking publish is going to make that

template live and you're going to get a

link. So, you can see there I clicked

publish, I got a link. From there, we

can click copy link and opening that

link is going to take us to this

template page where we can add that to

Grokbot. So, now we're going to flip to

the other side. Say you're a person and

you want to install a template. What

does that look like? Well, if we click

add to Grokbot, we're going to open that

link in our bot. And nothing is going to

happen. We're going to be able to review

that template. So, now I see the

context, I see the integrations that

that bot includes. I can check to make

sure this is what I'd expect, and I can

click add to bot.

And now,

this is distinctly a new copy of my Loop

Bot because it doesn't have the same

um icons or anything like that. I am

going to watch the bot basically install

itself. So, I hand you the blueprint,

you're going to take that blueprint and

install it into your bot. So,

what we're doing now is the bot is

taking that recipe we talked about

earlier and making its own version of

the meal, which means that one, it might

be slightly different from what you

received, and two, there might actually

be some setup that I have to do to make

this work exactly as I want it. So,

those are the things to keep in mind.

Bot templates um are independent

versions of the original bot, and there

might be some setup. If there are

plugins that were included in the

original bot, your new bot here, the bot

you created when you're using this

template, is going to have to reinstall

those plugins, but it comes with them.

If there are non-standard plugins like

MCP servers

um or other scripts or code, those also

aren't included in the template bot. So,

you're going to have to be sure to reuse

those or ensure there's a way to carry

that code over to the bot. So, you can

see that this template kind of unpacked

itself and configured itself. Sometimes,

for more complex templates, what I like

to do, the same way I would configure

maybe a coding project or something like

that, is effectively have the bot encode

instructions for setup. So, if we go

back to the original um bot that I

created here, I might say something

like, "Make sure to include all

instructions for setup and configuration

in the template. Think through exactly

what a user would need to replicate my

flow." And if I send that, what you'll

notice is that the bot might like

reflect and improve on the template.

This is especially important for

templates and bots that need API keys or

MCP servers or highly custom. So, if

you're building really complex

workflows, it might be worth thinking

through how you can ask your bot to make

setup for the end user as easy as

possible. So, that's just a small tip.

In practice, you don't need to do this

and you can kind of rely on our share

and copy templates flow. So, those are

templates in Grok Bot. Things you need

to know: Templates are more like a

recipe than a meal. So, think about them

as a blueprint for your bot to then go

create its own version that doesn't

carry over personal information.

Templates do include first-party

plugins,

skills, and other things that the bot

deems important to its workflow. They do

not include secrets. They do not include

any sort of personal or private skills

or private information. And they can be

shared publicly or with just your team.

Um templates are installable via a

single link and they're super easy to

get started. You're going to see a ton

of them online and the only thing I

would say is that evaluate templates

just like you would evaluate skills or

software. Be very careful about what

you're installing in your bot and it's

probably a good idea to view the details

and just read through the context, read

through the integrations, and make sure

everything in the template is exactly

what you'd expect before installing it.

I'm Matt with SpaceX and these are

templates in Grok Bot. Until next time.

Peace.