Durable AI Workflow & Agent Queue Benchmark: Inngest, Hatchet, Trigger.dev, Temporal, Mastra & LangGraph

3.1 Inngest (`github.com/inngest/inngest` — `go 1.26.4`)

Repository & Build Inspection (Oct 24, 2026): Inngest’s core orchestration server is written in Go (`go 1.26.4` in `go.mod`), leveraging `connectrpc.com/connect v1.16.1`, `github.com/99designs/gqlgen v0.17.27`, `github.com/coder/websocket v1.8.14`, and `cuelang.org/go v0.4.2` for schema/expression evaluation, paired with the Next.js/React dashboard in `ui/apps/dashboard/package.json` (`@inngest/dashboard`).[S1]

• Architectural Differentiator (`step.ai.infer`): In serverless deployments, waiting 45 seconds for an LLM reasoning call inside a Vercel or AWS Lambda function wastes compute wall-clock billing and risks HTTP timeouts. Inngest’s `step.ai.infer()` offloads the HTTP request to Inngest’s proxy layer and resumes the worker function only when the completion payload returns, recording token usage and prompt/response telemetry automatically.[S2]
• Control-Path & Dependency Observation: `go.mod` pins `connectrpc.com/connect v1.16.1` (whereas Hatchet runs `v1.21.0`). When running Inngest in hybrid cloud-to-VPC mode via `connect()`, ensure worker signing keys (`INNGEST_SIGNING_KEY`) are rotated per environment and never shared between staging and production workers.

3.2 Hatchet (`github.com/hatchet-dev/hatchet` — `go 1.26.10`)

Repository & Build Inspection (Oct 24, 2026): Hatchet’s engine (`go 1.26.10`) links `connectrpc.com/connect v1.21.0`, `github.com/docker/docker v28.5.2+incompatible`, `github.com/docker/go-sdk/context v0.1.0-alpha013`, and notably `github.com/doyensec/safeurl v0.2.x`, alongside its Vite/TypeScript dashboard (`frontend/app/package.json`, `pnpm@10.16.1`).[S5]

• Architectural Differentiator (Postgres-Backed High-Throughput DAGs + Fairness): Unlike HTTP-push orchestrators, Hatchet maintains persistent gRPC streams between workers and the engine, achieving 5–18 ms step dispatch latency and native `GROUP_ROUND_ROBIN` concurrency strategies so one noisy enterprise customer queueing 50,000 agent tasks cannot starve other tenants.[S6]
• Security Signal (`doyensec/safeurl`): Hatchet’s inclusion of `doyensec/safeurl` in `go.mod` demonstrates strong SSRF awareness on outbound webhook/HTTP calls—blocking DNS rebinding and RFC1918 private IP targets by default.[S5]

3.4 Deep-Dive Failure Mode Matrix: Serverless HTTP Push vs. Long-Polled gRPC Streams

When evaluating workflow orchestrators at 10M–50M monthly steps, the single most expensive architectural mistake is mismatching the transport protocol to the step duration distribution:

• The Serverless Double-Billing Trap (HTTP Push Without `step.ai.infer`): When an HTTP-pushed step function runs on Vercel Functions, AWS Lambda, or Cloudflare Workers and invokes an LLM streaming call (`gpt-5`, `claude-4-5-sonnet`, or `grok-4`) that takes 38 seconds, the customer pays for 38 seconds of serverless wall-clock compute plus the orchestrator step execution fee. Inngest solves this with `step.ai.infer()` (proxying the LLM HTTP request outside worker compute), whereas Trigger.dev v3 solves it by checkpointing the container via CRIU during `wait.forToken()` or child task waits.[S2][S8]
• The Connection-Pool Exhaustion Trap (Fan-Out Spikes): If a single parent event fans out into 2,500 parallel child steps (`step.run` or `triggerAndWait`), HTTP-push engines will immediately fire up to `concurrency.limit` concurrent webhook POST requests against your application ingress. Without per-tenant concurrency keys (`concurrency: [{ scope: "account", key: "event.data.tenantId", limit: 10 }]`), those 2,500 requests saturate PgBouncer / RDS connection pools within 400 milliseconds.
• The Persistent gRPC Stream Advantage (`hatchet-dev/hatchet` & `temporalio/temporal`): Because Hatchet (`connectrpc.com/connect v1.21.0`) and Temporal workers pull tasks over persistent multiplexed HTTP/2 gRPC connections based on available worker slot capacity (`maxRuns`), workers never suffer inbound webhook DDoS or TLS handshake storms during traffic spikes, and can run entirely inside private NAT subnets with zero public inbound ports.[S5][S10]

// INNGEST PRODUCTION PATTERN: ZERO-COMPUTE LLM OFFLOAD + PER-TENANT CONCURRENCY FAIRNESS
import { Inngest } from "inngest";
const inngest = new Inngest({ id: "gridfleet-agent-fleet" });

export const runCustomerResearchStep = inngest.createFunction(
  {
    id: "customer-research-workflow",
    // Enforce strict per-tenant concurrency fairness so 1 tenant cannot starve the fleet
    concurrency: [
      { scope: "account", limit: 50 },
      { scope: "fn", key: "event.data.organizationId", limit: 5 }
    ],
    retries: 4,
  },
  { event: "research/report.requested" },
  async ({ event, step }) => {
    // Step 1: Deterministic lockfile & manifest fetch
    const manifest = await step.run("fetch-public-manifest", async () => {
      return await fetchRepoManifest(event.data.repoUrl);
    });

    // Step 2: Offload long-running LLM synthesis to Inngest proxy ($0 idle worker compute)
    const analysis = await step.ai.infer("synthesize-cve-posture", {
      model: step.ai.models.openai({ model: "gpt-4o" }),
      body: {
        messages: [
          { role: "system", content: "You are a principal security auditor. Cite exact package versions." },
          { role: "user", content: JSON.stringify(manifest) }
        ],
        temperature: 0.1,
      },
    });

    // Step 3: Human review pause (waits up to 72h at $0 compute until reviewer approves)
    const approval = await step.waitForEvent("wait-for-human-qa", {
      event: "research/report.qa_approved",
      timeout: "72h",
      match: "data.reportId",
    });

    return { status: approval ? "published" : "qa_timeout", analysis };
  }
);

3.3 Trigger.dev v3 (`github.com/triggerdotdev/trigger.dev`)

Architectural Differentiator (Container Checkpoint/Restore): Trigger.dev v3 compiles TypeScript tasks into isolated container runs. When a task calls `wait.forToken()`, `wait.for({ seconds: 3600 })`, or invokes a sub-task with `triggerAndWait()`, Trigger.dev checkpoints the container state and pauses billing until the resume signal arrives—making it ideal for tasks that combine FFmpeg/Playwright/PDF binaries with LLM calls.[S8][S9]

4.1 Temporal (`github.com/temporalio/temporal`)

Temporal remains the gold standard for mission-critical distributed state machines where every workflow state transition is reconstructed via deterministic event-history replay.[S10] However, for rapid AI agent iteration, Temporal requires strict separation between deterministic Workflow code (which cannot make network calls, read system time, or import non-deterministic libraries) and non-deterministic Activities—adding onboarding friction compared to Inngest or Hatchet.

4.2 Mastra (`github.com/mastra-ai/mastra` — `@mastra/core@1.80.0-alpha.2`)

Repository & Build Inspection (Oct 24, 2026): Inspected `packages/core/package.json` (`@mastra/core@1.80.0-alpha.2`). Mastra exposes dedicated Agent-to-Agent (`./a2a`, `./a2a/client`, `./a2a/v1`) entrypoints backed simultaneously by `@a2a-js/sdk@~0.3.14` and `@a2a-js/sdk@~1.0.1`, alongside `execa@^9.6.1`, `fastq@^1.20.1`, `croner@^10.0.1`, and bridges for `@ai-sdk/provider-v5`, `v6`, and `v7`.[S13]

• Architectural Role: Mastra is best deployed as the TypeScript Agent & A2A SDK layer rather than a standalone distributed queue at 50M steps/month. Pairing Mastra’s agent/tool abstractions with Inngest or Hatchet for durable distributed step execution gives teams both ergonomic TypeScript agent authoring and battle-tested queue durability.

4.3 LangGraph Platform (`github.com/langchain-ai/langgraph`)

LangGraph models cyclic agent workflows as Pregel-inspired state graphs with first-class Postgres checkpointers, streaming token/state updates, and human-in-the-loop `interrupt()` primitives.[S16] While the open-source `langgraph` library is MIT-licensed and free to self-host, managed LangGraph Platform Cloud charges per node/step execution plus standby compute instance hours.[S17]