Log In to continue learning
Loop Engineering with LangChain Deep Agents
Intermediate
1h16m
Topics
Agents
AI Frameworks
Evaluation and Monitoring
Event-Driven AI
Task Automation
AI in Software Development
Now that you have a map of the four loops, you'll build the foundation for implementing them. You'll get familiar with LangChain Deep Agents and see how its file system, instructions, and skills support agents that work on longer-running tasks. All right, let's go. LangChain has a base ReAct agent in the LangChain library. This is shown here, and it's simply a model calling tools in a loop. You can create an agent like this, providing the model, tools, system prompt, and you invoke it like this, including a request in the invocation. That agent can be enhanced by adding code at critical points in the loop. This is called middleware. You can add code before and after the agent, before and after the model, and before and after tools. LangChain offers a create_deep_agent primitive that adds middleware to enable the list of features you see here. There are four core pillars of a deep agent. First, it has an execution environment. This includes tools, which allow the agent to take actions in the real world, a filesystem, which is the backbone of a deep agent, and optionally a code interpreter or sandbox that allows the agent to execute code. The second pillar is Delegation. A deep agent can plan for complex tasks and dispatch smaller units of work to subagents. At the core of a deep agent is this third pillar, Context Management. It has built-in support for memory and skills. Under the hood, it uses summarization and context offloading, which enable long- running interactions. Finally, deep agents enable prompt caching by default no matter the model provider you're using. The final pillar of a deep agent is the Steering pillar. Deep agents support first-class human-in-the-loop, and as we'll discuss in more depth later, they also support grading rubrics for giving feedback to a core agent. In this course, we'll be using the create_deep_agent primitive to explore the four loops. Here's a quick example that creates a deep agent with a model, tools, prompts, memory, and an additional middleware. As you can see here, we're invoking the agent with a query. Let's try this out in a Jupyter Notebook. So in the notebook, We'll give a quick introduction to the Deep Agents framework so you're familiar with it. We're just going to use a subset of the features, largely the filesystem, the Agent.md files, and Skills files, which are how you instruct your agent. In this lesson, the project you'll be doing is to create a poet agent. The agent will write poems in different formats. The Agent.md file will describe the basics of writing poems, and each of the Skills will describe a different poem format. library, and routines from the LangChain library. The model we'll be using is gpt-5.4-mini, and we'll set the root of our filesystem at a local directory. Now, the filesystem is created with a set of tools that you provide the agent. Those are the read, write, edit_file tools, and so on. The filesystem has a root_dir as /, and we'll assign that to a local directory. There's multiple back ends that are possible with deep agents, including a checkpointed back end and a persistent store. Here, we'll just use the local filesystem. So we'll do that here. And you can see the local file system sees the memories directory and skills directory, which we'll cover next. There's three ways to provide instructions with deep agents. There's the system_prompt that you specify when the agent is created, and you use that every time the agent is called. There's also AGENTS.md. Now this is loaded each time the agent's called, and you can modify it over time, so you can add memories to that file. Finally, there's skills. work with progressive disclosure. At the beginning of a run, a description of what's in a skills file is loaded into the context, but the full file is not loaded until the agent needs that information. It uses the frontmatter to decide if it needs to load any further information. This is what's in the file system: under the root, which is the primary workspace, There's a memories directory. And this is the instruction provided to the agent with each run. you're a poet. You should figure out what form is needed and then write the results into a poems directory. And then there's the skills directory. It has a directory for each of the different skills it has, and we can take a look at one of those. The top is what's called frontmatter. It describes what's below. In this case, you can write an acrostic. And then there's some detailed instructions about how to write acrostics. Here's an example of one. Acrostics have the first letter of each line spelling a keyword. So in this case, this is about the Boston Red Sox, and so the first letters are BOSTON. Now we can set up the agent to run. We'll make a request, which is to write a poem about the Boston Red Sox in each of the forms. This is how you invoke the agent, provide that request, and run it, and this is the output. So we can see the agent read the four skills to find out how to write each individual style, and then write out a poem. And here's the examples. So here's our acrostic again, a different poem, but again, starting with B-O-S-T-O-N. Now we can look at the trace in LangSmith. As I said, in later lessons, there will also be a local trace that won't require a login. Now, this is a public trace. You don't need a login to view this. And here's the trace in LangSmith. On the left-hand side is a summary of the run, and on the right-hand side are the details of each of the steps. What we see is the basic agent loop. We have a model call followed by tool calls, and a model call followed by tool calls. We'll talk about that more in the next lesson. We can take a look at the first model call. It has a System prompt and a User prompt. Here's the request we saw to write a poem about the Red Sox, and the System prompt, where it gave the instructions you saw earlier in the System prompt. There's more detail here. When you use the filesystem and use skills, Deep Agents adds some additional information about how to use that skills system, how to do the progressive disclosure, for example. And here, for example, is where you see the frontmatter files included in the context. If we drop further, we can see the AGENTS.md file is added to the context here. And then there are some additional instructions for a deep agent. We can see the first read_files are reading the SKILL files to understand how to write different poem types. We have four of those, one for each skill type. And then the second call to the model actually writes the files. So, for example, we have a write_file. We're writing to the acrostic file, and there's the contents: "Bats rise at Fenway with a sharp, bright crack," and so on. And then the final call for the model to return the results. So that's a very quick introduction to deep agents. There's a lot more detail on the website. And a quick introduction to LangSmith, which will let you trace your agents. In the next lesson, we'll look more at the agent loop.
