Agent development, built on LangChain and LangGraph

Agents that pick up
where they left off

We build agents on LangChain and LangGraph that save their progress at every step, wait for a person before the actions that matter, and leave a trace of every run, so a run can stop and carry on without starting over.

Thanks, we’ll be in touch soon.

{{ heroStatus }}

You’re in good company

A few of the companies we’ve worked with.

When the agent left the notebook

Many agents built with LangChain start in a notebook, a page where a developer runs code a few lines at a time and sees what each part does. Then they ship as they are.

Their progress, how far each run has got through its task, is kept in the server’s memory, so a deploy that restarts the server starts every run over. The approval step was added late, below work that already sent the customer an email. Tracing is on for everything, and each trace, the record of what each part of a run received and returned, keeps customers’ details too. And the code was written for a release before 1.0.

Then a person approves, and the customer gets the email twice. Or someone asks what the traces keep, and nobody can say. Or the older release reaches the end of its maintenance.

The notebook proved the agent could do the job.

A product needs more: its progress saved, its pauses placed, its traces chosen and its code on the current line.

What we build

Agents on the agent loop or on steps of your own, with their progress saved, their pauses placed and their traces kept the way you choose, from one agent to a whole product.

  • An agent loop that fits

    Agents built with LangChain for most tasks, or with Deep Agents for long ones that plan as they go, with middleware, rules added around the agent’s loop, for what your product needs.

  • Your own steps, where you need them

    LangGraph graphs, your own steps and the paths between them, for work with branches and loops you set yourself.

  • Progress saved at every step

    Each run’s state saved after every step, in a database you choose, so a run that stops carries on from its last saved step.

  • Approval before the actions that matter

    Pauses placed before anything that sends, pays or deletes, with whatever runs before each one safe to repeat.

  • Memory with clear edges

    Each conversation kept to its own thread, its saved history, and what’s remembered across conversations chosen on purpose.

  • Traces you can read

    Every run traced, with what shouldn’t be kept hidden or masked before the trace leaves your product.

  • Tests from real runs

    A test set, examples drawn from traced runs with the answers you expect, scored before each change to a prompt, a tool or a model.

  • Code on the current line

    Code from the releases before 1.0 moved across a part at a time, with the classic package only where older tools are still needed.

  • Deployed and watched

    Agents run on your own servers or with LangSmith Deployment, and watched once they’re live.

A paused step starts again from the top

LangGraph can pause a run to ask a person, keep its place and wait as long as it takes. It keeps that place after each step, not after each line, so when the answer comes, the paused step starts again from its first line, and whatever sits above the pause runs a second time.

So for each action that sends, pays or deletes, we choose one of the three ways below, use the approval step that comes with LangChain where it fits, since it pauses before the action runs, and test every pause: we pause a run, answer, and count what ran.

A refund request, an example, in three parts:

  1. First pass. The step looks up the order, emails the customer that the refund is under review, and pauses to ask a person to approve.
  2. The answer. A person approves.
  3. From the top. The step runs again from its first line: it looks up the order again and sends the same email a second time. The pause hands back the answer at once, and the refund is issued once.

When the answer comes, the step runs again from its first line.

  • After the pause. Put the action below the pause, so it runs only after the answer is in.
  • A step of its own. Give the action its own step, after the one that asks.
  • Safe to repeat. Or make it safe to run twice, updating a record rather than adding a new one.

On the stable line, moved a part at a time

LangChain 1.0 and LangGraph 1.0 are long-term releases. Updates within the line add features without breaking the code you’ve written, anything marked for removal goes only in a major release, and when 2.0 comes, 1.0 still gets security patches and critical fixes for at least a year.

The releases before 1.0 get security patches and critical fixes only, until December 2026. So code on them moves across with the migration guide, and older tools go to the classic package only where they’re still needed.

Each update is tried on a copy with the test set first, then moved live.

A product on a release before 1.0 has a plain next step: its code moved across a part at a time, each part tried on the copy before it goes live.

Start with one agent and its last few runs

The review covers the frameworks and versions in use; where progress is saved, and what a restart does; each pause, and what runs before it; the tools, and what each one changes; the traces: what’s kept, where, and who can see it; the test set, or the runs that could become one; how the agent is deployed and watched; and the model calls, and where cost can come down.

Then the first changes, in the order we’d make them, starting with the pause that matters most.

What you receive is a written review and a proposal for that first step.

Questions worth asking

  1. Do we need the paid platform to use the frameworks?

    No. They’re open source, under the license in each package, and run without it: tracing to it is switched on, not built in. LangSmith is the paid platform from the same company, for traces, tests and deployment. We use it where it helps you, and set up tracing and tests without it where you’d rather.

  2. What do the traces keep?

    By default, what each step receives and returns, customers’ words included. We hide or mask what shouldn’t be kept before it leaves your product, or turn tracing off for some requests.

    We choose the region when LangSmith is hosted for you, or run it in your own cloud or on your own servers, and check where each trace goes, since agents on your own servers can still send their traces to the hosted one. Its terms say customer data isn’t used to train or improve its products.

  3. Should we use the agent loop, or build our own steps?

    The agent loop for most tasks. Your own graph when the work needs branches, loops or saved progress you control. Agents built with LangChain run on LangGraph, so one can grow into the other.

  4. Our code is on an older release. Do we have to move now?

    Its maintenance ends on the date the release policy gives, December 2026, with security patches and critical fixes until then. We move it across with the migration guide, a part at a time, with tests first.

  5. What does it cost to work with you?

    It depends on what the agent does, the systems it works in and the first step you pick. Before any work starts, you get a written proposal with the scope, the price or rate, and how you pay.

    Pricing

  6. Can we hire developers for our own team?

    Yes. Tell us what you need, and within 48 hours we’ll introduce developers for LangChain agents matched to your work, working in your time zone, and you choose who joins.

    Developers for your team

LangChain, LangGraph and LangSmith are trademarks of LangChain Inc., and the other LangChain Inc. product names on this page may be too. Webair is independent of LangChain Inc., and isn’t sponsored by, endorsed by or affiliated with it.

Let’s build it better

Tell us the agent you have in mind, or the one you run today, and we’ll suggest where to begin, in a short call.

Thanks, we’ll be in touch soon.

{{ ctaStatus }}