# Inngest — Durable AI Workflow Orchestration

> Run reliable AI workflows with automatic retries and state persistence. Replace queues and scheduling with durable step functions. TypeScript, Python, Go SDKs. 5,200+ stars.

## Install

Save the content below to `.claude/skills/` or append to your `CLAUDE.md`:

## Quick Use

1. Start the dev server:
```bash
npx inngest-cli@latest dev
# Dashboard at http://localhost:8288
```

2. Create a durable function:
```typescript
import { inngest } from "./client";

export const processWithAI = inngest.createFunction(
  { id: "ai-pipeline" },
  { event: "app/document.uploaded" },
  async ({ event, step }) => {
    const text = await step.run("extract", () =>
      extractText(event.data.url)
    );
    const summary = await step.run("summarize", () =>
      callClaude(text)
    );
    await step.run("save", () =>
      saveToDatabase(summary)
    );
    return { summary };
  }
);
```

3. Each step retries independently — if step 2 fails, step 1 doesn't re-run.

---

## Intro

Inngest is a durable workflow orchestration platform with 5,200+ GitHub stars. It replaces queues, state management, and scheduling with durable step functions that automatically retry and persist state. Perfect for AI workflows where each step (extract → process → save) needs to be reliable. SDKs for TypeScript, Python, Go, and Kotlin. Best for developers building multi-step AI pipelines, background jobs, or event-driven workflows that must not lose progress.

See also: [AI automation scripts on TokRepo](https://tokrepo.com/en/@Script%20Depot).

---

## Inngest — Reliable AI Workflows

### The Problem

AI pipelines are multi-step: extract text → call LLM → save result → send notification. If step 3 fails, you don't want to re-run the expensive LLM call. Traditional queues don't handle this well.

### The Solution

Inngest's durable functions persist state after each step. If a step fails, only that step retries — previous steps are not re-executed.

### Key Concepts

| Concept | Description |
|---------|------------|
| **Durable functions** | Functions that survive failures and restarts |
| **Steps** | Individual units of work that retry independently |
| **Events** | Triggers that start workflows |
| **Flow control** | Concurrency, throttling, debouncing, rate limiting |

### AI Workflow Example

```typescript
const aiPipeline = inngest.createFunction(
  { id: "ai-research" },
  { event: "research/start" },
  async ({ event, step }) => {
    // Step 1: Gather sources (retries independently)
    const sources = await step.run("gather", () =>
      searchWeb(event.data.topic)
    );

    // Step 2: Analyze each source in parallel
    const analyses = await Promise.all(
      sources.map((s, i) =>
        step.run(`analyze-${i}`, () => analyzeSources(s))
      )
    );

    // Step 3: Synthesize with AI
    const report = await step.run("synthesize", () =>
      callClaude(`Synthesize: ${JSON.stringify(analyses)}`)
    );

    // Step 4: Save and notify
    await step.run("save", () => saveReport(report));
    await step.run("notify", () => sendSlack(report.summary));

    return report;
  }
);
```

### SDKs

| Language | Package |
|----------|---------|
| TypeScript/JS | `inngest` |
| Python | `inngest` |
| Go | `github.com/inngest/inngestgo` |
| Kotlin/Java | `com.inngest:inngest` |

### FAQ

**Q: What is Inngest?**
A: A durable workflow orchestration platform that lets you write reliable step functions with automatic retries and state persistence. Perfect for multi-step AI pipelines.

**Q: Is Inngest free?**
A: The dev server is free and open-source. Inngest Cloud has a free tier for production use.

**Q: How is Inngest different from n8n or Temporal?**
A: Inngest is code-first (not visual like n8n) and simpler than Temporal. You write regular functions with step.run() — no workflow DSL or state machines needed.

---

## Source & Thanks

> Created by [Inngest](https://github.com/inngest). Licensed under SSPL/Apache-2.0.
>
> [Inngest](https://github.com/inngest/inngest) — ⭐ 5,200+

Thanks to the Inngest team for making reliable workflows accessible to every developer.

---

<!-- ZH -->

## Quick Use

1. Start the dev server:
```bash
npx inngest-cli@latest dev
```

2. Create durable functions (each step retries independently)

3. Dashboard at http://localhost:8288

---

## Introduction

Inngest is a durable workflow orchestration platform with 5,200+ GitHub stars. Replace queues, state management, and scheduling with durable step functions — automatic retries and state persistence. Perfect for AI workflows where every step (extract → process → save) must execute reliably. Supports TypeScript, Python, and Go SDKs.

---

## Inngest — Reliable AI Workflows

### Core Concepts

- **Durable functions** — survive failures and restarts
- **Independent steps** — each step retries independently; completed steps aren't re-run
- **Event-driven** — events trigger workflows
- **Flow control** — concurrency, throttling, debouncing, rate limiting

### FAQ

**Q: What is Inngest?**
A: A durable workflow orchestration platform — write reliable step functions with automatic retries and state persistence.

**Q: How does it differ from n8n?**
A: Inngest is code-first (not visual), simpler than Temporal, and uses step.run() to write ordinary functions.

---

## Source & Thanks

> Created by [Inngest](https://github.com/inngest). Licensed under SSPL/Apache-2.0.
>
> [Inngest](https://github.com/inngest/inngest) — ⭐ 5,200+

---
Source: https://tokrepo.com/en/workflows/inngest-durable-ai-workflow-orchestration-f09e8059
Author: Inngest