Skip to content

LangChain Deep Agents or Argentic: what each does when a run outgrows the window

Deep Agents offloads big tool results to files and summarizes old history. Argentic rebuilds each prompt from a record of the run. How they differ, where Deep Agents is ahead of us, and what we have and haven't measured.

Neil Luo ·

We read LangChain's documentation for Deep Agents on 16 November 2026 and have not run it. Each Argentic number says which engine it was measured on, and none of them is a head-to-head against Deep Agents.

Deep Agents is LangChain's agent harness for long-running, multi-step work. It is open source and it comes from the team behind LangChain and LangGraph. We build Argentic, so keep that in mind as you read. This post is about one question: what each one does when a run grows past what the model can read at once.

What Deep Agents does

It handles a full window in three steps, all on by default. A tool result over 20,000 tokens is written to the agent's virtual filesystem and replaced in the prompt by a file path and the first 10 lines. When the prompt crosses 85% of the model's window, large file-write and edit calls from earlier in the session are replaced by a pointer to the file. If that still isn't enough, a model writes a summary, the summary replaces the older history, and the newest 10% of tokens stays in full.

Two things in that design are worth saying plainly. First, the originals are kept: a text rendering of the full conversation is written to the filesystem as a record, and the stored message history is not altered. Second, LangChain says what the cost is. Their own post says a detail that was summarized away is "not present in the active context" and "must be recovered via filesystem search", and it calls an agent that loses track of the user's intent after summarization the most insidious failure. The post reports no benchmark scores for these steps that we could find.

So with Deep Agents, whether an old detail comes back depends on the agent deciding to go and look for it.

What Argentic does instead

Argentic keeps a record of every step the agent takes and builds each prompt from that record, under a fixed size cap. The engine does not carry the history forward and trim it. At each rebuild it chooses from the record what goes back into the prompt, and the agent can search the whole record for an older detail.

In our 12-hour run (engine 0.48.1) prompts stayed at or under about 40,000 tokens: the median was about 22,000, 8 of 952 calls went a little over, and the largest was 43,431.

That is a different bet from Deep Agents, not a free win. Rebuilding changes the prompt, so a rebuild can cost cache hits. On our 900-event shop shift (engine 0.63.0, Claude Haiku 5.5, one run, events back to back, a local Postgres) 98.2% of prompt tokens were read from cache over 951 model calls, and the 13 rebuilds in that run took about 5% of the spend. That run had no idle gaps. An agent that waits longer between calls than the provider keeps its cache (five minutes by default on Anthropic) pays to write its prompt again at each wake.

Side by side

Each column is one product and each row is one question. Every Deep Agents cell links to the page it was read from.

Argentic next to LangChain Deep Agents
QuestionArgenticusLangChain Deep Agentsopen source SDK, also on LangSmith
Built forA hosted engine for agents that run for hours. It comes with its own loop and memory. our pageAn open source agent harness for complex, multi-step, long-running work. It adds planning, a virtual filesystem, subagents and long-term memory on top of LangChain and LangGraph. LangChain docs, GitHub
Who owns the loopArgentic ships the loop. You send it a message and declare your tools. our pageThe harness supplies the loop, and you can change it: it is a library you run, with middleware you can add or replace. LangChain docs, LangChain docs 2
Context that outgrows the windowThe prompt is rebuilt from a record of the run every turn, so its size stays capped as a run gets long. In the 12-hour run (engine 0.48.1) prompts stayed at or under about 40,000 tokens: the median was about 22,000 and the largest 43,431. our pageThree steps, all on by default. A tool result over 20,000 tokens is written to the filesystem and replaced by a path and its first 10 lines. At 85% of the model's window, large file-write and edit calls from earlier in the session are replaced by a pointer. If that is not enough, a model-written summary replaces the older history and the newest 10% of tokens stays in full. LangChain docs
After the old history is cutThe record of every step is kept as it happened and is not summarized. The agent can search the whole of it for an old detail. We have not measured that search against Deep Agents' filesystem search. our pageA text rendering of the original messages is saved to the filesystem as a record. A detail that was summarized away is not in the prompt; the docs say it "must be recovered via filesystem search". The stored message history itself is not altered. LangChain docs, LangChain
Memory and stateThe engine keeps a record of every step. The agent chooses what to remember with built-in tools such as decide and recall. our pageMemory is AGENTS.md files that are always loaded and that the agent can update. Scratch files are scoped to a thread unless you route a path such as /memories/ to a store. LangChain docs, LangChain docs 2
Prompt cachingOn our 900-event shop shift (engine 0.63.0, Claude Haiku 5.5, one run, events back to back, local Postgres), 98.2% of prompt tokens were read from cache over 951 model calls, with 13 rebuilds in the run. Static sections of the system prompt are cache-eligible on Anthropic and Amazon Bedrock models. The docs give no hit rate. LangChain docs
If the process diesEvery wake is recorded before it runs, and a cut-off wake can be finished with a resume. A tool call cut off before its result was saved is requested once more, so an action can repeat. We do not claim exactly once. our pageBuilt on LangGraph, which checkpoints state at each step, so a run stopped by a failure or a pause resumes from its last recorded state. On LangSmith, the Agent Server also runs cron jobs. LangChain docs, LangChain
Where it runsHosted by us, with a TypeScript client and a Python one. our pageTwo ways. You run the open source SDK in your own process or container, or LangSmith runs it: managed Deep Agents, or your own Agent Server in LangChain's cloud, in yours, or self-hosted. LangChain docs, LangChain docs 2
Open sourceThe engine is closed source. our pageMIT licensed. LangSmith, which hosts and traces it, is a commercial product with a free tier. GitHub, LangChain
ModelsYour own. You send your provider key with each call; it is not stored. our pageAny LangChain chat model that supports tool calling, including OpenAI, Anthropic, Google and open-weight models through providers such as Fireworks and Ollama. LangChain docs
PricingPrototype is free. During the beta it has no meter; from December 16 it includes 1,000 agent calls a month. Production is $20 a month per organization with 20,000 agent calls included and higher limits. It is paid by card at signup, with no free trial. The first 10 organizations get Production at $15 a month, kept for as long as they stay on it. Past what is included it is $1 per 1,000 agent calls. The model's tokens are billed by your own model provider, never by Argentic. our pageThe SDK is free; you pay for model tokens. LangSmith has a free Developer plan and Plus at $39 per seat a month, and its Agent Server is billed on the compute and database it uses. We found no separate price for managed Deep Agents. LangChain

Deep Agents on LangSmith is also a hosted option. If your question is "can I get this run for me, in the cloud", the answer is yes with either one. The difference we care about is the one in the third and fourth rows.

Where Deep Agents is ahead of us

  • Open source. It is MIT licensed. You can read the loop, change it, and run it on your own machines. Our engine is closed and hosted.
  • More in the box. Planning, subagents, skills, human approval on tool calls, and code execution in sandboxes from several providers. We don't ship a sandbox or a subagent system. We ship an engine that runs the agent.
  • Your own loop. Argentic ships its own loop and memory as one piece. If you have a tuned loop you want to keep, Deep Agents is built for that, and we don't offer it today.
  • A larger ecosystem. It sits on LangChain and LangGraph, with LangSmith for traces and evals. Argentic's beta opened on 21 October 2026, and our longest test is one 12-hour run on one model.
  • Any LangChain chat model that supports tool calling. We take the model you point us at through an OpenAI-compatible endpoint or Anthropic's, which covers most but not every option.

What we've measured, and what it doesn't tell you

  • Time per turn as the journal grows. On a synthetic journal, with no model calls, the engine's own time per turn at the median was 28 ms with 10,000 events and 32 ms with 1,000,000 (engine 0.78.0, one agent, one laptop-class Postgres, warm cache, 10 measured wakes). The 95th percentile was 82 ms at a million. It leaves out the model, the network, a cold database and many agents on one database. We have not measured how Deep Agents behaves as its state grows.
  • Summarizing against rebuilding, on a summarizer we wrote. On 60 LongMemEval_M questions with histories of about 1.2 million tokens and one free model, a loop that rewrote its own notes got 17 right and the engine got 38 (October 2026, older engine builds, not rerun). That summarizer is ours, not Deep Agents'. Theirs also saves the original to disk, which ours did not, so this test says nothing about how theirs would score. The post has the method.
  • Cost. We have not compared the cost of a run on either. It depends on how many model calls the run makes.

We have never run one agent on Argentic and on Deep Agents. We make no claim that Argentic is better, only that the two handle the end of the window in different ways, and the table says how.

Which to pick

Pick Deep Agents if you want to own and read the harness, you need sandboxes or subagents, or you already build on LangChain. It is a good tool, and it is free to start.

Look at Argentic if the agent is long-lived, a run will outgrow the window, and you would rather the engine decide what the model reads each time than rely on the agent to search for what was cut. You can find out where you stand without either of us: measure how your prompt grows over a real session.

If a cell is wrong

These pages change, and we read them once. If we got something wrong about Deep Agents, tell us at hi@getargentic.com and we will correct it. Anyone may benchmark Argentic against it using the setup we publish. For the other tools people compare us with, see where Argentic fits.

Sources and method: 11 hours 59 minutes on shift: what the agent remembered.

More posts.

  1. Does a growing transcript hurt a long agent run? Our early test, and the part we retracted

    An early September test of rebuilding the prompt at each task boundary against a growing transcript. The study reports it found more in all three cells, by less than we first claimed, and the claim that a growing context makes an agent worse did not survive our own re-test.

  2. Why an agent juggling many tasks loses track of what's done, pending and blocked

    Six reasons one agent working through many tasks reopens finished ones, forgets blocked ones and reports done too early, what fixes each, and the one underneath. We have no orchestration benchmark yet, and the post says so.

  3. Why an agent's own memory skips things

    Six reasons notes an agent writes for itself leave out the one detail that mattered, what to do about each, and the one underneath. On our shop shift, 22 of 28 stock answers were right with the engine keeping the counts and 4 of 28 with the model writing them. One run each.

  4. Why your agent forgets things after compaction

    Six reasons an agent loses details when its context is summarized and restarted, what you can do about each, and the one underneath. Includes our one-run shop-shift numbers and what they don't show.

  5. Why long-running agents lose track of counts

    Six reasons an agent's running totals drift, what to do about each, and the one underneath. On our own 900-event shop shift, 22 of 28 stock questions were right with the engine keeping the counts and 4 of 28 without. One run each, and six answers were still wrong.

  6. Why your agent repeats an action it already took

    Six causes of a repeated refund or email, from a missing stop condition to a record the agent lost, what fixes each, and the one underneath most of them. Our November rerun had no refund applied twice, with a key on the tool in both runs.

  7. Where Argentic fits next to the agent SDKs and the tools around them

    A table-by-table read of the Claude, OpenAI and Amazon agent SDKs, then Mem0, Zep, LangGraph and Letta, from their own docs, with where each is ahead of us.

  8. A plain transcript loop or an engine like ours: when each is the right call

    What the plain loop does well, where it runs out, and what the engine costs you.

  9. Why your agent forgets things from a long history

    On Gemma 4 31B, with histories of about 1.2 million tokens, a loop that keeps only about the newest 100,000 tokens got 5 of 60 right and the engine got 38. What we ran and what it doesn't show.

  10. Does summarizing old context lose details? We measured it

    On Gemma 4 31B, with histories of about 1.2 million tokens, our own note-rewriting loop got 17 of 60 and the engine got 38 of 60. Most of the loop's misses were answers saying the detail wasn't in its notes (29 of 43).

  11. Resuming an agent after a crash without repeating a finished action

    We killed a real server mid-run with SIGKILL and finished the work from another process. What was not repeated, and the one case that is.

  12. Checking what your agent was shown on each turn

    Replay re-checks every prompt against what was recorded: 1,754 of 1,754 turns matched. It checks the prompt side only.

  13. Run your first agent

    Sign in to the Argentic dashboard, make an API key and run an agent that remembers. What you get, what we've measured and what isn't there yet.

  14. Undoing what a bad source caused, from the record alone

    When a source was flagged after the run, the engine undid what it could have caused, using undo functions the host supplies, and finished without it, in 156 of 156 runs: 120 scripted, and 36 live Haiku 5.5 runs, 24 of them with the compromise forced. The live runs were rerun after an engine fix; the first 12 had 2 worlds missing benign effects.

  15. Why we rebuild an agent's context instead of appending to it

    What rebuilding context from a record changes, in plain terms, and the limits of what we have measured so far.