Loading video player...
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.
LangSmith Agent Builder (now in private preview) lets anyone create agents through a text-to-agent experience — no coding or prompt engineering required. Just describe what you want in plain language. The system asks follow-up questions, auto-generates your agent's prompt, connects tools via MCP, and sets up triggers for emails, Slack messages, or schedules. LangSmith Agent Builder is built on our deepagents package with planning capabilities, persistent memory, and multi-step task handling. Its built-in memory learns from corrections. You can also securely connect to tools like Gmail, Slack, and Linear within the agent building flow. Learn more about the private preview: https://bit.ly/42XWDjC Get started with LangSmith: https://bit.ly/47MHgwX