Harrison Chase - Agents Masterclass from LangChain Founder (LLM Bootcamp)

Agent systems are built around a simple but consequential shift: use a language model as a reasoning engine that decides which tool to call next, then adapts its next step based on what the tools return. That flexibility matters because real tasks rarely follow a clean script—especially when answering questions requires multiple hops, when database queries can fail, or when the system must recover from wrong intermediate actions. Instead of hard-coding “do A then do B,” an agent chooses actions dynamically, guided by user input and the results of previous steps.

The practical backbone of this approach is tool usage plus iterative control. A typical agent loop takes a user query, asks the language model to select a tool and provide the tool input, executes the tool, records the tool’s observation, and feeds that observation back into the model. The loop continues until a stopping condition triggers—often when the model decides it has enough information, though hard-coded rules can also force an early return (for example, after a fixed number of steps without reaching a final answer). This design is meant to overcome core language-model limits: models may not know private data, may struggle with exact computation, and can hallucinate. Tools—search APIs, databases, and other external computation—act as the corrective layer.

The most influential prompting strategy for this tool-using loop is ReAct (“reasoning” plus “acting”). ReAct combines chain-of-thought-style reasoning with explicit tool calls, aiming to improve both decision-making and grounding in real information. The transcript contrasts three approaches using a multi-hop question over Wikipedia: a direct answer attempt fails; “let’s think step by step” improves reasoning but still lacks grounded tool access; and “action-only” can retrieve information but may lose the reasoning structure needed to integrate results. ReAct’s blend is presented as a way to get the best of both: stronger reasoning about what to do, paired with tool calls that fetch the missing facts.

Despite the promise, production reliability remains a major challenge. Agents often misuse tools when they shouldn’t, or fail to use the right tools when they should. Tool descriptions and instructions can help the model choose appropriately, but scaling to large tool catalogs creates context-length pressure—pushing teams toward tool retrieval (embedding-based selection of the most promising tools) and retrieval of relevant few-shot examples. Another reliability hurdle is turning the model’s tool-call text into executable code; structured outputs (often JSON) and modular output parsers—sometimes with retry-and-fix behavior—are used to reduce parsing failures.

Long-running agents introduce additional failure modes: they lose earlier objectives as prompts grow, they struggle with remembering long tool outputs, and they can drift off track. Common mitigations include re-stating the objective near each action, retrieving only the most relevant prior steps, and summarizing or truncating large API responses. For longer horizons, separating planning from execution is highlighted as a promising reliability tactic.

Finally, the transcript links agent reliability to evaluation and memory. Evaluation must measure not only the final answer but also the agent trajectory—whether actions were correct, inputs were valid, and the number of steps was efficient. Memory is treated as central to modern agentic systems: beyond keeping recent steps, newer work emphasizes personalization, long-term memory via vector stores, and reflection loops that update an internal “state of the world.” Recent projects—AutoGPT, Baby AGI, CAMEL, and Generative Agents—are described as pushing these ideas forward through longer objectives, simulation environments, and time/importance/relevance-weighted memory retrieval with periodic reflection.