How Do You Build an AI Support Agent with LangChain in 2026, and When Does a Platform Beat It?

To build an AI support agent with LangChain in 2026, you call create_agent from the langchain package (v1, running on LangGraph), give it a model, three or four tools such as customer lookup, help-center search and ticket reply, and a system_prompt, then wrap it in a webhook your help desk calls for each new ticket. The agent code fits in under 30 lines. The help-desk client, the hosting and the framework upkeep around it are the larger job, and they decide whether a framework or a platform is the better fit.

What does LangChain handle, and what is left to you?

A support agent is a loop: read the ticket, call tools to fetch context (customer, orders, the right help-center article), act (reply, tag, escalate), and know when to hand off to a human. LangChain's own definition is clean: an agent is a model calling tools in a loop until the task is done, and the framework is the "harness" around that loop: the model, its prompt, its tools, and middleware. (If you're weighing build-vs-buy first, see our AI agents for customer service overview.)

How do you build the agent with LangGraph?

LangChain agents now run on LangGraph (both are past v1.0). One accuracy note that trips up older tutorials: LangGraph's prebuilt create_react_agent is deprecated in favor of create_agent from the langchain package, and the old prompt= argument is now system_prompt=. Install with pip install langchain langgraph langchain-anthropic, and a minimal support agent looks like this:

from langchain.agents import create_agent
from langchain_core.tools import tool

@tool
def get_customer(email: str) -> dict:
    """Look up a customer by email."""
    return db.query("SELECT id, plan FROM customers WHERE email=%s", email)

@tool
def search_kb(query: str) -> list[str]:
    """Return the top help-center passages for a query."""
    return [d.page_content for d in vectorstore.similarity_search(query, k=3)]

@tool
def reply_to_ticket(ticket_id: str, body: str) -> dict:
    """Post a public reply on a ticket via the help-desk API."""
    return zendesk.reply(ticket_id, body)

agent = create_agent(
    model="anthropic:claude-sonnet-5",
    tools=[get_customer, search_kb, reply_to_ticket],
    system_prompt="You are Acme's support agent. Answer from the help center; "
                  "escalate refunds over $100.",
)
result = agent.invoke({"messages": [{"role": "user", "content": ticket_text}]})

To run it on live tickets you wrap that invoke in a webhook your help desk calls per new ticket, which is the plumbing covered in the "what's still yours" section below.

That's a working agent, and this is where LangGraph earns its place over a raw loop: stateful graphs with checkpointing and human-in-the-loop interrupts, which support needs when an agent wants to do something risky. In v1 you add HumanInTheLoopMiddleware and name the tools that need approval, so the graph pauses before a refund goes out and a human resumes it:

from langchain.agents.middleware import HumanInTheLoopMiddleware
from langgraph.checkpoint.memory import InMemorySaver

agent = create_agent(
    model="anthropic:claude-sonnet-5",
    tools=[...],
    middleware=[HumanInTheLoopMiddleware(interrupt_on={"issue_refund": True})],
    checkpointer=InMemorySaver(),      # persists run state between pause and resume
)
config = {"configurable": {"thread_id": ticket_id}}
result = agent.invoke({"messages": [...]}, config)

Pair it with LangSmith and you also get tracing (see every step of a run) and evals (score agent trajectories), so unlike a raw build, observability and evaluation are partly handled. The LangChain agents docs, the v1 migration guide and the LangGraph repo are the primary references. This is the real argument for the framework: if you need that control, you get it.

Where Claude Code and Codex help

Both coding agents are fluent in LangChain and can scaffold the graph, tools, and LangSmith wiring from a description, then you refine. They write the framework code fast; they don't decide your tools, guardrails, or escalation policy, or run the agent in production.

What does LangChain still leave you to own?

LangGraph + LangSmith cover the loop, orchestration, tracing, and evals. Here's the honest remainder:

• Connect your help desk. LangChain has integrations, but a production support agent still needs a real Zendesk/Freshdesk/Intercom client (OAuth and token refresh, pagination, rate limits) and a webhook endpoint to trigger the agent per new ticket, with signature verification and idempotency. That's yours to build and host.
• Host and run it 24/7. LangGraph gives you the graph; you still need a cloud host (or LangChain's managed LangSmith Deployment, formerly LangGraph Platform), secrets, a job queue with retries/dead-letter, and autoscaling.
• The framework itself. This is the hidden cost. LangChain moves fast: the create_react_agent to create_agent shift, and prompt becoming system_prompt, are recent examples. You're signing up to track breaking changes, migrate, and keep up with a large surface area. That's fine if the framework's control is worth it; it's overhead if you just wanted a support agent.
• Maintenance. Model deprecations, help-desk API changes, KB re-indexing, and the framework upgrades above, permanently.

When does a platform beat a framework?

A framework is the right call when the agent's orchestration is your product: you need custom LangGraph state machines, unusual control flow, or to embed the agent deep in your own app. But if your goal is "resolve support tickets well," a framework asks you to own a lot that isn't your differentiator: the help-desk plumbing, the hosting, and a fast-moving dependency.

Macha is the platform side of that trade. You keep the agent design; it owns the infrastructure:

• Tools without clients. Custom Tools turn any REST API into a tool (define endpoint + auth, or let the AI builder create it from a sentence). Your help desk is a native connector (Zendesk, Freshdesk, Gorgias, Front, HubSpot or Intercom), so there's no client to write, no webhook to host, and no framework version to chase.
• Run, observe, grade. Agents run in the cloud, triggered by tickets. Agent Analytics traces every run (the LangSmith-style visibility, built in), simulations replay past tickets against an agent, and evaluation scores its output.

The pricing shape differs too. A LangChain build costs model tokens plus your hosting and engineering time. Macha is one plan priced by ticket volume, from $299 a month for 750 tickets, billed per ticket rather than per message, with setup and monitoring by the Macha team included (pricing).

So which should you build?

Reach for LangChain/LangGraph when you want maximum control of the agent's control flow, you're embedding it in a larger app, or custom orchestration is the point, and you're happy to own the framework and the infra around it. (Our from-scratch vs. platform breakdown goes deeper on that trade.) Choose a platform when resolving support is the goal and you'd rather not maintain help-desk plumbing, hosting, and a fast-moving dependency. You can start a Macha trial with $50 of free usage and no credit card, and bring the same agent design without the framework overhead.

FAQ

Is LangChain overkill for a support agent? Sometimes. If you just need "answer tickets from our docs and systems," LangChain's surface area can be more than you want to own, and that's the platform case. If you need custom multi-step orchestration, it's exactly right.

LangChain or LangGraph? Both. You write the agent with create_agent from langchain, which runs on LangGraph underneath; create_agent replaces the deprecated create_react_agent. If you have older AgentExecutor or create_react_agent code, plan a migration using the v1 guide.

Does LangSmith replace an eval harness? LangSmith gives you tracing and trajectory evals, which is most of it. You still assemble the test set of real tickets and decide what "good" means. A platform like Macha packages the batch-grading side with simulations against past tickets.

Can Claude Code or Codex build the LangChain agent for me? They'll scaffold the graph, tools, and LangSmith wiring fast. They won't make the product decisions or host, monitor, and maintain it in production.