Benchmarks

Measured. Reproducible.
Honestly caveated.

We measured what can be measured, cite what others have documented, and say plainly what we do not claim. Every number below has a date, a method, and a script you can run yourself.

Methodology

Measured July 4, 2026 · Node 22.22 · npm 10.9 · Linux x64 · warm npm cache · fresh project per stack. Each stack was installed with the packages its own docs require for a durable, human-approvable agent: LangGraph (+core, +SQLite checkpointer), Temporal (client/worker/workflow/activity), Inngest AgentKit (+inngest), OpenAI Agents SDK, Mastra core. Package count = direct + transitive dependencies installed; footprint = du -sm node_modules; cold start = time to import the package in a fresh Node process. Install time varies with network, treat it as indicative; counts and sizes are stable. Reproduce: bench/footprint.sh.

Dependency packages installed

Every package is supply-chain surface your security team must trust. 2025-26 saw real attacks ride exactly this vector (trojanized npm packages targeting AI tooling).

⬢ nexus
0 deps
langgraph + sqlite ckpt
63
openai agents sdk
106
temporal (4 pkgs)
158
mastra core
232
inngest agentkit
314

Installed footprint (node_modules)

⬢ nexus
~1 MB
openai agents sdk
64 MB
langgraph
90 MB
mastra core
143 MB
inngest agentkit
159 MB
temporal (4 pkgs)
270 MB

Cold-start import time

Matters for serverless, CLIs, and CI, every invocation pays it.

⬢ nexus
74 ms
temporal client
200 ms
openai agents sdk
269 ms
langgraph
291 ms
inngest agentkit
314 ms
mastra core
505 ms

Moving parts at runtime

The number of things that must be deployed, monitored, patched, and paged about, for a durable agent with human approval. Sourced from each project's own documentation (July 2026).

StackWhat must be runningComponentsDurability model
⬢ nexusyour Node process + a file or SQLite database1journal + resume, per step
OpenAI Agents SDKyour process + a datastore you build + resume plumbing you build (docs recommend adding Temporal/Dapr/Restate for real durability)2–4, DIYserialized state blob; crash mid-turn loses the turn
LangGraph (durable)your process + Postgres checkpointer; LangGraph Platform self-hosted adds a server + Redis + license key2–4checkpoints at step boundaries
Inngest AgentKityour functions + the Inngest server (SSPL-licensed) + event keys2–3event-driven step memoization
Temporaldev: single server binary + worker + client (3 processes) · production self-hosted: server, database, UI, admin tools, Elasticsearch (~5 containers) + workers, or Temporal Cloud3 dev / 5+ prodevent-history replay (excellent, heavy to self-host)

Sources: openai-agents docs (HITL & running-agents), langchain-ai LangGraph platform docs, inngest/agent-kit README, temporalio docs. Capability differences, not quality judgments. Temporal's durability is superb if you can run Temporal.


Code to get a durable, approvable, budget-capped agent

OpenAI's own canonical human-in-the-loop examples are 116–137 lines, and their "persistence" is a local JSON file with resume plumbing left to you. Here's the whole thing in Nexus, durability included:

the standard pattern, ~120 LOC + DIY storage + DIY resume + no budgets
// 1. define tool with needsApproval          (their SDK: ✓)
// 2. run, detect result.interruptions        (their SDK: ✓)
// 3. serialize RunState to a string          (their SDK: ✓)
// 4. design a DB schema for pending states   (you: build it)
// 5. build an approval UI / notification     (you: build it)
// 6. build the resume endpoint/worker        (you: build it)
// 7. handle crash mid-turn                   (you: can't, turn is lost)
// 8. token/USD budget caps                   (you: build it)
// 9. audit journal of every step             (you: build it)
// 10. replay for regression testing          (you: build it)
nexus. 25 lines, everything included
runtime.register(defineAgent({
  name: 'support', provider, model,
  tools: [lookup, refund],       // refund: requiresApproval
  budget: { maxUsd: 0.50 },      // hard cap, pre-flight
  approvalPolicy: ({ arguments: a }) =>
    a.amountUsd < 50 ? 'approve' : 'ask',
}));

const run = await runtime.run('support', task);
// paused? notify Slack (1 line), approve from anywhere:
await runtime.approve(run.id);
// crashed? resume. finished? replay. all built in.

Capability matrix

Durable runsHuman approvalsPolicy rulesPer-run USD budget$0 replayOpen run formatZero deps
⬢ nexus✓ CC0
LangGraphcheckpointsDIY
TemporalDIYhistory replay
Inngest AgentKitDIY
OpenAI Agents SDKstate blob, DIY storepredicate✗ (max_turns only)
MCP approval proxiesper-key

Assessed July 2026 from public docs of each project. "DIY" = achievable with custom code, not shipped. Corrections welcome, open an issue.

What we do NOT claim: Nexus does not make your LLM produce tokens faster, model latency is the provider's. "Faster" here means measurably faster to install, import, audit, and operate, with fewer components and fewer failure modes. When you truly need horizontal workflow orchestration across thousands of workers, Temporal is excellent, our bet is that most agent teams need durability, approvals, and budgets long before they need a workflow cluster.
How enterprises put this to work →