Your agent works on your laptop. Then you deploy it, and somewhere in a forty-step plan the model provider throws a 529, or the box gets recycled mid-run, or you push a deploy and the function restarts from the top — re-charging the card it already charged. The work that makes agents interesting is exactly the work serverless is worst at: it's long, it waits, and it has side effects you can't afford to repeat.

The usual fix is to build the boring half yourself — a queue, a worker pool, a retry policy with backoff, a dead-letter table, idempotency keys, and a dashboard to see what's stuck. That's a week of undifferentiated plumbing before your actual feature runs reliably in production. Inngest is a way to skip that week.

What it is#

Inngest is a durable execution platform: you write ordinary functions, trigger them with events, and Inngest runs each step as a checkpointed, retriable unit of work — while it owns the queue, the scaling, and the flow control. The load-bearing idea is the step. When you wrap work in step.run, its result is saved once it succeeds; if a later step fails and the function retries, the completed steps don't run again. Each step is retried independently, so one flaky API call doesn't restart the whole job.

Functions are triggered by events (also cron schedules and webhooks), which keeps things decoupled — you send app/account.created and any number of functions can react. There are official SDKs for TypeScript, Python, and Go, and built-in flow control: concurrency limits, throttling, debouncing, rate limiting, and batching, all declared as config rather than hand-rolled. It's open source (Apache-licensed, on GitHub) with an official Helm chart to self-host, or a managed Cloud if you'd rather not run it.

For agents specifically, step.ai wraps a model call so it's automatically retried and its result cached for durability, and AgentKit — their TypeScript framework — sits on top to compose agents, tools, routers, and multi-agent networks on the same durable engine.

Who it's for#

If you have work that's too long or too important to run inside a request — an agent loop that plans over minutes, an onboarding drip with day-long waits, a webhook that fans out into fifty calls, a nightly batch job — Inngest is aimed at you. It's an especially good fit if you like thinking in events and steps and want to call your model inline inside the function rather than restructuring everything around a replay-based engine.

Who it isn't for: if your background work is one fire-and-forget email, this is more than you need. And while the SDKs cover three languages, the agent layer (AgentKit) is TypeScript-first today.

How to start#

Install the SDK, define an event-triggered function, and reach for steps where you need durability. Here's an agent-shaped flow: do work, pause for a human approval, and sleep — all crash-safe.

import { Inngest } from "inngest";

const inngest = new Inngest({ id: "my-app" });

export default inngest.createFunction(
  { id: "run-agent-task", concurrency: 5 },
  { event: "agent/task.requested" },
  async ({ event, step }) => {
    // Retried independently; result checkpointed on success.
    const plan = await step.run("draft-plan", () => generatePlan(event.data));

    // Pause the run until a human approves — survives crashes and deploys.
    const approval = await step.waitForEvent("await-approval", {
      event: "agent/plan.approved",
      timeout: "3d",
      if: `async.data.taskId == "${event.data.taskId}"`,
    });

    if (!approval) return { status: "expired" };

    await step.sleep("cool-off", "1d"); // no cron, no scheduler table
    return step.run("execute", () => executePlan(plan));
  }
);

No queue to provision, no scheduler for that one-day sleep, no polling loop for the approval. The function can sit paused for days and resume on the exact step where it stopped.

Pricing#

The Hobby tier is free: 50,000 executions per month with a concurrency of 5 — enough to build and run a real side project before paying anything (runs pause once you exhaust the quota rather than surprising you with a bill). Pro starts at $75/month with 1 million executions included, higher concurrency, and metered overage at tiered rates. Enterprise adds SAML, RBAC, audit trails, and longer trace retention on custom terms. Confirm the current numbers on the pricing page before you budget, since tiers move.

The catch / when NOT to use it#

Executions are the meter, and steps count — a chatty agent that fans out into dozens of steps per run burns the quota faster than a simple job, so model your workload before you assume the free tier covers it. It's also a real service to adopt: an SDK, an events model, and a serve endpoint your app exposes. If you just need a single delayed task, your framework's built-in queue is less to learn. And if your agent loop must be replay-deterministic with strict exactly-once guarantees, weigh the trade-offs first — see Temporal vs Inngest vs Restate. For a close cousin in the same durable-jobs space, compare notes with our Trigger.dev highlight.