Why is LangChain so hard to use for simple agents?

A lot of people feel that way, and it’s not just you.

Short version: LangChain is powerful, but it’s optimized for flexibility and abstraction, not for the simplest possible “make an agent do X” workflow. That can make basic things feel surprisingly complex.

Why it feels hard

1. Too many abstractions

   • You often have to think in terms of chains, tools, prompts, memory, retrievers, agents, executors, callbacks, etc.
   • For a simple agent, that’s a lot of machinery before you even get something working.

2. The API has changed a lot

   • LangChain has evolved quickly, and older examples/tutorials may no longer match current best practices.
   • This makes it harder to learn from docs or Stack Overflow snippets.

3. “Simple” agents are not actually that simple in LangChain

   • If your agent needs tool use, state, routing, or multi-step reasoning, LangChain exposes those concepts directly.
   • That’s useful for advanced use cases, but overkill if you just want “ask a question, maybe call one tool, answer.”

4. Framework-first design

   • LangChain often wants you to build inside its structure rather than just write straightforward Python code.
   • So instead of a few lines of custom logic, you may need to fit your app into its patterns.

5. Agents are inherently flaky

   • Even outside LangChain, tool-using LLM agents are tricky: prompting, tool schemas, error handling, retries, and stopping conditions all matter.
   • LangChain can make this more visible, which feels like extra complexity.

What to do instead

If your use case is simple, you may be better off with:

• Direct OpenAI/Anthropic API calls
• A small amount of custom Python around tool calling
• Lightweight libraries like:
  • PydanticAI
  • Instructor
  • smolagents
  • OpenAI Agents SDK
  • LlamaIndex for retrieval-heavy apps

When LangChain makes sense

LangChain is more worth it if you need:

• multiple tools and tool routing
• RAG pipelines
• modular reusable components
• integrations with many vector stores, loaders, and model providers
• complex workflows that will grow over time

Practical rule of thumb

• One agent, one or two tools, simple control flow: don’t reach for LangChain first.
• A bigger system with retrieval, orchestration, and many integrations: LangChain can pay off.

If you want, I can also show you:

1. a minimal agent in plain Python, and
2. the equivalent in LangChain,
   so you can compare the complexity directly.