One engine for agents that run for hours. The agent loop, its memory and a journal of every step come as one piece. The prompt stays near its cap however long the run goes, and every run leaves a record you can check. This post says where that sits next to the other things people reach for. We wrote it from one side, from each vendor's own documentation and repository as they stood on 1 November 2026. We have never run the same agent on all of them, and the tables are what the docs say, not what we measured.
Two kinds of neighbour
Some tools do the same job we do: they run the agent loop for you. The Claude Agent SDK, the OpenAI Agents SDK and Amazon's Strands and AgentCore are the ones we look at here. Other tools do a different job that touches ours. Temporal, Restate and DBOS keep code alive through a crash. Mem0 and Zep keep facts for an agent to read. LangGraph and Letta are frameworks with their own ideas about state.
For the first group the question is which one should run your loop. For the second it is what the tool was designed for and whether you need it next to, or instead of, us. We don't keep a score, because a tool built for a different job doesn't lose to us by doing something else.
The ones that run the loop for you
Each column is one product and each row is one question. Every cell links to the page it was read from.
| Question | Argenticus | Claude Agent SDKAnthropic | OpenAI Agents SDKOpenAI | Strands and AgentCoreAmazon |
|---|---|---|---|---|
| Built for | A hosted runtime for agents that run for hours. It comes with its own loop, journal and memory. our page | Putting the agent behind Claude Code, with its tools, loop and context management, inside your own app in Python or TypeScript. Claude docs | A lightweight framework for building multi-agent workflows. GitHub | Three pieces. Strands Agents is an open-source SDK for building agents. AgentCore Runtime hosts agents or tools. AgentCore Memory is a managed memory service. GitHub, AWS docs, AWS docs 2 |
| Who owns the loop | Argentic ships the loop. You send it a message and declare your tools. our page | The SDK runs the loop. It runs as a subprocess the SDK starts and supervises. Claude docs, Claude docs 2 | The SDK's Runner runs the loop: it runs the tool calls, adds the results and goes round again. OpenAI docs | Strands runs the loop. AgentCore Runtime hosts a loop you bring. Strands docs, AWS docs |
| Context that outgrows the window | The prompt is rebuilt from the journal every turn and rebuilt at checkpoints, so its size stays capped as a run gets long. In the 12-hour run the median prompt was about 22,000 tokens and the largest 43,431. our page | Automatic compaction summarizes older history as the window fills. The docs warn that instructions from early in the conversation may not survive it. Claude docs | A session can limit how many recent items it retrieves, prune history through a callback you write, or compact stored history with the Responses API. OpenAI docs | Strands has conversation managers: a sliding window by default, or one that summarizes older messages. Strands docs |
| Memory and state | Every step goes into a journal in a database. The agent chooses what to remember with built-in tools such as decide and recall. our page | Sessions are saved as files on the machine that ran them by default. A SessionStore adapter can mirror the transcript to your own storage. Sessions keep the conversation, not the filesystem. Claude docs, Claude docs 2 | Sessions keep history in a backend such as SQLite, Redis, SQLAlchemy or OpenAI's Conversations API. The runner adds the new items after each run. OpenAI docs | Strands keeps conversation history and key-value agent state, and session managers save them to files or S3. AgentCore Memory keeps short-term events and long-term records that an LLM extracts. Strands docs, Strands docs 2, AWS docs |
| A fact that changed | The agent can replace an earlier decision with a supersede tool. It does not invalidate facts the way Zep does: in the 12-hour run an old price was quoted after it changed, twice, and that is an open issue. our page | No way to replace or retire a changed fact is documented for the SDK. Claude docs | No way to replace or retire a changed fact is documented. A session can drop its latest item or be cleared. OpenAI docs | AgentCore Memory consolidates new information into a new or an existing record. We found no explicit rule for replacing a changed fact, and none in Strands. AWS 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 | You can resume from a saved session ID if the session file is on the same machine or in a SessionStore. The run does not restart by itself. Claude docs, Claude docs 2 | Nothing built in. The Python docs point to Temporal, Dapr, Restate and DBOS integrations for runs that outlive a process. OpenAI docs | A Strands session manager restores saved state after a restart. A stopped AgentCore session resumes on new compute. In-memory state is lost, and files persist only if session storage is set up. Strands docs, AWS docs |
| Where it runs | Hosted by us, with a TypeScript client and a Python one. our page | A library you run yourself. Anthropic's Managed Agents, in beta, is a separate service that runs the harness in Anthropic's managed infrastructure. Claude docs, Claude API docs | A library that runs inside your application. OpenAI also offers a separate, OpenAI-managed Agents API. OpenAI docs, OpenAI docs 2 | Strands runs inside your own process. AgentCore is managed by AWS. Strands docs, AWS docs |
| Open source | The engine is closed source. our page | The code is in a public repository. The README says use of the SDK is governed by Anthropic's Commercial Terms of Service, while GitHub's page also shows an MIT licence label. GitHub | MIT licensed, in public Python and TypeScript repositories. GitHub, GitHub 2 | Strands is Apache 2.0 according to its README. AgentCore is a managed service. GitHub |
| Models | Your own. You send your provider key with each call; it is not stored. our page | Claude models, through the Anthropic API or through Amazon Bedrock, Claude Platform on AWS, Google Cloud or Microsoft Foundry. Claude docs | Any, with OpenAI's Responses API as the default. Other providers go through Chat Completions endpoints or adapters. OpenAI docs | Any provider. Strands defaults to Amazon Bedrock, and AgentCore Runtime works with any model. Strands docs, AWS docs |
| Pricing | Free until December 16 while it is in beta. After that, $1 per 1,000 agent calls, with a free Prototype plan (1,000 calls a month) and Production at $20 a month (20,000 calls). Your model provider bills you directly. our page | The docs state no charge for the SDK; you pay for model tokens. Managed Agents adds $0.08 per session-hour on top of tokens. Claude API docs | OpenAI's pricing page lists no charge for the SDK; model tokens bill at the model's rates. OpenAI docs | No charge is stated for Strands. AgentCore is consumption-priced, with separate charges for Runtime and for Memory; AWS's page lists price changes dated October 2026. AWS |
The context row is where we differ most. When a history outgrows the window, the Claude SDK compacts it, the OpenAI SDK can trim or compact it, and Strands can slide a window over it or summarize. All three work on the transcript that already exists. Argentic builds each prompt again from the journal instead, so the engine chooses what the model reads each time. We tested one version of the first approach against ours: on 60 LongMemEval_M questions, with one free model, a loop that rewrote its own notes got 17 right and the engine got 38 (the post). That loop was ours, not any of these SDKs, and it is one model, so read it as a direction and not a ranking.
Where they are ahead. The code for all three is in public repositories, and the OpenAI and Strands ones carry MIT and Apache 2.0 licences. If you want to read the loop, change it, or run it on your own machines, any of them suits you better than we do. We are hosted and the engine is closed. The OpenAI SDK works with other providers' models, and the Claude SDK works with Claude models. We take the model you point us at.
On crashes. The docs for the three SDKs describe resuming a saved session or restoring saved state. We found no description of finishing a call that was cut off partway through, and the OpenAI docs send you to Temporal, Dapr, Restate or DBOS for that. We do finish it, and we can't promise it runs once: a tool call cut off before its result was saved is asked for again.
Tools built for a different job
Keeping code alive
| Question | Argenticus | Temporal | Restate | DBOS |
|---|---|---|---|---|
| Built for | A hosted runtime for agents that run for hours. It comes with its own loop, journal and memory. our page | Durable execution of application code. Temporal docs | A lightweight runtime that turns AI agents, workflows and backend services into durable processes. Restate docs | A library for building reliable programs, with durable workflows on Postgres. DBOS docs |
| Who owns the loop | Argentic ships the loop. You send it a message and declare your tools. our page | You write it, inside a Workflow. With its OpenAI Agents SDK integration, model calls run as Activities. Temporal docs | You write it with any SDK and wrap model calls in ctx.run() to make them durable. Restate docs | You write it. You mark the loop as a workflow and each model or tool call as a step. DBOS docs |
| Context that outgrows the window | The prompt is rebuilt from the journal every turn and rebuilt at checkpoints, so its size stays capped as a run gets long. In the 12-hour run the median prompt was about 22,000 tokens and the largest 43,431. our page | Not a model-context feature. Continue-As-New keeps a Workflow under the Event History limit, and an execution is terminated past 51,200 events. Temporal docs | Not documented in the pages we read. Restate docs | Not documented in the pages we read. DBOS docs |
| Memory and state | Every step goes into a journal in a database. The agent chooses what to remember with built-in tools such as decide and recall. our page | A Workflow's state is recorded in an Event History that the Temporal Service stores. Agent memory is yours to bring. Temporal docs | Key-value state in Virtual Objects, which your handler code reads and writes. One writing handler runs at a time per key. Restate docs | The library writes workflow and step checkpoints to a Postgres database. DBOS docs |
| A fact that changed | The agent can replace an earlier decision with a supersede tool. It does not invalidate facts the way Zep does: in the 12-hour run an old price was quoted after it changed, twice, and that is an open issue. our page | Not its job. Temporal docs | Not its job. Your code overwrites state with ctx.set. Restate docs | Not its job. DBOS 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 | A Workflow resumes from its Event History. Activities may run more than once, so the docs recommend making them idempotent. Temporal docs | Each step is recorded in a journal and the agent picks up from it after a crash. Restate docs | An interrupted workflow resumes from its last checkpoint. Steps run at least once, so the docs say to make them idempotent. DBOS docs, DBOS docs 2 |
| Where it runs | Hosted by us, with a TypeScript client and a Python one. our page | Self-host it, or use Temporal Cloud. Temporal docs, Temporal docs 2 | Restate Cloud, bring-your-own-cloud, or self-hosted. Restate docs | The library runs in your app against your Postgres. DBOS also sells a hosted cloud and a Conductor control plane. DBOS, DBOS docs |
| Open source | The engine is closed source. our page | The server is MIT licensed. Temporal Cloud is the paid service. GitHub | The server uses the Business Source License 1.1. Its change license is Apache 2.0, four years after a version is released. GitHub | The Transact library is MIT licensed. GitHub |
| Pricing | Free until December 16 while it is in beta. After that, $1 per 1,000 agent calls, with a free Prototype plan (1,000 calls a month) and Production at $20 a month (20,000 calls). Your model provider bills you directly. our page | Temporal Cloud starts at $50 per million actions, with volume discounts down to $25. Temporal | Usage-based, on durable actions. The free plan includes 100,000 durable actions a month. Restate | The library is free. The Pro plan is $99 a month with 1 million checkpoints included, and DBOS Cloud is priced through sales. DBOS |
These three make a program survive a crash by recording its steps and replaying them. You write the agent loop, and they keep it running. Choosing what goes into the prompt isn't something their docs set out to do. That's a reasonable division: they work for any program, and an agent is one kind. We wrote a longer comparison with Temporal. If you already run one of them, or your agent is one piece of a larger workflow, use it. We haven't tried running Argentic inside one.
Keeping facts, or a framework around them
| Question | Argenticus | Mem0 | Zep and Graphiti | LangGraph | Letta |
|---|---|---|---|---|---|
| Built for | A hosted runtime for agents that run for hours. It comes with its own loop, journal and memory. our page | Long-term memory for AI agents that persists across sessions. Mem0 docs | Zep is a context layer that builds temporal context graphs from business data and conversations. Graphiti is the open-source framework inside it. Zep docs, GitHub | A low-level orchestration framework for long-running, stateful agents. GitHub | A platform for building stateful agents. Letta docs |
| Who owns the loop | Argentic ships the loop. You send it a message and declare your tools. our page | It runs no loop. Your code calls add and search. Mem0 docs | It runs no loop. You add messages and fetch a Context Block to put in your prompt. Zep docs | You define the graph of nodes and edges, and LangGraph runs it. LangChain has prebuilt agent loops on top. LangChain docs | Letta Code is a stateful agent harness, so Letta supplies the loop. GitHub |
| Context that outgrows the window | The prompt is rebuilt from the journal every turn and rebuilt at checkpoints, so its size stays capped as a run gets long. In the 12-hour run the median prompt was about 22,000 tokens and the largest 43,431. our page | Not documented as a way to handle a full window. It stores extracted facts and returns the relevant ones when you search. GitHub | The Context Block is built from the graph and the four most recent thread messages. You still send recent messages to the model yourself. Zep docs | The docs show how to trim, delete and summarize messages. You build that into your graph. LangChain docs | Its older docs describe compaction: older messages are summarized to make room. The current docs say less about it. Letta docs, Letta docs 2 |
| Memory and state | Every step goes into a journal in a database. The agent chooses what to remember with built-in tools such as decide and recall. our page | When your code calls add, an LLM pulls key facts out of the messages and Mem0 stores them. Mem0 docs | Zep ingests the messages you add into the user's context graph. Zep docs | Checkpointers save a thread's graph state, and a Store keeps long-term data across threads. Your graph code writes both. LangChain docs | Memory is Markdown files in a git repository that the agent edits. Older versions used memory blocks in the context window. Letta docs |
| A fact that changed | The agent can replace an earlier decision with a supersede tool. It does not invalidate facts the way Zep does: in the 12-hour run an old price was quoted after it changed, twice, and that is an open issue. our page | Add only adds: new memories are added without overwriting or deleting existing ones. Changing a memory is a separate update or delete call. Mem0 docs, Mem0 docs 2 | Zep checks new data against the graph and may invalidate earlier facts. Each fact carries valid-at and invalid-at times. Graphiti's README says old facts are invalidated, not deleted. Zep docs, GitHub | Not its job. Your nodes overwrite or delete state. LangChain docs | The agent edits its own memory files. The docs we read do not say how an outdated fact is handled. Letta docs, Letta docs 2 |
| 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 | Not applicable; it is not a runtime. Mem0 docs | Not applicable; it is not a runtime. Zep docs | It restarts from the last saved checkpoint. In some durability modes the docs say a crash can lose recent checkpoints. LangChain docs | Agent state and memory persist beyond a connection. The SDK does not replay events missed while disconnected. Letta docs |
| Where it runs | Hosted by us, with a TypeScript client and a Python one. our page | The hosted Mem0 Platform, or open source that you run yourself. Mem0 docs | Zep Cloud, or inside your own VPC on Enterprise. Graphiti is self-hosted only. Zep, GitHub | The library runs anywhere. LangSmith Deployment can run in LangChain's cloud, in your cloud, or on your own infrastructure. LangChain docs | Letta Cloud, or run it yourself. Letta docs |
| Open source | The engine is closed source. our page | Apache 2.0. Some features, such as graph memory, are on the Platform only. GitHub, Mem0 docs | Graphiti is Apache 2.0. The Zep platform is not offered as open source in its current docs. GitHub | LangGraph is MIT licensed. LangSmith is a paid product. GitHub | Apache 2.0. GitHub |
| Pricing | Free until December 16 while it is in beta. After that, $1 per 1,000 agent calls, with a free Prototype plan (1,000 calls a month) and Production at $20 a month (20,000 calls). Your model provider bills you directly. our page | A free plan, then a custom plan you contact Mem0 for. Mem0 | Zep has a free plan with 10,000 credits a month, then Flex at $125 a month. Graphiti needs your own graph database and model. Zep, GitHub | LangSmith has a free Developer plan and Plus at $39 per seat a month. LangChain | A free plan, Pro at $20 a month, and an API plan at $20 a month plus $0.10 per active agent a month. Letta docs |
Mem0 and Zep are memory layers. They don't run your agent; they hold what it learned and hand it back. LangGraph is a framework for the graph your agent runs on, and Letta is a platform where the agent edits its own memory. Letta's docs were changing while we read them, with an older set marked legacy, so check which one you are looking at.
Zep handles a changed fact better than we do today. Its graph records when a fact became true and when it stopped being true, and keeps both. Ours has a supersede tool the agent can call, and in the 12-hour run it still quoted an old price after the price changed, twice. That is an open issue. If the thing you need most is a trustworthy record of what was true when, look at Zep and Graphiti first.
Where we are behind
- Maturity. Argentic's beta opened on 21 October 2026. Our longest test is one 12-hour run on one model, and the known issues page lists what it got wrong, including running counts that drift across rebuilds. Most of the others were public well before then, and we have no figures on how many people use any of them.
- Closed and hosted only. If you need to self-host, read the code, or hand a security team a licence they know, we aren't the answer yet.
- No head-to-head. We haven't run one agent on Argentic and on any of these. We make no claim that Argentic is better than any of them.
- Price. We have not compared cost with any of them. What a real run costs depends on how many model calls it makes, and we have measured that only on benchmarks and one simulated shift.
Which to pick
Look at Argentic if the agent is the product, its history will outgrow the model's window, and you would rather be handed a loop that rebuilds its own prompt and a record you can check than write one. Use an SDK from the first table if you want a library you control. Use one of the tools in the last two tables if the job is the one it was built for. Several of these combine; we haven't tested any of the combinations with us.
If a cell is wrong
These pages change, and we read them once. If we got something wrong about your product, tell us at hi@getargentic.com and we will correct it. Anyone may benchmark Argentic against any of these using the setup we publish.
Sources and method: 11 hours 59 minutes on shift: what the agent remembered.