New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Inngest Flow Control

by Asymmetric-al in Asymmetric-al/core

A skill your agent uses when handling external API rate limits (e.g., OpenAI 429s, HubSpot or Stripe rate limits), preventing duplicate work from rapid event bursts (debouncing user actions)…

AGPL-3.0Auto-check passedBackend & APIs

Install Inngest Flow Control

skills CLI
$ npx skills add Asymmetric-al/core --skill inngest-flow-control -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Asymmetric-al/core inngest-flow-control --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/Asymmetric-al/core.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/inngest-flow-control .claude/skills/inngest-flow-control && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
inngest-flow-control
GitHub stars
381
Token cost
~2.5k tokens
SKILL.md length
560 words
Files
1
Skills in repo
43
Repo updated
First seen
Licence
AGPL-3.0

At a glance

A skill your agent uses when handling external API rate limits (e.g., OpenAI 429s, HubSpot or Stripe rate limits), preventing duplicate work from rapid event bursts (debouncing user actions)…

  • Works in 4 steps: Confirm whether the request is… → Use inngest-brownfield-audit before… → Follow this upstream guidance under… → …
  • Handling external API rate limits (e.g.
  • SKILL.md covers Quick Decision Guide, Concurrency, Throttling and Rate Limiting, plus 9 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Inngest Flow Control is an agent skill from Asymmetric-al/core. Use when handling external API rate limits (e.g., OpenAI 429s, HubSpot or Stripe rate limits), preventing duplicate work from rapid event bursts (debouncing user actions), spreading load over time, ensuring per-tenant fairness, processing events in batches, limiting concurrent runs of the same operation, or assigning priority to important runs. Covers Inngest flow control: concurrency limits with keys, throttling, rate limiting, debounce, priority, singleton, and event batching.

Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Backend & APIs, covering Rate limiting. It works with OpenAI, HubSpot and Stripe. The repository describes itself as: A high-performance, enterprise-grade Next.js 16 application for mission-focused non-profit organizations. Built for high impact teams. The licence is AGPL-3.0.

When your agent uses it

  • Handling external API rate limits (e.g.
  • Stripe rate limits)
  • Preventing duplicate work from rapid event bursts (debouncing user actions)
  • Spreading load over time

Example prompts

  • “/inngest-flow-control”

Requirements

  • Python 3

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Confirm whether the request is agent-tooling guidance or product runtime
  2. Use inngest-brownfield-audit before changing existing app workflows or
  3. Follow this upstream guidance under OpenSpec, root AGENTS.md, repo
  4. Keep runtime packages, app code, migrations, and INNGEST_* env

What it can do on your machine

Read from SKILL.md and the folder at commit c30c8ff. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are typescript).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • inngest.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Inngest Flow Control loads about 2.5k tokens when it runs. Until then it costs about 126 tokens; SKILL.md has 560 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~126
When it runs · the whole SKILL.md, loaded when a task matches
~2.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from Asymmetric-al/core at commit c30c8ff, republished under its AGPL-3.0 licence (© Asymmetric-al). 560 words, ~2,528 tokens.

Download SKILL.mdSave it as .claude/skills/inngest-flow-control/SKILL.md (or your agent's skills folder).
name
inngest-flow-control
description
Use when handling external API rate limits (e.g., OpenAI 429s, HubSpot or Stripe rate limits), preventing duplicate work from rapid event bursts (debouncing user actions), spreading load over time, ensuring per-tenant fairness, processing events in batches, limiting concurrent runs of the same operation, or assigning priority to important runs. Covers Inngest flow control: concurrency limits with keys, throttling, rate limiting, debounce, priority, singleton, and event batching.

Inngest Flow Control

Master Inngest flow control mechanisms to manage resources, prevent overloading systems, and ensure application reliability. This skill covers all flow control options with prescriptive guidance on when and how to use each.

These skills are focused on TypeScript. For Python or Go, refer to the Inngest documentation for language-specific guidance. Core concepts apply across all languages.

Quick Decision Guide

  • "Limit how many run at once" → Concurrency
  • "Spread runs over time" → Throttling
  • "Block after N runs in a period" → Rate Limiting
  • "Wait for activity to stop, then run once" → Debounce
  • "Only one run at a time for this key" → Singleton
  • "Process events in groups" → Batching
  • "Some runs are more important" → Priority

Concurrency

When to use: Limit the number of executing steps (not function runs) to manage computing resources and prevent system overwhelm.

Key insight: Concurrency limits active code execution, not function runs. A function waiting on step.sleep() or step.waitForEvent() doesn't count against the limit.

Basic Concurrency
typescript
inngest.createFunction(
  {
    id: "process-images",
    concurrency: 5,
    triggers: [{ event: "media/image.uploaded" }],
  },
  async ({ event, step }) => {
    // Only 5 steps can execute simultaneously
    await step.run("resize", () => resizeImage(event.data.imageUrl));
  },
);
Concurrency with Keys (Multi-tenant)

Use key parameter to apply limit per unique value of the key.

typescript
inngest.createFunction(
  {
    id: "user-sync",
    concurrency: [
      {
        key: "event.data.user_id",
        limit: 1,
      },
    ],
    triggers: [{ event: "user/profile.updated" }],
  },
  async ({ event, step }) => {
    // Only 1 step per user can execute at once
    // Prevents race conditions in user-specific operations
  },
);
Account-level Shared Limits
typescript
inngest.createFunction(
  {
    id: "ai-summary",
    concurrency: [
      {
        scope: "account",
        key: `"openai"`,
        limit: 60,
      },
    ],
    triggers: [{ event: "ai/summary.requested" }],
  },
  async ({ event, step }) => {
    // Share 60 concurrent OpenAI calls across all functions
  },
);

When to use each:

  • Basic: Protect databases or limit general capacity
  • Keyed: Multi-tenant fairness, prevent "noisy neighbor" issues
  • Account-level: Share quotas across multiple functions (API limits)

Throttling

When to use: Control the rate of function starts over time to work around API rate limits or smooth traffic spikes.

Key difference from concurrency: Throttling limits function run starts; concurrency limits step execution.

typescript
inngest.createFunction(
  {
    id: "sync-crm-data",
    throttle: {
      limit: 10, // 10 function starts
      period: "60s", // per minute
      burst: 5, // plus 5 immediate bursts
      key: "event.data.customer_id", // per customer
    },
    triggers: [{ event: "crm/contact.updated" }],
  },
  async ({ event, step }) => {
    // Respects CRM API rate limits: 10 calls/min per customer
    await step.run("sync", () => crmApi.updateContact(event.data));
  },
);

Configuration:

  • limit: Functions that can start per period
  • period: Time window (1s to 7d)
  • burst: Extra immediate starts allowed
  • key: Apply limits per unique key value

Rate Limiting

When to use: Hard limit to prevent abuse or skip excessive duplicate events.

Key difference from throttling: Rate limiting discards events; throttling delays them.

typescript
inngest.createFunction(
  {
    id: "webhook-processor",
    rateLimit: {
      limit: 1,
      period: "4h",
      key: "event.data.webhook_id",
    },
    triggers: [{ event: "webhook/data.received" }],
  },
  async ({ event, step }) => {
    // Process each webhook only once per 4 hours
    // Prevents duplicate webhook spam
  },
);

Use cases:

  • Prevent webhook duplicates
  • Limit expensive operations per user
  • Protection against abuse

Debounce

When to use: Wait for a series of events to stop arriving before processing the latest one.

typescript
inngest.createFunction(
  {
    id: "save-document",
    debounce: {
      period: "5m", // Wait 5min after last edit
      key: "event.data.document_id",
      timeout: "30m", // Force save after 30min max
    },
    triggers: [{ event: "document/content.changed" }],
  },
  async ({ event, step }) => {
    // Saves document only after user stops editing
    // Uses the LAST event received
    await step.run("save", () => saveDocument(event.data));
  },
);

Perfect for:

  • User input that changes rapidly (search, document editing)
  • Noisy webhook events
  • Ensuring latest data is processed
Show full SKILL.md (221 more words)Show less

Priority

When to use: Execute some function runs ahead of others based on dynamic data.

typescript
inngest.createFunction(
  {
    id: "process-order",
    priority: {
      // VIP users get priority up to 120 seconds ahead
      run: "event.data.user_tier == 'vip' ? 120 : 0",
    },
    triggers: [{ event: "order/placed" }],
  },
  async ({ event, step }) => {
    // VIP orders jump ahead in the queue
  },
);

Advanced example:

typescript
inngest.createFunction(
  {
    id: "support-ticket",
    priority: {
      run: `
        event.data.severity == 'critical' ? 300 :
        event.data.severity == 'high' ? 120 :
        event.data.user_plan == 'enterprise' ? 60 : 0
      `,
    },
    triggers: [{ event: "support/ticket.created" }],
  },
  async ({ event, step }) => {
    // Critical tickets get highest priority (300s ahead)
    // High severity: 120s ahead
    // Enterprise users: 60s ahead
    // Everyone else: normal priority
  },
);

Singleton

When to use: Ensure only one instance of a function runs at a time.

Skip Mode (Preserve Current Run)
typescript
inngest.createFunction(
  {
    id: "data-backup",
    singleton: {
      key: "event.data.database_id",
      mode: "skip",
    },
    triggers: [{ event: "backup/requested" }],
  },
  async ({ event, step }) => {
    // Skip new backups if one is already running for this database
    await step.run("backup", () => performBackup(event.data.database_id));
  },
);
Cancel Mode (Use Latest Event)
typescript
inngest.createFunction(
  {
    id: "realtime-sync",
    singleton: {
      key: "event.data.user_id",
      mode: "cancel",
    },
    triggers: [{ event: "user/data.changed" }],
  },
  async ({ event, step }) => {
    // Cancel previous sync and start with latest data
    await step.run("sync", () => syncUserData(event.data));
  },
);

Batching

When to use: Process multiple events together for efficiency.

typescript
inngest.createFunction(
  {
    id: "bulk-email-send",
    batchEvents: {
      maxSize: 100, // Up to 100 events
      timeout: "30s", // Or 30 seconds, whichever first
      // `key` groups events into separate batches per unique value
      // This is different from expressions `if` which filters events
      key: "event.data.campaign_id", // Batch per campaign
    },
    triggers: [{ event: "email/send.queued" }],
  },
  async ({ events, step }) => {
    // Process array of events together
    const emails = events.map((evt) => ({
      to: evt.data.email,
      subject: evt.data.subject,
      body: evt.data.body,
    }));

    await step.run("send-batch", () => emailService.sendBulk(emails));
  },
);

Combining Flow Control

Example: Fair AI Processing
typescript
inngest.createFunction(
  {
    id: "ai-image-processing",
    // Global throttling for API limits
    throttle: {
      limit: 50,
      period: "60s",
      key: `"gpu-cluster"`,
    },
    // Per-user concurrency for fairness
    concurrency: [
      {
        key: "event.data.user_id",
        limit: 3,
      },
    ],
    // VIP users get priority
    priority: {
      run: "event.data.plan == 'pro' ? 60 : 0",
    },
    triggers: [{ event: "ai/image.generate" }],
  },
  async ({ event, step }) => {
    // Combines multiple flow controls for optimal resource usage
  },
);

Pro tip: Most production functions benefit from combining 1-3 flow control mechanisms for optimal reliability and performance.

This Repository

These upstream Inngest instructions are vendored for agent tooling and integration work in this monorepo.

Repository Triggers

Use this skill when inngest-flow-control matches the current Inngest task. If the right skill is unclear, start with docs/ai/skills/inngest/SKILL.md.

Repository Workflow

  1. Confirm whether the request is agent-tooling guidance or product runtime integration.
  2. Use inngest-brownfield-audit before changing existing app workflows or fragile background work.
  3. Follow this upstream guidance under OpenSpec, root AGENTS.md, repo rulebooks, framework docs, and runtime evidence.
  4. Keep runtime packages, app code, migrations, and INNGEST_* env requirements out of agent-tooling-only changes.

Repository Checklist

  • The task has explicit product-runtime scope before adding Inngest app code or dependencies.
  • Existing workflows were audited before introducing or changing durable workflow behavior.
  • Any MCP usage is backed by a running Inngest dev server on the configured port.
  • Upstream source and license attribution remain documented in docs/ai/skills/inngest/references/upstream.md.

© Asymmetric-al, AGPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/inngest-flow-control of Asymmetric-al/core.

Open the folder on GitHubat commit c30c8ff

Compare with similar skills

Inngest Flow Control next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Inngest Flow Control compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Inngest Flow Control this skillAsymmetric-al/core381—~2.5kAutomated safety check: PassAGPL-3.0
Stripe Best Practiceskanchengw/cnllm1732 repos~925Automated safety check: PassApache-2.0
Auth Architecturemajiayu000/litellm-rs118—~1.9kAutomated safety check: PassMIT
LLM Gatewaysickn33/agentic-awesome-skills47k1 repos~2.1kAutomated safety check: PassMIT
Openrouter Rate Limitsjeremylongshore/tons-of-skills-marketplace2.8k—~2.4kAutomated safety check: PassMIT
API ForgeEliasOulkadi/shokunin114—~2.9kAutomated safety check: PassMIT

Similar skills

  • Stripe Best Practices

    kanchengw/cnllm

    Guides Stripe integration decisions — API selection (Checkout Sessions vs PaymentIntents), Connect platform setup (Accounts v2, controller properties), billing/subscriptions, Treasury financial…

    173 GitHub starsUsed in 2 repos~925 tokens
    Backend & APIsAuto-check passed

  • Auth Architecture

    majiayu000/litellm-rs

    LiteLLM-RS Authentication Architecture. An agent skill from majiayu000/litellm-rs.

    118 GitHub stars~1.9k tokensUpdated today
    Backend & APIsAuto-check passed

  • LLM Gateway

    sickn33/agentic-awesome-skills

    Deploy an API gateway for LLM traffic with load balancing, rate limiting, key management, semantic caching, fallback routing, and cost tracking.

    47k GitHub starsUsed in 1 repo~2.1k tokens
    Backend & APIsAuto-check passed

  • Openrouter Rate Limits

    jeremylongshore/tons-of-skills-marketplace

    Understand and handle OpenRouter rate limits. An agent skill from jeremylongshore/tons-of-skills-marketplace.

    2.8k GitHub stars~2.4k tokensUpdated yesterday
    Backend & APIsAuto-check passed

  • API Forge

    EliasOulkadi/shokunin

    Design REST/GraphQL APIs with OpenAPI 3.1, error handling, pagination, rate limiting, webhooks, and idempotency.

    114 GitHub stars~2.9k tokensUpdated 6 days ago
    Backend & APIsAuto-check passed

  • Venice Errors

    veniceai/skills

    Handle Venice API errors correctly. An agent skill from veniceai/skills.

    144 GitHub stars~4.9k tokensUpdated 5 days ago
    Backend & APIsAuto-check passed

More from Asymmetric-al/core

All 43 skills in this repo

  • Idempotency Handling

    Asymmetric-al/core

    Implement idempotency keys and handling to ensure operations can be safely retried without duplicate effects.

    381 GitHub stars~867 tokensUpdated today
    Auto-check passed

  • Accessibility Review

    Asymmetric-al/core

    Audit and fix accessibility in Core UI. An agent skill from Asymmetric-al/core.

    381 GitHub stars~1.1k tokensUpdated today
    Auto-check passed

  • Agent Email Inbox

    Asymmetric-al/core

    A skill your agent uses when building any system where email content triggers actions — AI agent inboxes, automated support handlers, email-to-task pipelines, or any workflow processing untrusted…

    381 GitHub stars~4.1k tokensUpdated today
    Auto-check: notes

  • Components Build

    Asymmetric-al/core

    Build modern, composable, and accessible React UI components following the components.build specification.

    381 GitHub stars~2.1k tokensUpdated today
    Auto-check passed

  • Create Agent

    Asymmetric-al/core

    Guides a one-question-at-a-time design interview, captures alignment in agent/EVE-BRIEF.md, then scaffolds and implements a runnable eve agent with verbose teaching comments.

    381 GitHub stars~2.6k tokensUpdated today
    Auto-check: notes

  • Emil Design Engineering

    Asymmetric-al/core

    Design engineering principles and patterns for building polished, accessible web interfaces.

    381 GitHub stars~1.4k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Inngest Flow Control

What does Inngest Flow Control do?

A skill your agent uses when handling external API rate limits (e.g., OpenAI 429s, HubSpot or Stripe rate limits), preventing duplicate work from rapid event bursts (debouncing user actions)…. Inngest Flow Control is an agent skill from Asymmetric-al/core., OpenAI 429s, HubSpot or Stripe rate limits), preventing duplicate work from rapid event bursts (debouncing user actions), spreading load over time, ensuring per-tenant fairness, processing events in batches, limiting concurrent runs of the same operation, or assigning priority to important runs.

When should I use Inngest Flow Control?

Inngest Flow Control fits situations like: handling external API rate limits (e.g; stripe rate limits); preventing duplicate work from rapid event bursts (debouncing user actions); spreading load over time.

How do I install Inngest Flow Control in Claude Code?

Run `npx skills add Asymmetric-al/core --skill inngest-flow-control -a claude-code`. Or copy the skill folder (.agents/skills/inngest-flow-control in Asymmetric-al/core) into .claude/skills/inngest-flow-control in your project. Claude Code loads it when a task matches its description.

How do I install Inngest Flow Control in Codex?

Run `npx skills add Asymmetric-al/core --skill inngest-flow-control -a codex`. Or copy the skill folder (.agents/skills/inngest-flow-control in Asymmetric-al/core) into .agents/skills/inngest-flow-control in your project. Codex loads it when a task matches its description.

Can I use Inngest Flow Control in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Asymmetric-al/core --skill inngest-flow-control -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/inngest-flow-control, .gemini/skills/inngest-flow-control, .github/skills/inngest-flow-control and .opencode/skills/inngest-flow-control in your project.

What does Inngest Flow Control need to run?

SKILL.md names no scripts, command-line tools or credentials: Inngest Flow Control is instructions for the agent only. Our summary lists: Python 3.

Does Inngest Flow Control access the network?

SKILL.md names 1 domain. As links in the text: inngest.com. This is read from the text; nothing was executed.

Is Inngest Flow Control safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Inngest Flow Control use?

Inngest Flow Control is published under the AGPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Inngest Flow Control use?

About 2.5k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Inngest Flow Control?

Skills that share tags, products or a category with Inngest Flow Control: Stripe Best Practices (kanchengw/cnllm, 173 stars), Auth Architecture (majiayu000/litellm-rs, 118 stars), LLM Gateway (sickn33/agentic-awesome-skills, 47k stars) and Openrouter Rate Limits (jeremylongshore/tons-of-skills-marketplace, 2.8k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Inngest Flow Control?

Asymmetric-al (a GitHub organization) maintains it in Asymmetric-al/core, which has 381 GitHub stars. The repository holds 43 skills in this directory. The repository was last updated on October 9, 2026.

Source: Asymmetric-al/core on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.