Architecture review
You have a design or an implementation and want a second opinion before committing quarters of work. Report with findings, risks and concrete recommendations.
3–5 days
LangChain and LangGraph
LangChain and LangGraph, from proof of concept to production
The frameworks are not the problem. The problem is what happens when the flow holds state, fails halfway through, and someone has to understand why. That is what LangGraph solves and what we know how to operate.
Technical capabilities
LangGraphLangChainLangSmithDurable stateHuman-in-the-loopReplayCheckpointing
3 yearsbuilding on LangChain in production
2M+users served by systems built with these tools
3–5days for an architecture review
Key takeaways
- LangChain composes and LangGraph sustains: the first connects models to data and tools; the second models the flow as a graph with durable state.
- Durable state allows pausing for human approval, retrying a single step without repeating earlier ones, surviving restarts, and replaying a full run for debugging.
- In an audit Quarl reviews the graph, checkpointing, human interrupt points, step and cost limits, tool failure handling, observability with LangSmith, and evaluation.
- Not everything needs a framework: for a linear flow of a few steps with no state and no approvals, direct code is simpler to maintain — and Quarl says so when that applies.
Operating track record
FEMSA loyalty platform
Three years operating the system in production — not one delivery and an exit.
Cross-entity contamination
The most frequent failure in RAG architectures, solved with structured metadata at ingestion.
Fixed scope and date
The proposal arrives within 48 hours with fixed scope, price and date. If scope changes, it is quoted separately and approved first.
What they are
One composes, the other sustains
LangChain is the framework for composing applications on language models: connecting the model to data sources, tools, memory and reasoning chains. It solves building very well.
LangGraph solves what comes after. It models the flow as a graph with durable state: the process can pause waiting for a person’s approval, retry a single step without repeating the previous ones, survive a restart, and replay in full for debugging. It is the difference between a flow that works and one you can operate.
That is why most of what we put into production with agents runs on LangGraph, with LangChain covering the composition pieces.
Services
How we can come in
Custom development
We build the system: graph, tools, guardrails, state persistence, evaluation and observability with LangSmith.
Audit of an existing project
When the system is built but fails, costs too much, or nobody understands why it makes the decisions it makes.
1–2 weeks
Embedded team
We join your team, your process and your repository for a few months, and leave capability behind in your people.
What we check in an audit
Where these systems break
- State and checkpointing. If the process does not persist, any failure forces a full redo — and in flows with already-executed actions, that duplicates work or charges.
- Human interrupt points. Which actions should require approval and do not.
- Step, time and cost limits. A graph without a ceiling loops. It is the error that burns the most budget.
- Tool failure handling. What happens when the API the agent calls returns an error or takes too long.
- Observability. Without step-level traces, debugging is guesswork. LangSmith configured properly changes this completely.
- Evaluation. A set of cases with expected outcomes running in continuous integration. Without it every change is a bet.
An honest opinion about frameworks
Not everything needs LangGraph. For a linear three-step flow with no state and no approvals, a well-written function with direct model calls is simpler to maintain and easier to debug.
We will tell you when the framework is overkill. Adding a heavy abstraction where none is needed is the most common way to turn a simple project into an expensive one.
Stack
Around the framework
LangGraphLangChainLangSmithModel Context ProtocolPydanticFastAPINestJSPostgreSQLRedisOpenAIAnthropic ClaudeAzure OpenAIDockerGitHub Actions
Related services
AI agents
LangGraph orchestration, durable state and human approval on steps with consequences.
View serviceLanguage models
LLM applications with structured output and tool calling.
View serviceRAG systems
Chunking, reranking and hybrid search, evaluated with recall@k and NDCG.
View serviceAI consulting
Architecture, evaluation criteria and cost per query before writing code.
View serviceFrequently asked questions
What is the difference between LangChain and LangGraph?
LangChain is for composing: it connects models to data, tools and memory. LangGraph is for operating: it models the flow as a graph with durable state, with the ability to pause for human approval, retry a step without repeating earlier ones, survive restarts and replay a full run for debugging. LangChain helps you build it; LangGraph lets you sustain it.
Do we need a framework at all?
Not always, and we say so when you do not. For a linear flow of a few steps, with no state and no approvals, direct code is simpler to maintain. The framework starts paying off with branching, state that survives restarts, human approvals, partial retries, or the need to replay runs. Adding the abstraction before you need it makes the project more expensive for nothing.
Will you work on a project we already started?
Yes, and it is a significant part of what we do. The audit reviews the graph, state handling, guardrails, cost limits, failure handling and observability, and delivers findings ranked by impact with the fix for each. We can execute those fixes or leave them documented for your team.
Can you train our team?
Yes. In the embedded team format we work inside your repository and your process, pairing with your people, with the explicit goal of leaving capability behind. It is slower than doing it externally and handing over, and over the medium term it is far cheaper for you.
What is durable state and why does it matter so much?
It means the flow records where it is, so a restart, a network failure or a wait for approval does not force starting over. It matters because in a flow that already executed actions — sent an email, charged a card, created a record — restarting is not just slow: it duplicates real-world effects. It is the main reason LangGraph exists.
Do you use LangSmith?
Yes, for tracing and evaluation. It lets you see every step of a run with its inputs and outputs, compare configurations and run evaluation sets systematically. When a client prefers not to depend on an external service, we build equivalent tracing on Datadog or in-house tooling.
What about alternative frameworks?
We know CrewAI, AutoGen and the lighter alternatives, and in some cases they are the right call. Our criterion is which one operates better in production: state, debugging, cost control and ecosystem maturity. Today LangGraph wins in most enterprise cases, but it is not an ideological position.
Which language do you work in?
Python and TypeScript, depending on what your team uses. LangChain and LangGraph have implementations in both, and we pick the one that lets your people maintain the system, not the one we find more comfortable.
Book 15 minutes
Tell us what you are building, or what stopped working. You leave the call with a concrete answer: it can be fixed, it can be built, or it isn't worth it.