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.
| Question | Argenticus | LangChain Deep Agentsopen source SDK, also on LangSmith |
|---|---|---|
| Built for | A hosted engine for agents that run for hours. It comes with its own loop and memory. our page | An 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 loop | Argentic ships the loop. You send it a message and declare your tools. our page | The 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 window | The 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 page | Three 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 cut | The 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 page | A 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 state | The engine keeps a record of every step. The agent chooses what to remember with built-in tools such as decide and recall. our page | Memory 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 caching | On 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 dies | Every 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 page | Built 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 runs | Hosted by us, with a TypeScript client and a Python one. our page | Two 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 source | The engine is closed source. our page | MIT licensed. LangSmith, which hosts and traces it, is a commercial product with a free tier. GitHub, LangChain |
| Models | Your own. You send your provider key with each call; it is not stored. our page | Any LangChain chat model that supports tool calling, including OpenAI, Anthropic, Google and open-weight models through providers such as Fireworks and Ollama. LangChain docs |
| Pricing | Prototype 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 page | The 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.