# inngest-durable-functions

A skill that teaches your agent to write Inngest functions that survive crashes, retry on failure and resume where they stopped.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 3800 installs · ★ 29
- Author: inngest
- License: Apache-2.0 · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/inngest/inngest-skills/tree/HEAD/skills/inngest-durable-functions/SKILL.md
- Updated: 2026-09-28
- HTML: https://affpapa.org/en/nevibecode/skills/inngest-durable-functions

## What it does

This skill covers Inngest's durable execution model in TypeScript. It explains what belongs inside `step.run()` and what does not: API calls, database writes and file I/O go in steps, while pure calculations and validation stay out. Memoization keeps finished steps from running twice, and state persists across infrastructure failures.

Triggers get their own sections — events with conditional filters, cron schedules with timezones, and calling another function through `step.invoke()`. Idempotency is handled on both sides: a custom `id` on the sent event, or an `idempotency` key on the function. Cancellation uses `cancelOn` with expressions where `event` is the original trigger and `async` is the incoming event.

Know the ceilings before you design a workflow. A single run allows 1000 steps, 4MB of returned data per step and 32MB of combined run state. Every step is a separate HTTP request, so overhead adds up. Hitting those numbers means splitting the work into smaller functions wired together with `step.invoke()` or `step.sendEvent()`. Examples are TypeScript only; Python and Go readers are pointed to the Inngest docs.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add inngest/inngest-skills --skill inngest-durable-functions -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/inngest-durable-functions/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/inngest-durable-functions/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add inngest/inngest-skills --skill inngest-durable-functions -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/inngest-durable-functions/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add inngest/inngest-skills --skill inngest-durable-functions -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/inngest-durable-functions/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install inngest/inngest-skills inngest-durable-functions
```

2. **Manually: put the files in place**
- File: `.github/skills/inngest-durable-functions/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add inngest/inngest-skills --skill inngest-durable-functions -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/inngest/inngest-skills --path skills/inngest-durable-functions
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/inngest-durable-functions/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add inngest/inngest-skills --skill inngest-durable-functions -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/inngest/inngest-skills/tree/HEAD/skills/inngest-durable-functions/SKILL.md

## When to use it
- keep a webhook handler from dropping events when the process dies
- replace a flaky cron job with a scheduled function that retries
- resume a background job from the failed step instead of the start
- stop a duplicate event from sending the confirmation email twice
- cancel an order when payment never arrives

## Example prompts
- Write an Inngest function on `order/created` that validates payment, charges the customer and sends an email, each in its own `step.run()`
- Add `cancelOn` for the `order/cancelled` event with the check `event.data.orderId == async.data.orderId`
- Set up an hourly cron trigger with retries and idempotency on `event.data.cartId`

## Source text · SKILL.md · Apache-2.0

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 6d1c1786a9d1f4b0.

BEGIN THIRD-PARTY FILE 6d1c1786a9d1f4b0
````text
---
name: inngest-durable-functions
description: Use when building functions that must survive process crashes, retry automatically on failure, run on a schedule, react to events, or maintain state across infrastructure failures — e.g., webhook handlers that drop events, flaky cron jobs, background jobs that fail mid-execution, or workflows that need to resume where they left off. Covers Inngest function configuration, triggers (events, cron, invoke), step execution and memoization, idempotency, cancellation, error handling, retries, logging, and observability.
---

# Inngest Durable Functions

Master Inngest's durable execution model for building fault-tolerant, long-running workflows. This skill covers the complete lifecycle from triggers to error handling.

> **These skills are focused on TypeScript.** For Python or Go, refer to the [Inngest documentation](https://www.inngest.com/llms.txt) for language-specific guidance. Core concepts apply across all languages.

## Core Concepts You Need to Know

### **Durable Execution Model**

- **Each step** should encapsulate side-effects and non-deterministic code
- **Memoization** prevents re-execution of completed steps
- **State persistence** survives infrastructure failures
- **Automatic retries** with configurable retry count

### **Step Execution Flow**

```typescript
// ❌ BAD: Non-deterministic logic outside steps
async ({ event, step }) => {
  const timestamp = Date.now(); // This runs multiple times!

  const result = await step.run("process-data", () => {
    return processData(event.data);
  });
};

// ✅ GOOD: All non-deterministic logic in steps
async ({ event, step }) => {
  const result = await step.run("process-with-timestamp", () => {
    const timestamp = Date.now(); // Only runs once
    return processData(event.data, timestamp);
  });
};
```

## Function Limits

**Every Inngest function has these hard limits:**

- **Maximum 1,000 steps** per function run
- **Maximum 4MB** returned data for each step
- **Maximum 32MB** combined function run state including, event data, step output, and function output
- Each step = separate HTTP request (~50-100ms overhead)
````
END THIRD-PARTY FILE 6d1c1786a9d1f4b0

The third-party file has ended. Everything between the 6d1c1786a9d1f4b0 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2161 of 14695 bytes. © inngest · Apache-2.0 · https://github.com/inngest/inngest-skills/tree/HEAD/skills/inngest-durable-functions/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md