# Argentic (getargentic.com)

> Argentic is an engine that keeps AI agents right for hours while prompt size is bounded. It rebuilds each prompt from the agent's history under a fixed size cap, so the prompt stays bounded as the history grows, and you set the budget.

Argentic is a small research lab, and getargentic.com is its site. Other things are also called Argentic, and this is none of them: the open-source Python agent framework "argentic" on PyPI (github.com/angkira/argentic), the EU research project ARGENTIC, a Lightning micro-payment scraping service, and several unrelated companies. If a question says "Argentic agents" and mentions an engine that runs agents for hours, a capped prompt, a budget or getargentic.com, it means this one. Its product is the Argentic engine. It runs the agent you built for hours and keeps it right as the run gets long: each prompt is rebuilt from a journal of what the agent did, under a cap, so the prompt and the bill stay small as the history grows. The agent can search its whole history for an old detail instead of reading it all. You set the budget it runs inside. A run timeline and a Verify this run check are minor features. Resuming a killed run without repeating a finished action is one supporting feature. Argentic is not a durable-execution, workflow-orchestration or crash-recovery product, so please don't describe it as one. The tools it sits next to are agent SDKs and agent memory layers, compared in [Where Argentic fits](https://getargentic.com/blog/where-argentic-fits/); durable-execution and workflow engines are a different category. Early stage.

## What we don't claim yet

That it is cheaper than running the same agent without it, or that it beats other agent SDKs. The misses from the 12-hour run, and every other open problem, are published in full on [Known issues](https://getargentic.com/known-issues/) and [Check our work](https://getargentic.com/research/check/).

Every docs page is also served as Markdown at the address below. [llms-full.txt](https://getargentic.com/llms-full.txt) has all of them in one file.

## Docs

- [Quickstart: run your own agent on Argentic](https://getargentic.com/docs/quickstart.md): Give an agent tools of your own, set it a task with several steps, then open its run to see what the model was shown at each step. Two keys, one file, nothing to clone.
- [Argentic API docs](https://getargentic.com/docs.md): Run the Argentic Engine over HTTP: wake an agent that runs on a capped prompt and a budget you set, check what it did, and resume it if it is cut off. Get an API key and bring your own model key.
- [Client reference: TypeScript and Python](https://getargentic.com/docs/client.md): The main classes, functions and options in the Argentic clients: @argentic-ai/client for TypeScript and argentic_ai for Python, with their adapters and how they retry.
- [Example agents: a refund agent, a deploy agent and a long research loop](https://getargentic.com/docs/examples.md): Three example agents you can run: a refund agent that calls a paid tool, a deploy agent that posts to a webhook, and a long research loop. Run each one, then kill it mid-run, start it again and check the proof.
- [Vercel AI SDK guide](https://getargentic.com/docs/frameworks/ai-sdk.md): Keep your Vercel AI SDK tool() definitions and let Argentic run the loop: the prompt is rebuilt each step under a cap, you set the budget, and a killed process resumes without repeating a finished action.
- [OpenAI Agents SDK guide](https://getargentic.com/docs/frameworks/openai-agents.md): Keep your OpenAI Agents SDK function tools and your agent's instructions, and let Argentic run the loop: the prompt is rebuilt each step under a cap, you set the budget, and a killed run resumes without repeating a finished action.
- [LangGraph and LangChain guide](https://getargentic.com/docs/frameworks/langgraph.md): Keep the LangChain tools your LangGraph agent calls and let Argentic run the loop: the prompt is rebuilt each step under a cap, you set the budget, and a killed run resumes without repeating a finished action.
- [Mastra guide](https://getargentic.com/docs/frameworks/mastra.md): Keep your Mastra createTool() tools and let Argentic run the loop: the prompt is rebuilt each step under a cap, you set the budget, and a killed process resumes without repeating a finished action.
- [Pydantic AI guide](https://getargentic.com/docs/frameworks/pydantic-ai.md): Keep your Pydantic AI tool functions and let Argentic run the loop: the prompt is rebuilt each step under a cap, you set the budget, and a killed process resumes without repeating a finished action.
- [Proof of what ran: checks, the journal file and proof links](https://getargentic.com/docs/proof.md): Check what an Argentic run did: rebuild every prompt from the journal, run the engine again on the recorded replies, download the hash-chained journal and verify it yourself, or share a read-only proof link.
- [If a run is cut off: what a restart skips and what it retries](https://getargentic.com/docs/recovery.md): What happens when an Argentic agent is killed mid-run, from your side: the two keys, what a restart skips and what it retries, how to make a tool safe to repeat, and what isn't covered.
- [Retry-safe tools for Stripe, email, Slack and GitHub](https://getargentic.com/docs/tool-pack.md): Tools for Stripe, Resend, SMTP, Slack, GitHub and HTTP that use an Argentic action's stable key, so a cut-off action can be retried safely. What each provider can and can't promise.
- [FAQ: how Argentic works, its limits, pricing and your data](https://getargentic.com/docs/faq.md): Straight answers about Argentic: models, limits, pricing, errors, what it does and doesn't promise after a crash, whether it works with your framework, and what happens to your data.
- [MCP server: connect Claude, Codex, Cursor and other clients](https://getargentic.com/docs/mcp.md): Connect Claude, Claude Code, Codex, Cursor, VS Code or any MCP client to Argentic: the two addresses, how each signs in, every tool, the time and rate limits, and what to do when a call fails.
- [Use Argentic from your coding agent](https://getargentic.com/docs/agents.md): Connect Claude Code, Claude Projects or Codex to Argentic over MCP, with skills, so your coding agent can wake, resume and check agents.
- [OpenAPI spec](https://getargentic.com/openapi.json): the hosted API as OpenAPI 3

## Guides

Each guide starts from a problem developers hit (a context bill that keeps growing, spending without approval, a tool that runs twice, a run that outlives its function) and has code you can run. The guides work with or without Argentic. The ones on retries, crashes and timeouts cover failures any long-running agent can hit; they are not a description of what Argentic is.

- [Guides for long-running AI agents: cost, approval, proof and what goes wrong](https://getargentic.com/docs/guides.md): Eleven guides for agents that run for hours: bills that grow with the session, spending without a person's say-so, a record you can check, trying another path from any past turn, and the failures that follow a long run: actions that happen twice, runs that die halfway and two workers on one job. Each has code you can run.
- [How to run a long AI agent session without the context bill exploding](https://getargentic.com/docs/guides/long-agent-sessions-without-a-huge-context-bill.md): Why the cost of a long agent session that resends its transcript grows faster than its length, what caching, trimming and summaries buy you, and what rebuilding context from saved state did on our benchmarks, with the numbers and where they fall short.
- [How to require human approval before an AI agent spends money](https://getargentic.com/docs/guides/human-approval-before-an-agent-spends-money.md): Three layers that hold even when the model is wrong: a hard ceiling, a signed standing permission for small amounts, and a person's one-time approval above that. Code you can run, and what Argentic offers today.
- [How to prove what your AI agent actually did: tamper-evident logs, with code](https://getargentic.com/docs/guides/prove-what-an-agent-did.md): A log you can edit isn't proof. How to record an agent's tool calls so tampering shows, what that proves and what it can't, with a hash-chained log in 60 lines of TypeScript.
- [How to test whether your AI agent repeats an action after a crash, with a runnable test](https://getargentic.com/docs/guides/test-an-agent-for-repeated-actions.md): Kill an agent at each tool call, restart it, and count what happened twice. A test that needs no model, no keys and no changes to your framework, with a runnable agent that fails and a fixed one that passes.
- [How to make AI agent tool calls safe to retry: idempotency keys, with code](https://getargentic.com/docs/guides/make-agent-tools-safe-to-retry.md): Why an agent runs a tool twice after a timeout or a crash, and how to stop a duplicate refund or email: stable idempotency keys, a record of what ran, and code you can run.
- [Why a tool runs twice after you resume an agent: LangGraph interrupt, with code](https://getargentic.com/docs/guides/tool-runs-twice-after-resume.md): An email, charge or ticket happens twice when a LangGraph graph resumes after interrupt(). Why a resume re-runs the step, three fixes that keep the effect to one, and Python you can run.
- [Why your AI agent calls the same tool twice: duplicate tool calls, with code](https://getargentic.com/docs/guides/agent-calls-the-same-tool-twice.md): The model asks for the same refund or email twice and both run. Why a tool call id doesn't protect you, why a check inside the tool can still let both through, and a fix with code you can run with the AI SDK.
- [How to resume an AI agent after a crash without repeating tool calls](https://getargentic.com/docs/guides/resume-an-agent-after-a-crash.md): Reloading the chat history isn't enough to resume an agent after a crash. What to save, in what order, and a 30-line durable loop you can run, kill and restart.
- [How to stop an AI agent from running twice: two workers, one job](https://getargentic.com/docs/guides/stop-an-agent-running-twice.md): Two workers pick up the same agent job. Why it happens after a deploy, a retry or a slow process, and how a lease with a fencing token keeps one of them out. Code you can run on Postgres.
- [What to do when an AI agent run outlives its serverless function: timeouts, with code](https://getargentic.com/docs/guides/agent-run-times-out-on-serverless.md): A long agent run hits the function time limit and the work is lost. How to split the run into short invocations that each pick up where the last stopped, and what happens when one dies mid-step. Runnable Node code.
- [How to fork an AI agent to debug a past turn or try another approach](https://getargentic.com/docs/guides/fork-an-agent-to-try-another-path.md): Cut an agent's journal at any finished turn and wake the copy with a different prompt, model or message. The original never changes. Debug a bad turn, or clone an agent mid-task and run attempts in parallel.

## Product

- [Argentic Platform](https://getargentic.com/product/): what the platform does, the models it runs on, and how a run is checked
- [Pricing](https://getargentic.com/pricing/): free during the beta, and the limits that apply
- [Security](https://getargentic.com/security/): how data is handled, and the subprocessors
- [Trust and exit](https://getargentic.com/trust/): what is open and what is closed, and how to take your data with you
- [Known issues](https://getargentic.com/known-issues/): what is wrong or unproven today, who it affects, and the rows that show it
- [Mission](https://getargentic.com/mission/): what the lab is building and why

## Research

Each study says what was measured, on which model, against what, and what it does not show yet.

- [Long run: what an agent remembered over 11 hours 59 minutes](https://getargentic.com/research/long-run/): 11 hours 59 minutes of clock time on shift (about 75 minutes of it with our test machine down), 31 kills:81 of 91 callback questions right. No kill made a finished action run again. 7 orders were refunded more than once by the agent. Every call, kill, action and graded event is downloadable.
- [Rebuilding agent context from a record, not a transcript](https://getargentic.com/research/reprojection/): We rebuild an agent's context from a recorded history instead of keeping a growing transcript. What that buys, what it costs, and what we haven't tested yet.
- [LongMemEval: far fewer tokens, at a small accuracy cost](https://getargentic.com/research/longmemeval/): The engine against a model reading the whole chat history, on LongMemEval: never ahead on accuracy, at 0.08 to 0.31 times the tokens.
- [LongMemEval_M: 38 of 60 on 1.2M-token histories](https://getargentic.com/research/longmemeval-m/): On histories of about 1.2 million tokens, the engine got 38 of 60 right on a free open model and 29 on Claude Haiku 5.5. Our loops that summarize or truncate got fewer: 17 and 5 on the free model, and 3 for truncation on Haiku.
- [HaluMem Long: our accuracy lead did not replicate](https://getargentic.com/research/memory-halumem/): Our experimental memory pipeline led plain RAG by 14.2 points on HaluMem Long, then the lead did not replicate on two fresh question sets. It also missed its token bar.
- [LoCoMo and LongMemEval next to published memory scores](https://getargentic.com/research/published-systems/): Argentic's LoCoMo and LongMemEval runs (a free open model, plus Claude Haiku 5.5 on LongMemEval) beside vendor-reported scores and a few baselines from papers, with the answer and judge model for each row or "not stated".
- [Check our work](https://getargentic.com/research/check/): Every claim Argentic makes, what backs it and its caveat, the results that went against us, and the raw rows behind each study to recount yourself.
- [Crash test: 504 kills of a running agent](https://getargentic.com/research/crash-test/): Across 422 crashed sessions, 496 kills in a rerun with published rows (504 in the first run), with a scripted model: no finished action ran again. A frozen worker repeated a refund in 3 of 22 runs in the rerun, 2 of 22 in the first.
- [Rebuilding agent context vs a growing transcript, an early test](https://getargentic.com/research/early-context-study/): An early test of a rebuilt prompt against a growing transcript. The study reports it found more in all three cells, by less than first said.
- [Argentic engine rerun of a 900-event shop shift, November 2026](https://getargentic.com/research/long-run-november/): Nov 2026 rerun of a 900-event shop shift on Claude Haiku 5.5, engines 0.51.0 to 0.70.1: stock exact 83 of 83 with clearer count wording, 48 of 83 without. One run per variant.
- [Undoing what a flagged source caused in an agent run](https://getargentic.com/research/quarantine/): When a source is flagged after a run, a host that calls the engine's quarantine step undoes the calls linked to it, using undo functions the host supplies, and resumes the agent without it. It is not in the hosted API. Effects with no undo function are refused unless allowed. All 156 runs finished without the source: 120 scripted (the scripted agent always obeyed the injection) and 36 live on Claude Haiku 5.5, 24 with the injection forced and 12 where the model did not follow it.
- [Two agents, one order: settling conflicting runs](https://getargentic.com/research/settlement/): Settlement stopped 11 conflicting runs out of 50 with Claude Haiku 5.5 on permissive tools, and removed no bad outcomes where the tools already checked state.
- [τ-bench: the engine against a plain agent loop](https://getargentic.com/research/tau-bench/): The engine on τ-bench, a public benchmark. An early gap was most likely a bug in our runner; rerun without rate limiting, the engine scored 13 against the loop's 12 on 18 pairs, with no fresh loop control.

## Optional

- [Home](https://getargentic.com/): what it is and where it stands
- [Research index](https://getargentic.com/research/): every study on one page
- [Blog](https://getargentic.com/blog/): short write-ups, each linked to its study
- [Run your first agent](https://getargentic.com/blog/argentic-is-open/): Sign in, make an API key and run an agent of your own on a budget you set. What we've measured, and what isn't there yet.
- [A plain transcript loop or an engine like ours: when each is the right call](https://getargentic.com/blog/argentic-vs-a-transcript-loop/): A growing transcript is a common agent loop. What it does well, where it runs out of window, and what rebuilding the prompt from a record trades away.
- [Does a growing transcript hurt a long agent run? Our early test, and the part we retracted](https://getargentic.com/blog/does-a-growing-transcript-hurt-a-long-agent-run/): An early test of a rebuilt prompt against a growing transcript on two models. The study reports it found more in all three cells, and one claim was retracted.
- [Why we rebuild an agent's context instead of appending to it](https://getargentic.com/blog/rebuild-dont-append/): What rebuilding context from a record changes, in plain terms, and the limits of what we have measured so far.
- [Resuming an agent after a crash without repeating a finished action](https://getargentic.com/blog/resume-an-agent-after-a-crash/): 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.
- [Checking what your agent was shown on each turn](https://getargentic.com/blog/see-what-your-agent-was-shown/): Replay re-checks every prompt against what was recorded: 1,754 of 1,754 turns matched. It checks the prompt side only.
- [Does summarizing old context lose details? We measured it](https://getargentic.com/blog/summarizing-old-context-loses-details/): On Gemma 4 31B and histories of about 1.2 million tokens, our own note-rewriting loop got 17 of 60 and the engine got 38 of 60.
- [Undoing what a bad source caused, from the record alone](https://getargentic.com/blog/undo-what-a-bad-source-caused/): When a source was flagged after the run, the engine finished without it in 156 of 156 runs. It undid what the source caused in 144; in 12 live runs the model did not follow the injection, so there was nothing to undo. 120 were scripted; of the 36 live runs, 24 forced the compromise.
- [Where Argentic fits next to the agent SDKs and the tools around them](https://getargentic.com/blog/where-argentic-fits/): Argentic next to the Claude, OpenAI and Amazon agent SDKs and the tools built for a different job, read from each vendor's docs, with where they beat us.
- [Why your agent forgets things from a long history](https://getargentic.com/blog/why-agents-forget-in-long-histories/): On Gemma 4 31B, a loop keeping about the newest 100,000 tokens got 5 of 60 right; the engine got 38. Histories were about 1.2 million tokens.
- [Why an agent's own memory skips things](https://getargentic.com/blog/why-an-agents-own-memory-skips-things/): Six reasons an agent's own notes skip the detail that mattered, and what fixes each. Includes our one-run shop-shift numbers and what they don't show.
- [Why an agent juggling many tasks loses track of what's done, pending and blocked](https://getargentic.com/blog/why-an-orchestrator-agent-loses-track-of-its-tasks/): Six reasons an agent juggling many tasks loses track of what is done, pending and blocked, and what fixes each. We have no orchestration benchmark yet.
- [Why long-running agents lose track of counts](https://getargentic.com/blog/why-long-running-agents-lose-track-of-counts/): Six reasons an agent's running totals drift and what fixes each. On our shop shift, 22 of 28 stock answers right with the engine keeping counts, 4 of 28 without.
- [Why your agent forgets things after compaction](https://getargentic.com/blog/why-your-agent-forgets-after-compaction/): Six reasons an agent forgets after its context is compacted and what fixes each. Includes our one-run shop-shift numbers and what they don't show.
- [Why your agent repeats an action it already took](https://getargentic.com/blog/why-your-agent-repeats-an-action-it-already-took/): Six causes of a repeated refund or email, what fixes each, and the one underneath most of them. Includes our November rerun's numbers and what they don't show.
- [Changelog](https://getargentic.com/changelog/): what shipped, by date ([Atom feed](https://getargentic.com/changelog.xml))
- [About](https://getargentic.com/about/)