Inngest and Temporal are both durable execution engines for AI agents: a run survives a crash, and it can make a human-in-the-loop wait for approval. They get there from opposite ends. Inngest is durable orchestration for the functions you already deploy: its cloud calls them over HTTP. Temporal runs your agent as a workflow on a server, and your workers pull work from it.

So pick Inngest when your agent already lives in a web app (Next.js, a Python API) and you want the least new machinery. Pick Temporal when a run has to wait indefinitely, or you need an SDK in Java, .NET, Ruby, or PHP. And if you’d rather run neither, Cadenya is a hosted agent loop with durable execution and approvals built in. What it offers is at the end.

Every price and limit below comes from each vendor’s own pages, checked on September 28, 2026.

Inngest and Temporal side by side

	Inngest	Temporal
What you run yourself	One binary (the Inngest CLI). SQLite on one node by default, Postgres and Redis to scale out	Four services (Frontend, History, Matching, Worker) and a database
Managed option	Inngest Cloud: Free, Pro from $99 a month, Business from $499	Temporal Cloud from $0 a month, Business from $500
What you pay for	Executions: one per run plus one per step	Actions: $50 per million for the first 5 million
Free allowance	50,000 executions a month	$150 in credits, valid for 90 days
How long a run can wait for a person	Until the waitForEvent timeout, inside a maximum run length of 30 days (Free) to 366 days (Pro)	“Hours, days or indefinitely”
The waiting primitive	step.waitForEvent(), matched on event data	Signals, Updates, and durable timers
Code that changes while runs wait	Completed steps are memoized and never re-run	Worker Versioning (pinned or auto-upgrade) and patching
Server license	SSPL v1, Apache 2.0 three years after each release. SDKs are Apache 2.0	MIT
SDKs	TypeScript (Node 20 or later), Python (3.10 or later), Go	Go, Java, Python, TypeScript, .NET, Ruby, PHP
Latest server release	v1.45.1, September 17, 2026	v1.32.0

Self-hosted or managed: what you run

Inngest self-hosts as “a single binary that includes all Inngest services.” Out of the box it stores state in SQLite, which “does not support scaling beyond a single node”, so a production setup points it at Postgres and Redis. One caution sits on the same page: “Inngest’s support team does not guarantee direct support for self-hosted instances.”

Temporal is four services that scale on their own, plus a database (PostgreSQL 13 to 16, MySQL 8.0.19 and later, or Cassandra). Searching across runs works on SQL from server 1.20, and Temporal recommends Elasticsearch in production.

The bigger difference is where your code runs. Inngest calls your functions where they already live, so a Next.js app on Vercel can host its own agent steps. Temporal needs long-lived workers that poll the server. With Temporal Cloud, you still run the workers.

Human-in-the-loop approvals: how long a run can wait

Inngest pauses the run on step.waitForEvent() and resumes it when a matching event arrives:

import { Inngest } from 'inngest';

const inngest = new Inngest({ id: 'refunds' });

export const refundApproval = inngest.createFunction(
  { id: 'refund-approval', triggers: { event: 'refund/requested' } },
  async ({ event, step }) => {
    const decision = await step.waitForEvent('wait-for-approval', {
      event: 'refund/decided',
      timeout: '7d',
      if: `async.data.refundId == "${event.data.refundId}"`,
    });
    // null means nobody decided within 7 days
    if (!decision) return 'expired';
    return decision.data.approved ? 'refunded' : 'denied';
  },
);

The run costs nothing while it waits (“no compute cost while a human reviews”). But every example in Inngest’s docs sets a timeout, the call returns null when it passes, and the whole run is capped by the plan’s maximum run length: 30 days on Free and 366 days on Pro, per Inngest’s usage-limits page. What if the reviewer answers before the run reaches the wait? Inngest misses it. The wait “begins listening for new events from when the code is executed”, so an approval sent a second too early is lost.

Temporal waits on a condition, and your app sends a Signal to flip it:

import { condition, defineSignal, setHandler } from '@temporalio/workflow';

export const decide = defineSignal<[boolean]>('decide');

export async function refundApproval(refundId: string): Promise<string> {
  let approved: boolean | undefined;
  setHandler(decide, (value) => {
    approved = value;
  });

  // No timeout, so the wait has no limit.
  await condition(() => approved !== undefined);
  return approved ? `refund ${refundId} sent` : `refund ${refundId} denied`;
}

A Signal can arrive before the workflow reaches the wait, and the handler still records it. Temporal’s AI cookbook says a workflow “can wait for approval for hours, days or indefinitely.” The ceiling to plan for is the event history, 51,200 events or 50 MB per run.

Versioning: deploying while runs wait

Inngest takes the light path: “completed steps are never re-executed, even across deployments.” A step you add runs when an in-flight run reaches it, and a reordered step logs a warning instead of failing the run. No version markers.

Temporal makes you choose. A Pinned workflow finishes on the version it started on, and an Auto-Upgrade workflow moves to new code and stays safe through patching. It’s more ceremony, and it’s explicit about what an old run executes.

Pricing

Inngest bills executions: “A function with 5 step.run() calls uses 6 executions total.” Free covers 50,000 a month and pauses when you hit it. Pro starts at $99 a month with 1 million, then $0.000050 per execution, falling to $0.000015 with volume.

Temporal Cloud has no base fee. You pay $50 per million Actions (a workflow start, each activity, each timer, each Signal), plus storage and support at 10% of usage. New accounts get $150 in credits for 90 days, and Business starts at $500 a month.

For an agent run with one start, 6 model calls, 3 tool calls, and one approval, that’s about 11 Inngest executions or 12 Temporal Actions. At 2,000 runs a month, Inngest fits in its free tier and Temporal Cloud bills about $2. The Temporal cost breakdown shows the arithmetic.

What you still write for an AI agent

Neither engine is the agent. You still write the loop that calls the model, the tool calls, the stream to your UI, context compaction, and the screen where someone approves.

Inngest ships AgentKit, “a TypeScript library to create and orchestrate AI Agents” with support for “OpenAI, Anthropic, Gemini and all OpenAI API compatible models.” Temporal runs the OpenAI Agents SDK as workflows (Python 3.10 or later) and lists integrations for the AI SDK by Vercel, LangGraph, Mastra, Pydantic AI, and more.

Cadenya runs all of those for you.

What does Cadenya offer that Inngest and Temporal don’t?

Inngest and Temporal run the code you deploy as durable workflows with human-in-the-loop waits, and that code still has to be the agent. Cadenya is the agent: durable execution and human-in-the-loop approvals with the loop built in, and nothing to deploy or self-host. Here’s what that covers:

1. Nothing else to run. No binary with Postgres and Redis behind it, no Temporal services, no workers, and no sidecar. The loop runs on Cadenya and your app stays a stateless web tier, so your deploys never touch a running objective.
2. The agent loop, already written. Cadenya calls the model, runs the tools, streams each reply, and compacts the context window when a conversation gets long. With Inngest’s AgentKit or Temporal’s OpenAI Agents SDK integration, that loop is still code you run and upgrade.
3. No versions to manage. An objective keeps its variation’s configuration snapshot even when you edit the variation. There’s no step order to keep stable across deploys and no worker version to pin.
4. Tools generated from your OpenAPI spec. Point a tool set at an OpenAPI 3 document and every operation becomes a tool, with no OpenAPI-to-MCP generator to run and no hand-written tool list to keep in sync. Cadenya re-checks the document each hour, filters the list, and loads tools on demand. MCP servers and plain HTTP endpoints work too.
5. Human-in-the-loop approvals with no race. The objective pauses on toolApprovalRequested before anyone can answer, and the answer targets that pending tool call by ID, so an early approval can’t get lost. It can come from your backend, a webhook handler that posts to Slack, or a person in the React chat widget, and a denial can carry a memo that steers the agent.
6. Any model, on your own keys. The model is a setting on a variation, so switching providers needs no deploy. Use any model on OpenRouter or your own endpoint that speaks the OpenAI chat format, billed by your provider. Weighted variations route more traffic to whichever model or prompt users rate higher.
7. Resumable streaming. The event stream honors Last-Event-ID, and the TypeScript SDK reconnects on its own after a drop.
8. Acting on behalf of the signed-in user. A widget session can carry the user’s short-lived token as a secret that overrides the shared API credential, so your API sees that user’s token on each tool call. Pinned parameters fix the IDs the model can’t change.
9. SDKs for older stacks. TypeScript on Node 18, Python 3.9, Ruby 3.1, and Go 1.22, all at 1.7.0 and Apache-2.0, plus a CLI and a plain HTTP API for Java or anything else. Inngest’s SDKs need Node 20 or Python 3.10, and Temporal’s Ruby SDK needs Ruby 3.2 at least.
10. A price in one line. Free for 1,000 loops a month, $49 a month for 50,000, then $0.0015 a loop, where a loop is one LLM request. An agent turn that calls the model 6 times is 6 loops, and waiting costs nothing. There are no seats, and no server license like Inngest’s SSPL to check, since you host no server.

The tool sets guide shows how your API becomes an agent’s tools, and the free plan needs no card.