Today we're excited to launch Langsmith

Agent Builder. Langmith Agent Builder is

a completely new type of noode agent

experience. You build and describe your

agent in natural language incorporating

memory so it adapts and learns over time

alongside you. There's no drag and drop.

There's no visual workflow complexity.

It's all just natural language. It's

dead simple, easy for anyone to pick up.

The hardest part about building an agent

in Langmith Agent Builder is writing the

prompt. needs to be pretty detailed. And

so we've added a bunch of tools in

Langmith Agent Builder to make it easy

to do so. We've added metarrompting

which takes in your initial idea and

then asked you follow-up questions and

expands upon that to create an initial

detailed prompt. But prompting isn't

static and it evolves over time as you

use your agent and work with it to

overcome challenges. And that's where

the idea of memory comes in. Your agent

needs to remember those interactions

it's had with you and it should update

its prompts and instructions in memory

bank over time. And that's exactly what

happens in Linksmith agent builder.

Let's see all of this in action. I'm

going to go over here and I'm going to

create a new agent. Now, I could create

it manually or I could use this agent

builder to help me create it. Let's use

the agent builder.

I want to create a daily briefer,

something that knows what's going to

happen in my day and then send me a

report about it at the start of the day.

So, we can see here that this agent will

look for the tools and triggers that it

has and then read more about them. That

way, it can tell me what I can and can't

do. So, if I ask for something that's

impossible with the given tools and

connections that it has, it will just

tell me that rather than leading me down

a false path. Here, you can see that it

asks a few follow-ups about what I want

to achieve. This is really useful

because my initial description was

actually not that specific. So, this

will help narrow in and help the agent

builder create a better agent. So, let

me respond to them right now.

I want it to read my calendar.

I would like to receive it via Slack

and it should be delivered at like let's

say 6 a.m. each morning. Now, the agent

takes these answers and thinks about

whether it needs any more info and it

does. So, it needs to know my Slack

email or user ID so that I can send the

direct message. I'm not going to use my

real email for this. Let's say fooling

langchain.com

and let's submit the answer.

Now, it's going to think whether it

needs any more info and it doesn't. So,

now it's going to start building the

agent. Now, we can see here that the

agent has been successfully generated.

Before creating it, it wants me to

connect to Google and Slack.

This is important. These agents often

require connecting to internal tools or

APIs and we want to give them the proper

O and credentials to do so. And that is

exactly what this is going to do. So I'm

going to go do that and then come back

here. We can see here that after I offed

I can now go ahead and create the agent.

All right. So this is just what the

agent is. It's these instructions and

then it's the trigger. The trigger is

what kicks off the agent. So I can see

here that it's getting kicked off at 6

am every day and then the tools that it

has access to. I also have over here a

little test chat. So this is useful

because I can basically run it in a

debug mode where it pauses before it

executes tools. This is helpful when I'm

trying to just get a sense of whether

the agent is doing what I expected to

do. So let's keep that on and let's try

it out. Let's say go and watch it kick

off a daily brief. We can see that it's

checking my Google calendar. Great.

Let's continue.

and now wants to send me a Slack DM with

a private message. Let's take a look at

the contents of this message.

Now, this is where memory comes in. So,

let's imagine that as I'm watching this

agent about to send this message, I

actually want it to do something

different. I can just tell it in natural

language in the chat. So, let's say

something like it should always write a

poem.

We can see here that it now wants to

read a file. What is this file?

It's actually the memories of the agent.

So this file here corresponds to the

instructions that you see over here. And

this is how memory in this agent works.

So I'm going to let it continue and I'll

see that it will actually try to update

the file. There we go. It's calling

update or it's calling edit. If we go

in, we can see the new string and the

old string. And in the new string, it

says, "Always close the briefing with a

short uplifting boom." So, let's

continue.

And now it's writing a new Slack

message. And if we look at the Slack

message, it should contain a poem.

There we go. We can also verify this by

just refreshing this page.

When we do that, if we look at the

instructions here,

we can see here that there are the

instructions about ending the briefing

with a short uplifting poem. So, this is

how memory comes into the agent and is

useful for updating the agent as you

interact with it because it's unlikely

that you're going to create it perfectly

the first time around and it's going to

want to learn from its interactions with

you. Now, this is just a test chat and

so to actually use the agent, I can

click here and I'm brought to this panel

where I interact with the agent. Not

only can I interact with it in a given

conversation, but I can also take a look

at all the threads that it has access

to. Now, because I just created this

agent, there aren't any threads. But

let's go to an agent that I had already

created. Now, this is a different daily

briefer that I had already created a few

days ago. I can see here that I have a

list of threads.

Some of these threads require my

attention. So, if I look at the

different thread types, I can see that

there's idle, which means that the agent

has already run. There's busy, which

means the agent is currently running.

There's interrupted, which means the

agent has stopped and needs my attention

or needs my help with something. And

then there's threads that have errored.

So required attentions are ones that are

interrupted. If I look at this, I can

see that it's notified me that I

actually need to off with my Google

calendar. I actually didn't do that for

this agent, and so it got stuck. And so

rather than just fail, it actually used

this built-in tool called notify user to

basically put this thread and say, "Hey,

I need help."

So this is an example of what we call

the agent inbox. And this is where you

can monitor your agent as it's working.

It can reach out to you. It can help

with stuff. And then as you interact

with it here, it still has memory

enabled. So it will learn over time as

well.

That's an overview of our no code agent

builder. As mentioned before, this is

not a visual workflow builder. It is an

actual agent builder. It leans into the

autonomy of these agents, provides them

with memory as well, so they can update

through their interactions with you.

This is available in private beta today.

So, if you don't see it enabled, just

sign up for the wait list and we'll let

people off of it accordingly. Thanks for

watching.