0:01[music] All right, all right, all right.
0:14Remember the way we started? Who was here in the morning? A little bit of energy. Yeah. All right. We're going to give a lot of energy to Harrison. How many of you have used a personal agent of some kind?
0:27Muse, Instate, and OpenAI Thought.
0:30We got one agent and it's running all of these sub agents for you running all these tasks at the same time. The question is how does this work? What happens when you scale from one agent to thousands, to tens of thousands?
0:45Harrison is going to walk us through exactly this. And, I've mentioned this briefly before, pretty sure he's the biggest Taylor Swift fan in the building.
0:54Anyone else a Taylor Swift fan?
0:57No one else is a Taylor Swift fan? Okay, Harrison is the biggest one. Bring it on, guys. Please give it up for the CEO of LangChain, Harrison Chase.
1:07[applause] [music] Thank you for that. I'm excited to be here. Uh, my name my name is Harrison Chase. I'm the co-founder and CEO of LangChain. And today I want to talk about something that's top of mind for us as we think about the the future of agents and and and where these things are going.
1:31I think there's been like a few step function changes in how agents work over the past four years. I think they started off as pretty simple kind of like text generation machines and then and then we added in tool calling and then we added in reasoning and and maybe a year, a year and a half ago was when I'd say like really powerful coding agents first started to work. And I'd say like around six, four months ago is when we started to see some of these proactive, goal-oriented,
2:01agents starting to take off. Muse and Instinct that's mentioned are are two kind of like popular examples of these. But we see a lot of uh B2B and some B2C agents also kind of like taking on a lot of these characteristics. So I want to talk about what we're seeing in terms of how people are building these and some of the challenges that they're facing.
2:23So in order to kind of like set the the stage of what these do, I think there's been a shift from agents that are just doing tasks like research this account to agents that you're now giving a responsibility. So like keep me on top of the important accounts that I have.
2:39And we're seeing this shift take place in in terms of agents that we run at LangChain. So these are three real different categories of agents that are that are some of the most used at LangChain inside our company. Um we have a go-to-market agent um and uh this moved from our sales team using it to basically ask questions about the account to having it basically monitor for kind of like account changes and then proactively pull up kind of like uh
3:07research reports, do research, and then draft outreach. And so this is one example of moving from kind of like chat to this proactive always-on. We see the same thing happening in engineering.
3:17Everyone of course uses agents for coding, but thinking about how to use these agents in the the software factory that you're building is really important. There's a lot of events that happen. Pull requests are an great example of this. You want agents always on, always working, um responding to changes, uh responding to to comments, and basically acting in the background. Um and then Content Studio uh on the marketing side is another agent that we have.
3:43Um and a lot of this is proactive in terms of asking it to generate kind of like slides and generate images, um but it's also monitoring drafts that we have in Notion and when we see people comment on it it take it it takes those and and changes the draft itself. And so all of these are examples of going from kind of like tasks to the responsibilities that the agent has.
4:05One one big change that we've seen is that these agents need to have persistent state. Um so so that includes kind of like their purpose, their goal in life, like relevant context for them to do. Some some semblance of what unresolved work might still be going in or still be going on that it should check in on. Because it could be doing two or three or even four different things in the background.
4:27And these agents might expose themselves in a variety of channels for users, but under the hood it's really important that it has one stream of everything that's doing. So whether it's a scheduled scan or a new event that comes in or a new message that comes in or a call log that it sends, all of this contributes to the same kind of like single channel of of of state. And in fact, if you look at some of the proactive roles on assistance, like these things and news um and and
4:55kind of assets as well, there's just one big message that it shares with you, the user. And I actually think this is an intentional design choice because these agents are doing so many things and they're trying to represent all of that in a way that I think would be really overwhelming. So instead they decided to keep it really simple and treat it kind of like a one big channel to represent the fact that this is just one big agent doing all of this work.
5:17One of the big problems that we see with building these agents come from more of this is one of the big ones that we see, is basically like triggers are not reasons to act. So what I mean by this simply is agents are listening to a bunch of different events in the background. Um so if you add a new user to Slack and there's a lot of different messages in it, it may not be needed in each one. This is a example, but the same thing for email. If I'm an email assistant, it doesn't need to respond to each one. And so there's this new um
5:44there's this new um responsibility that these agents have. Previously we would even message them and we would assume and we and we uh created them so that they always respond to us. Now they're listening to and they're taking all these events sent to them and they have to decide when not to respond.
6:02If you get this wrong, it can be really bad. What if you don't flag an email that's really important? What if you flag like a bunch of spam emails? All of those are really bad outcomes. And so managing this kind of like proactiveness and tuning it to be just right is one of the biggest challenges that that I see people dealing with. And that's because when they're correlating, they create a ton of noise that just spams the user over and over again. So any thing they can use, if you think about what they're doing for you, they're running in the background. There's probably a bunch of times that they're running and you never
6:32see anything that they do. And then they do it again. They just shout with the same offer to check your email or same offer to do something again and again. That would be a really bad And so this type of like proactivity I think is uh is one of the new things in terms of building these proactive that that is a problem that didn't exist because they always respond.
7:00Um with when when we think about agents, I think the hardest part of of building agents is uh getting them to the behavior that we want them to behave.
7:08It's pretty easy to build a prototype, but getting them to handle different situations in the right way, I think that's consistently been one of the the challenges of what we've seen at Um it it it and when we think about this behavior, we think there's kind of like three different dimensions. Um and I'm going to I'm going to talk through all three of these dimensions of how they apply their The three dimensions we think are kind of like one, what is the intended behavior for the agent? This is often the code, the tools, the skills that you
7:38can be able to make. That's what you wanted to do, that you wanted to use the skills, you wanted to use the tools. You have some prompt which says how you want the agent to act.
7:47The second big pillar is how how does it actually play? Because all that is great, but when an agent's running, they're non-deterministic and they're really sensitive to like small changes in in in a prompt or any of the the tools that it interacts with.
8:00So there's no real way to know what the agent is going to do based on the code or the prompt. You kind of have to see how it's actually running. And so is observability data, being able to see the observed behavior of of the agent that's really important.
8:13And then and then as we move towards these proactive goal-oriented always-on agents, I think another really key piece is like what is acceptable behavior? So what I mean by this when I'm talking about most of you talking about kind of like guardrails and identity and permissions and what tools it can access and not what tools it has, because when we have these proactive always-on agents, there's this idea that they're they're more autonomous. They're really working for you. They're they're being free in how they approach this goal.
8:41But you still need to set some guardrails. You still need to set some some lines to to to run within. And that's where setting the acceptable behavior as kind of like hard and fast kind of like guardrails is really important to talk about. And so I think these three pillars make up a lot of what's hard to building the different components of building agents.
9:00And so I'll talk I'll talk I'll want to talk about agents and then and then talk about one thing that I think binds all of them together which is memory and and and and then and tools. So first I want to talk about the runtime. This is the intended behavior of the agent.
9:13How does the agent do the work? How do you steer it?
9:17So when we think of an agent, we talk about them being a harness and their being context. And so what I mean by that is there's the LLM or a series of LLMs and a series of voice models that that work together to basically represent this agent. And you can swap and you want the ability to swap and encounter and choose which one to use. Some might be good for different things.
9:39Some might be faster, cheaper, lower latency, better at different languages. And and and and so the model is a knob that you can kind of like tune and and dial. How that model interacts with its environment, that's what we call the harness. And so the harness is basically the orchestration layer that sits around the model and interacts with the environment, interacts with the tools, interacts with knowledge.
10:03Some of the ways that it can interact are standards. So MCP is a standard that lets you plug tools into a harness. The harness has to be aware of what MCP is and how to call them. Skills are another example of this. Subagents are another example of this.
10:17So all of these integration bits and are part of the harness. And then lastly, there's the context. And so this is information and instructions and facts that make up a domain that you want the agent to be good at. And this is usually a domain that you, the builder, are an expert in and want to harness onto the the agent in terms of knowledge or tools that you want to give it for your APIs or skills working in a in a different way.
10:45And so all of these are different levers that that you can you can kind of like tune to get the agent to work. And and and one of the most important ones I think is is starting to become the context that the agent uses. This is often times going to be the most domain specific thing that you will will have and really the core kind of like the specialization of the agent because when we build an agent, we're specializing it in some way. And so we're taking these general purpose models that are really good.
11:14We're using these harnesses and more and more there are starting to be like pretty good base harnesses to use. And then we're plugging in the context. And the context is always the stuff that's going to be different for the agent. This is never going away. And I think there's a different types of context. So I want to draw a distinction between two different types of context that we see being really important. One is basically facts.
11:37And then the other is is is judgment or behavior or basically things that can't be written down. And and and so maybe like draw a distinction between this.
11:49Facts would be things like companies like those of we do. So I'll use an example throughout this of which is a great go-to market startup that we work with. After is in the sales go-to-market space. They they basically work for the marketing team. So one of the things that they want to do is know for if they're working with a customer, the customers need to know who they're trying to sell to, what things they have launched. And so
12:25about products that their customers might use or accounts that they're monitoring. have and might want to impart onto the system or actively might want to build in because they themselves are experts in the market. So examples would be like how to write a good cold email. That kind of thing is something that takes a bunch of kind of like skill and knowledge and nuance to be a little bit and that might look slightly different from your domain and you might not have like a perfectly kind of like notion document around what
12:55that looks like. And so a lot of this judgment doesn't exist in kind of like written down documents. It's it's out there and humans know it, but it's in their brain. And a big part of getting agents as like agents to behave and if you think they're behaving poorly, that that means that you have some misalignment of how you want them to behave or how you think they should behave that that that this misalignment is what they're actually doing. And often times that comes down to not giving them the right context.
13:25And often times that context that's missing is not facts. Those are facts and generally easy to provide. It's just tacit kind of like really subtle kind of like knowledge of how to do something.
13:35And so the team that's designing like really good um autonomous agents is getting as much of this like tacit judgment that will align the agent with how you want it to behave into its context as possible. And so the key to do that is actually to set up a really really good feedback loop because that's how the agent is going to get that knowledge. It's going to do something. It's going to draft outreach for an account. You or an expert is going to judge it. It's going to look at
14:05the message and it's going to give feedback in some way, whether it's explicit or implicit. Usually the more explicit it can be the better. But you're going to get that judgment. Um you'll see very very transfer it into instructions or skills transfer that back into the into some part of the agent and then and then you kind of like fine tune a lot of this a lot of this knowledge into something
14:33that aligns the agent with how you want it to behave. The the reason that I think this is so important for these like proactive always on agents is again they're always on. They don't have the human if you're using a coding agent and does something slightly wrong you're usually as it goes off. If you have this agent running in the background it really needs to be aligned with how you work.
14:55That probably means at the start you have really tight feedback loops to get what's in your head and what good looks like into some thing that the agent can understand and then hopefully over time it can start to take that and and kind of work for longer and longer.
15:08And so I want to give a real example of how actively kind of like he's about this because I think a lot of this um is is around um a new term that I like is around like goal engineering. Like you want to design a goal that is aligned with feedback because feedback is so important and if you can design the goals and if you can design the agents on those goals to be aligned with with how you can easily give feedback and capture the most feedback and the agents will be
15:36So this is this is an example of uh let's call it like V1 of back of these agents where they basically had a different uh agent for account and that would make sense. Each account is its own like thing. There's a bunch of knowledge about the account. Why why shouldn't there be an agent that just tries to progress the account through different stages yourself? That that intuitively makes a bunch of sense.
15:57Um going back to the two types of contacts that you might have one type of contacts is fact based stuff and often times things about baby now are very factual. What do they do? Um you know what's what's the size of the company? What are uh who are the who are the people there?
16:14Those are all the facts. Then there's these different stages.
16:18There's these different things that you do with each account. So you like do research on an account. You do the outreach to an account. You make the follow-up. It does things across all accounts. And that often times is what will make the agent good in your eyes or not. And again, it's slightly different for kind of like each each customer. So actively can't just only say, hey, this is exactly how you should do outreach because different companies might want to do outreach in different ways. So they need different abilities proactive always on agents to
16:46to learn what what that looks like. And so you now have one agent per account. But each agent is trying to learn the same set of things, but it's all scattered all over the place. And so you you could One way to approach this would be to design a really complicated memory system that that pulls things from all different accounts and triages them into these different stages.
17:07The the kind of like cleaner and simpler things do is actually like pre-compute tasks that agents around these different stages. So now you have a research agent. Now you have an outreach agent. Now you have a follow-up agent. You can do all outreach for these different accounts.
17:24You can see it on one view. You can give feedback on it. Um so switching between different types of like feedback is a very like time sensitive thing. It's very costly. It's human hours You want to make it really easy for people to give feedback. If you're trying to get feedback on research and outreach and follow-up, it's probably not going to go super fast. If you're just churning through a bunch of like outreach and and correcting them, it's going to be very fast and it's going to be very clear where that feedback should go to the outreach agent. And you still
17:52have account contacts. You still have contacts for account A. It's just that this is factual. This is easier to spread across different agents and you don't need to align it so much. And so I think this is a really good idea or a good example of kind of like goal engineering. And when I talk about goal engineering, um it it it's it's again this idea of making like the work that an agent is doing really easy to correct. The the hard part about getting
18:20uh the the agent to move time. One one of the hard parts is getting the feedback for how it should improve over time. If you if you've ever given a thumbs up or thumbs down or you're on a chat bot very rarely do people kind of like click that thumbs up and thumbs down. Getting feedback is hard. And so the more you can do to align uh to get this feedback the better. That involves also um building a good UX. Uh I think that's a really underestimated part. I think like we talk about UX for
18:49interacting with agents, but UX for viewing agents is really really important. And the key part here is that uh you take that feedback and you use it. And and again there's different types of feedback that you can get. Not not everything has to be kind of like explicit feedback. If they approve or reject uh an email there's probably some feedback in there even if it's not as explicit as some like kind of language that the customer gives.
19:16So you should be trying to design systems to really elicit the most possible feedback um from uh from from from users. The other thing that we probably want to think much about in terms of goal engineering is is is really like what the uh what the what the how how to measure the the end result.
19:39Like agents are really good at like uh uh taking a goal and just like running with it. And you see that they're like trying to be persistent. You see this with like coding where you'll you'll give them a problem and they'll spin up a bunch of sub agents. And this is why there's this flood of so many security things because they really want to solve a problem and so they break out of their sandbox and do it. And they're they're super persistent. So you want to be really precise in kind of like what the right thing to optimize is.
20:05Um and and and and so you want to get some idea of how to measure progress as it's running in the background, but you also want to be uh aware of basically um the fact that if you're giving a wrong objective to the back slide it's going to go off and do that thing. And so like uh you know, this is one example in the sales domain, but I actually like an example in the software space better. If you're telling agents to go out and and remove all bugs in the code base, they might just delete the code base. There's no more bugs. And so
20:34that's an example of a kind of like a cheating as a metric, but it's not at all what you intend. And so having it aware of metrics that are like reasonable and all metrics are kind of gaming but hopefully can't be gamed too much, and then also having some alignment for not just completely go off the rails is a new problem. That again you don't we haven't had until we have these really long proactive always on always on agents.
21:02Um I mentioned this already, but like I think one of the other thing issues that comes up and that you have to deal with in in the harness or the runtime um is is basically when to interrupt.
21:12Interrupting too much can be really costly, um but not interrupting can also be costly. And so there's some signal. This could be an incoming email. This could be a change to an RFC. This could be a GitHub PR to review. There's then some work that the agent will do. Sometimes this is as simple as just running a classifier.
21:30Sometimes it's actually going out and running some research work. And then at the end is making a decision, do I interrupt the user or do I not interrupt the user? And so this is a new type of harness capabilities that will need to be in the harness system. You know, some some harnesses or some models might call sub agents too much or might, you know, use M dashes too much. I think we'll start to see that some model or some harnesses interrupt too much. Like so the behavior that we start to notice of
21:56of the runtime of the harness. Another kind of like runtime behavior that we see being really important is the concept of asynchronous sub agents. So basically the ability for this main agent to delegate work to background agents that run, have it run while it's doing something else, and then and then as background work finishes, having it come back in. These agents are running for longer and longer periods of time.
22:19They're being asked to do more and more complex work. Um and and and and they're also being exposed through a variety of different channels. And so we've really lent into this idea of of uh of asynchronous subagents.
22:33Um and and and one easy way to to imagine it right now is basically like uh all sometimes ask my agent to do something that takes a while, like uh go do something on the web, which is kind of slow at browsing That's just doing this a lot with voice agents because you need to maintain a connection to the user on the phone and keep on chatting with them, but you also want to do really complex background things. Um and and so I think that's really asynchronous subagents one of the first examples that I saw that made it really quick where I had a lot of voice
23:02demos because again you need this kind of like main agent to maintain a conversation with the user, but you want to do a bunch of work. And so so having harnesses that support this There's another There's a really interesting context engineering um you know uh kind of like arguments here around when when that background agent finishes, how does it actually alert kind of like the main agent? Um and so there's some there's some context engineering thing that can be done to kind of like nail
23:29that as as well. And then the last thing um that they'll talk a lot more about when they talk about memory is basically this idea of basically of of of state that the agent accumulates.
23:40Um as the agent does work across all these different domains and across all these different subagents, uh you want you want to keep track of what it's doing. Sometimes this just looks like context in the agent. Um sometimes this just looks like uh knowledge that's in the file system.
23:56Um one of the things that we've one of the other things that we've seen a lot of our internal agents start to do is have this structured like task table where they keep track of all the different things that they're monitoring. Um and then when they when they wake off in the background, they can kind of check to see if any of these tasks need to be progressed or if feedback gone on or if the user has pushed that to the back and rejected.
24:18And so having this kind of like an activity log of everything that it does is is is important for keeping track of state over long periods of time.
24:26All All Next I want to talk about feedback loops and observability. This gets into how do know that the observed behavior of the agent is because we can design this harness that has all these async sub agents and memory and and alerting and and we think we know what it does, but we don't actually know what it does with all the production. And And And And that's why
24:47Um I want to start with One of the big changes that we see with these long running agents is that it's no longer enough to just test the end result. You want to test everything that it does. Um so you want to look at the actions it's taken, the state that it's that it's um manipulated, the the trajectory of its tool call, and you want to test uh you want to test a bunch of different dimensions. Um does it does it stay quiet? Does it wait? What tools does it call? Um when
25:15you Does it have the right access? Um and and so being able to test more than just like like the final output is really is is really important here. I When you think about testing that, I think there's two different components.
25:29One is kind of like what the agent actually did. This is what we call a trace. Trace supply kind of like the evidence of what happened. This is the trajectory of the agent, all the tool calls, um maybe a string of thought if you have that, um basically what it did.
25:41The rubric is then your logic of what of whether that's good or not. Um and so was the signal that it found relevant Does it reach a threshold? All of these are different dimensions, and we see a lot of work that that that companies are doing goes into defining these rubrics because now it's There's multiple things that you want to grade because it's not just like one thing that you want to check. There's usually four or five, six different things. Um and it's checking more than just the final answer. It's checking the whole the whole trace.
26:09And so so collecting traces and and and creating rubrics are really important for for evals.
26:16Um we talked a lot But we talked a lot about this idea of image running in the background when they get alert. You need to get that right. You need to evaluate that as well. So now there's this two dimension of basically you have this you have basically this this uh false positive true positive, false negative, true true negative Should it actually do something and does it actually do something or or you know does it create any noise? Does it create this opportunity? You might care about different you might you might care about these in
26:46different amounts. Maybe in some cases you might care more about avoiding false positives, other times you might care more about avoiding false negatives. And so it's not necessarily a universal kind of like a grading scheme here, but this is a new dimension that didn't exist with with kind of like that you now need to evaluate.
27:07The other thing that I think exists but is very true also of these of these is basically you want to test the agent in in the it's called So Harbor is a really good open source framework for running these these sandbox agent This is really important in coding because you want to give it a a container, let it run, let it manipulate code and then see and then scrape basically the code that that's there at at the end. Same thing for these that are doing things. You want to see
27:36what databases it changed. You want to see what And so finding it in the environment and testing not only the final answer but also the final state in the is important there. As you're running your agent you'll probably see it fail in unexpected ways.
27:53You'll see users start to use it in unexpected ways and there might be some failures and turning these failure into regression tests is really really important. So really common is sampling traces, reviewing those traces against a rubric either using LLMs to judge or with humans, keeping any kind of like useful test cases and so these would be cases where the agent fails in either a unexpected way or in in an unexpected domain.
28:20And then whenever you change your prompt model or context harness you can you can kind of like test them back against them. And so again just to just draw a distinction here, this is this is the role of a developer that's building the not necessarily of the user of the the user shouldn't have to think about things like this. Memory is like an internal loop there for the user. That's just work. This is a developer facing loop.
28:46All right, last thing we have governance. What is the agent allowed to do? I actually think this is one of the space that's just changing the most with these proactive always-on goal-oriented agents because they're starting to do more and more. And so while that's exciting, you also need ways to kind of like limit what they can do. Um some things you might want to add uh uh a human thing on even if you know the agent is pretty good at it. So I have an email agent that's pretty good at kind of like sending emails for me, but I
29:15still approve every single one that goes out because I want that that that's what I want to do.
29:21I want my I I I I I I don't trust the agent to be fully autonomous in that way. It's still pretty good results. I actually don't interact with that many of them at all, but I still have this kind of like explicit thing. And so I just want to mention this to say like just because the agent is good at something does not mean that you or your users will necessarily want the always-on to do it. There are there are definitely kind of like cases where for user trust or for UX you might uh you might want to um lock it down.
29:49Locking it down does not mean putting stuff in the prompt that says don't do this without my approval. It means actually enforcing that kind of like the API level.
29:57Um I see the API level in particular. I think that's a great place to enforce these boundaries. Um we have a concept of a pool server um which is when agents interact with pools. That's a very natural place to put and and and and control in the way that the agent cannot control but like you as a developer control. Who does the agent act on behalf of? Does it act on behalf of you or as a fixed credential? Um are there any policies that apply to it in terms of how many emails it can send out or things like that? And then does
30:26it need human approval or not? So again like prompts do not involve kind of like automatic uh enforcement of things. I I identity briefly. Identity is really, really interesting. We see two main forms of identity. One is as acting on behalf of a person.
30:44Uh so if I so we have um we have uh we have Robin. Robin is our internal company just like general assistant. If I ask it a question, it authenticates through to you know through my credentials so it has access to everything I have in Notion. There are also some tools like web search where just you for actually Salesforce is a good example of this.
31:05Not everyone in the company has access to Salesforce, but we want everyone to know what's going on in different deals. And so we have kind of like a company that has access to all the general stuff in Salesforce.
31:16This can also depend on the context. And the context can be what channel it's acting in. So we have Robin our our agent in Slack. It actually gets different uh permissions when you're interacting with it in DMs versus when you're in a public channel. Uh it gets different memories in DMs than public channels. Um this is because in public channels we have other people who can see things and we can also ask it to do. And so you also want to make sure that if someone follows up to me and starts doing something that's doing it with their credentials, it's
31:44not mine. And so there's a bunch of multiplayers and really, really you see this pop up in uh in in in things like Slack and and company agents in general. Um again kind of like similar things to to that as bots do not need enforcement. Sandboxes great if you're absolutely using a sandbox to run custom code.
32:04We'll probably want a different service for some of the identity and authorization and limits and things like that. We have a tool server. We use the tool server and our sandbox at at the same time and they both do different things.
32:19Um you want people to at a certain point you don't want it in a loop at every single thing, otherwise it will get really annoying. The key is to figure out a a a bunch of work that the agent can do and then come to you for basically approval or review of the draft.
32:34Um and and I say draft even outside of the I say draft in in almost like an abstract sense. So you want it to do a bunch of work and then come to you. If it has to if it has to get your approval for every web structure it runs, that's terrible. These are designing kind of like experiences where you can do a bunch of work, create a draft, and then review it um makes uh it makes it so that you trust it more with long running things.
32:56Speaking of trusting it, he enabled to basically adjust the agent as it's running and being recorded.
33:02Uh things like steering and queuing are two different context engineering mechanisms for dealing with new messages that come in. If I I kick off an agent and I message it after 3 minutes and it's still running, does my message automatically go to it or does the agent finish running the first time and then my message comes up? That's the difference between steering and queuing. Can be written in different scenarios.
33:23Now a new problem we have with some of these long running agents.
33:28I want to talk really quickly about memory. I think memory span across all of this is a really important part of getting long running proactive agents uh right. Um memory is basically evolving the context over time. Again, agent equals model harness context. The context is the one that's easiest to evolve over time. Um memory involves a bunch of maintenance and I think this maintenance is actually the hardest part of memory. Storing memories can be easy.
33:54You can go basically just using markdown files and storing those in a database or a file system. But a lot of the difficulty comes around knowing what to retain, how to update things, and when to even remove things completely.
34:06The best way we've seen to do this is have uh uh uh a curating agent that maintains memory. This is separate from the main agent that's running. Curating memory is a hard job. If you ask your main agent to do that and do its job, it'll probably not be the agent that done that well. And so one of the best strategies we see is have a background dreaming or or a curating job that like takes a lot of uh notes that the agent might make as it goes along and curates those in in in into memory.
34:34Um memory applies at different scopes. Uh so you want personal memory, you want company memory. This is an example from Active where layer. They have account based memory and then notions what are which are what they call basically the outcomes of Those all apply at different scopes. You'll want to balance them and you'll want to parse when a user says something which memory should it be applied to.
34:57Um depending on the context uh the the change might be different. Um so again this is a hard part of memory. When I say uh don't send this draft, is it just for this action? Is this supposed to be updating the behavior over time? And then what if or is this supposed to be updating knowledge over time? I think you'll want this kind of like memory and this streaming or this curation over two different sources of long-term things.
35:22One is skills, how the agent behaves. The other is facts, what is true. Those are separate things. You have different structures but they both need this type of like curation that happens over time.
35:32Memory changes are just like any other changes to your agent. They can maybe go off the rails, they can begin to misbehave. You'll want to test it in some way or have some guardrails around it whether it's offline testing or online testing. Uh you'll you'll want to be monitoring your memory and making sure that it's behaving and making changes that you wanted to that you wanted to make.
35:52Okay so talked about kind of like the the intended behavior, the observed behavior and and then the kind of like how to control the behavior and the limits around the behavior. Memory I think it comes it all together but also kind of like want to want to close out with some higher level thoughts. Um first there's two different loops that should be happening. One that uh dictated based on customer feedback. One is the the the loop that is most visible to the user and this is I think best approximated by by memory. The user says
36:21something and and memory updates automatically. Then there's a loop that developers do.
36:27There's developers who see users using the application even if memory fixed it, they still want to know what's going wrong and and and and maybe correct based on this. This might involve more than this probably involve more changes to things than just memory but they both have of idea of something happens, it wasn't right in some way, update something, do some verification that the fixes you made actually work. And so two different loops at two different kinds
36:53of abstraction the same pieces.
37:00Um, generally in in terms of coding the behavior we think this is the most important part of when we say we talk about coding intelligence a lot. There's a lot of different pieces of that, but the coding behavior of the agent is the main part. What goes into the behavior the one time is kind of like the intended behavior. Um, the governance controls what exactly it can do. And again you want to observe this behavior as well. So we think a lot about coding intelligence, we think a lot about coding behavior. We think these three big three different pieces.
37:28Um, these are these are there's a bunch of open questions that are trade-offs. When should it act? We talked a lot about this. This is the proactiveness. That's really important to get right and an open question. What should generalize?
37:39That's memory. Again, open question but really important. How do we actually prove that these things are working?
37:44Evals online and offline are really important but also really hard to get right. How do we do that? All of these are open questions that that I want to want to kind of leave you guys with. And the last thing that I'll just say um, the the best way to build these agents I think is to start giving it uh, one thing to do at a time and then another and then another. One really good mental model to say like from a customer of ours is they have this proactive always on agent and it has different skills or different playbooks that it can run. And
38:13basically it will go to the user which it thinks the most popular skill is. And then once it's done with that it will go with it to another and be like hey, I have you know, do you want me to do X?
38:22Do you want me to do Y? Do you want me to do Z? Each of them are different responsibilities, different playbooks in the back end. But it's slowly kind of like getting the user comfortable and letting it be more autonomous. Really autonomous defining agents aren't going to just like magically appear. They're going to be built step by step.
38:37And hopefully some of the things that I talked about will give you guys some good ideas on how to build them. So thank you guys for your time and yeah.