Agents let a model choose what action to take next. A tool can be a search function, calculator, database lookup, ticket creator, calendar API, or internal service. The agent reads the user request, chooses a tool, passes arguments, observes the result, and continues until it can answer.
Agents are powerful, but they are not the default answer. If your workflow is known, build a chain. Use agents when tool choice or step order is genuinely dynamic.
LangChain is expanded here with a practical explanation, multiple examples, and beginner-focused checks so the idea is easier to learn from this page alone.
Read the concept first, then trace the example line by line. The important habit is to connect the rule to visible behavior instead of memorizing only the name.
An agent is a loop around a model and a set of tools. The model decides which tool to call, and your code controls what tools are available.
Good tools are narrow, typed, well-named, and safe. The model should not need to guess what a tool does. Dangerous tools should require confirmation or operate in read-only mode by default.
LangChain becomes much easier when you separate the concept from the tool syntax. First identify the problem being solved, then identify the data or resource being changed, and finally identify the proof that the change worked.
In LangChain, this topic should be studied through prompt inputs, model calls, parser behavior, retrieved context, tool boundaries, and validation. Those points explain not only how to use the feature, but also why it fails when the wrong assumption is made.
The previous audit note was: under 650 content words; fewer than 2 sections . This expanded section adds a fuller explanation, concrete examples, and practice guidance so the page can stand on its own for beginners.
A good way to learn this page is to read the normal path once, run or trace the example, then intentionally change one input to observe the different result. That one change teaches more than memorizing several definitions.
Start with a tiny project scenario. For example, imagine one user action, one request, one resource, one function call, or one batch of data. Keep the scenario small enough that every step can be explained without skipping details.
Next, describe the movement of information. Where does the input start? Which rule or component handles it? What result should appear? If the result is wrong, where would you inspect first?
Finally, compare two outcomes. The correct outcome proves that you understand the main rule. The incorrect outcome teaches the symptom, which is what you will recognize later during debugging or interviews.
This example exposes two safe tools. In production, tool functions should include logging, permissions, timeouts, and typed errors.
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
@tool
def calculate_monthly_cost(users: int, price_per_user: float) -> str:
"""Calculate monthly subscription cost for a number of users."""
total = users * price_per_user
return f"Monthly cost is ${total:.2f}"
@tool
def lookup_plan_limit(plan: str) -> str:
"""Return user limit for a plan. Valid plans: starter, growth, enterprise."""
limits = {"starter": 5, "growth": 50, "enterprise": "custom"}
return f"{plan} plan user limit: {limits.get(plan.lower(), 'unknown plan')}"
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
agent = create_react_agent(model, tools=[calculate_monthly_cost, lookup_plan_limit])
result = agent.invoke({
"messages": [
("user", "If we have 18 users on the growth plan at $12.50 each, what is the monthly cost and is it within the plan limit?")
]
})
print(result["messages"][-1].content)from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_template('Explain LangChain with one example and one warning.')
chain = prompt | (lambda message: message.text) | StrOutputParser()
# In a real app, replace the lambda with a chat model and keep the parser step explicit.def check_answer(answer: str) -> list[str]:
issues = []
if 'source' not in answer.lower():
issues.append('Add sources or retrieved context.')
if len(answer) < 120:
issues.append('Add a fuller explanation for LangChain.')
return issues
print(check_answer('Short answer without source'))Give an agent unrestricted database write access.
Expose narrow tools with authorization and confirmation.
Use vague tool names like run_action.
Use specific names like lookup_customer_invoice.
Learning LangChain only as a term.
Learn it through a working example, a boundary case, and a failure case.
Skipping verification.
Always check output, state, logs, metrics, query results, or compiler feedback.
Changing many things at once while debugging.
Change one setting, input, or line, then inspect the result.
Use an agent when the model must choose among tools or determine the next step dynamically. Use a chain for known workflows.
No. Safety comes from limited tools, validation, permissions, confirmations, logging, and evaluation.
Start with one tiny example, trace every step, then compare it with a broken version.
Verify the visible result: output, state, log entry, metric, query result, compiler feedback, or rendered behavior.
It often combines vocabulary with behavior. The confusion drops when you trace the input, rule, result, and failure path.
Explore 500+ free tutorials across 20+ languages and frameworks.