Build an AI Support Agent with LangChain — and When a Platform Beats a Framework

What you're building

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.)

Option 1: Build it with LangGraph

In 2026 you build LangChain agents on LangGraph (both hit v1.0). One accuracy note that trips up older tutorials: create_react_agent is deprecated — use create_agent from the langchain package, the current agent factory with a middleware system. Install (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-4-6",
    tools=[get_customer, search_kb, reply_to_ticket],
    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 exactly the plumbing the "what's still yours" section is about.

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 — exactly what support needs when an agent wants to do something risky. You can pause the graph for approval before a refund goes out:

from langgraph.checkpoint.memory import InMemorySaver

agent = create_agent(model="anthropic:claude-sonnet-4-6", tools=[...],
                     checkpointer=InMemorySaver())      # persists run state
# the graph interrupts before a flagged tool; a human resumes it
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 and the LangGraph repo are the primary references. This is the real argument for the framework — if you need that control, it's genuinely powerful.

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 LangChain still leaves 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 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 → create_agent shift is a recent example — so you're also signing up to track breaking changes, migrate, and keep up with a large surface area. That's fine if the framework's power 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.

Option 2: When a platform beats a framework

Here's the honest case the title promised. 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, Front, Intercom, HubSpot, Help Scout, Salesforce, Jira Service Management, Pylon); no client to write, no webhook to host, no framework version to chase.
• Run + observe + grade — agents run in the cloud triggered by tickets; Agent Analytics trace every run (the LangSmith-style visibility, built in); Studies grade the agent against a batch of real tickets.

LangChain vs. a platform — the honest table

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 free on Macha and bring the same agent design, minus 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 power (and its moving surface area) can be more than you want to own — that's the platform case. If you need custom multi-step orchestration, it's exactly right.

LangChain or LangGraph? Build on LangGraph in 2026 — it's the current foundation, and create_agent replaces the deprecated create_react_agent. If you have older AgentExecutor code, plan a migration.

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's Studies packages the batch-grading side.

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.