Inngest Agent Kit

Inngest Agent Kit is an open-source TypeScript framework for building event-driven, durable AI agents. Maintained by Inngest and released in 2024 under Apache 2.0, it combines an agent SDK with Inngest’s proven event-driven runtime. The framework targets teams that need production-grade reliability out of the box: automatic retries, per-step observability, and event-triggered workflows that survive crashes and deploys.

Agent Kit occupies a distinct slot in the agent orchestration space. It is not a general-purpose orchestration library like LangChain or a graph-based system like LangGraph. Instead, it layers agent primitives (agents, networks, state, routers) on top of a durable execution engine. Every step in an agent’s loop is checkpointed. If a tool call fails or a server reboots, the agent resumes from the last successful step—not from scratch. This design philosophy comes directly from Inngest’s experience building background job infrastructure for thousands of production apps.

With 863 GitHub stars, 26 contributors, and 14,219 weekly npm downloads, Agent Kit is still newer than alternatives like CrewAI or Mastra. But its growth signals genuine interest from TypeScript teams that already use Inngest and want to extend those patterns into agentic workloads.

Agent Kit is code-first and imperative. You define agents as TypeScript objects with a model, instructions, and tools. You compose them into networks that share a state machine. The core abstractions are:

• Agent: A single LLM call configured with a model, system prompt, tools (including MCP servers), and lifecycle hooks. Agents can be as simple as “call GPT-4o with these tools” or as complex as a coding agent with multiple sub-agents.
• Network: A container for multiple agents. A network runs a loop: it calls a router, which chooses the next agent to execute, then stores the result in shared state, and repeats until the router decides to stop. This is deterministic routing—not free-form agent handoff.
• State: A typed key-value store combined with conversation history. Every agent and router can read and write to state. This is how agents pass context (e.g., a search result to a summarizer).
• Router: A function that examines current state and picks the next agent (or quits). The default router uses the network’s configured LLM, but you can supply a custom router (e.g., rule-based).
• Step: Each agent call, tool invocation, and state mutation is wrapped in a durable step. Steps are memoized: if the workflow restarts after a failure, completed steps return cached results instantly.

Control flow is loop-based: network.run(userMessage) starts the loop. The router runs, an agent runs, its result updates state, then the router runs again. You can also use Inngest’s step.run() and step.invoke() inside agent tool implementations to perform durable sub-steps—like calling a third-party API and persisting the result before proceeding.

The framework supports streaming: agent responses can stream token-by-token to a UI (useful for chat interfaces). UI streaming is built into the Inngest Dev Server, which also provides local live traces and input/output logs without deploying to the cloud.

Agent Kit’s standout features come from the Inngest runtime integration.

Durable execution. Every step (LLM call, tool run, state write) is checkpointed to Inngest’s event log. If a tool throws a transient error—rate limit, network timeout—the step retries with exponential backoff. If the entire process crashes mid-loop, it resumes from the last checkpoint. This is crucial for long-running agents that process thousands of requests over hours.

Event-driven triggers. Any Inngest event source can launch an agent: webhooks (Stripe, GitHub, Slack), cron schedules, queues, or internal app events. You don’t poll or pollute your app code with agent logic. The agent becomes a passive handler that reacts to business events.

Built-in observability. The Inngest dashboard shows per-step traces, logs, and replay. You can see exactly which model call and which tool execution happened, how long each took, and what the agent’s internal state was at each point. Debugging a failed agent is as simple as clicking “replay” from the failure point.

Type safety. Agents, tools, state, and routers are fully typed. The framework infers TS types from your model provider config and tool definitions. This catches mismatched tool schemas at compile time, not in production.

Multi-agent coordination. Networks implement deterministic routing—no emergent “chit-chat” between agents. The router decides which agent to invoke next based on state. This is more predictable than freeform handoff (as in AutoGen or CrewAI) and easier to debug.

Tool calling and MCP support. Tools can be defined inline with Zod schemas or imported from MCP servers (Model Context Protocol). This lets you reuse a growing ecosystem of MCP-provided tools (file systems, databases, APIs) without writing wrappers.

Self-hostable or cloud-hosted. Run the Inngest Dev Server locally for development. For production, deploy to Inngest Cloud or self-host Inngest’s open-source runtime.

Background agent jobs. Process support tickets, review code commits, or analyze customer feedback in the background. Inngest’s durable runtime ensures each agent run completes even if the container restarts during a long LLM call.

Webhook-driven automations. Connect a GitHub “push” webhook to an agent that drafts release notes. Or a Stripe “checkout.completed” webhook to an agent that sends a personalized onboarding email series. The event bus pattern keeps your main app clean.

Multi-step content pipelines. Research, draft, review, and publish blog posts or documentation. Each step is a separate agent call with durable checkpointing. If the review agent rejects a draft, the pipeline resumes from the drafting step without losing the research output.

Internal copilots. Build support agents that query your knowledge base (via MCP tools), escalate to human agents, and log every interaction. Built-in tracing gives your team full audit trails.

The framework is a poor fit for real-time, latency-sensitive workloads (e.g., voice agents) where the overhead of checkpointing every step adds too much delay. It also doesn’t support graph-based DAGs or dynamic branching beyond the network loop—if your agent needs complex conditional flows, a graph framework like LangGraph may suit you better.

Install the package:

1npm install @inngest/agent-kit

The smallest meaningful example defines an agent, a network, and runs it:

1import { createNetwork, openai } from "@inngest/agent-kit";
2
3const searchAgent = openai({
4  model: "gpt-4o",
5  instructions: "You are a search assistant. Use the web search tool to answer questions.",
6  tools: [webSearchTool],
7});
8
9const network = createNetwork({
10  agents: [searchAgent],
11});
12
13const result = await network.run("What happened in the 2024 Super Bowl?");
14console.log(result);

You need an LLM provider API key (OpenAI, Anthropic, or any OpenAI-compatible provider). For local development, start the Inngest Dev Server (npx inngest-cli dev) to see traces and logs. No additional infrastructure is required for simple agents.

Full documentation, examples, and SDK reference are at [agentkit.inngest.com](https://agentkit.inngest.com). The GitHub repo ([github.com/inngest/agent-kit](https://github.com/inngest/agent-kit)) contains example projects for GitHub review bots, Slack integrations, and multi-agent research pipelines.

Inngest Agent Kit vs. CrewAI. CrewAI is a popular multi-agent framework with a similar “agents + tasks” model. CrewAI focuses on role-based collaboration and emergent agent-to-agent handoff. Agent Kit prioritizes deterministic routing and durable step execution. Choose CrewAI if you want more built-in role-playing patterns and are okay with simpler retry logic. Choose Agent Kit if your agents must survive failures and you already use (or want to adopt) Inngest for background jobs.

Inngest Agent Kit vs. LangChain/LangGraph. LangChain’s ecosystem is vast: hundreds of integrations, graph-based orchestration, and evaluation tools. Agent Kit is narrower but deeper in reliability. LangGraph gives you full control over DAGs and cycles; Agent Kit gives you a single network loop with retries. If you need complex branching or state machines, LangGraph is more flexible. If you need bulletproof production deploys and event-driven triggers, Agent Kit’s runtime saves you months of building that infrastructure yourself.

Inngest Agent Kit vs. Mastra. Mastra is a newer TypeScript agent framework that also emphasizes observability and type safety. Mastra uses a more traditional function-calling model. Agent Kit’s differentiator is the event-driven, durable runtime. Mastra is easier to try out quickly; Agent Kit requires understanding Inngest’s event model. For teams already comfortable with Inngest, Agent Kit is the natural extension. For newcomers, the Inngest learning curve may be a barrier.

In both comparisons, Agent Kit’s smaller community and younger age are the main risks. But its tight integration with a battle-tested execution engine makes it a strong choice for teams that prioritize reliability over ecosystem breadth.