03 — Open Source Automation

OpenFlowX

An open-source, no-code automation engine. Design workflows visually and orchestrate event-driven logic with native AI agents using a durable DAG execution architecture.

Next.js App Router tRPC Inngest Prisma + PostgreSQL React Flow Vercel AI SDK Better Auth
Live site Demo GitHub ↗
The challenge

Automation without
the boilerplate.

Problem

Platforms like Zapier are expensive at scale, while open-source alternatives like n8n require complex self-hosting infrastructure that most developers want to avoid. Furthermore, seamlessly injecting modern AI reasoning into standard API workflows is still highly experimental and prone to failure.

Building a robust automation engine from scratch requires solving hard distributed systems problems: directed acyclic graph (DAG) traversal, conditional branch pruning, state checkpointing, and idempotent retries.

Solution

OpenFlowX is a fully open-source visual automation builder powered by a durable execution engine. It allows developers and non-technical users to orchestrate tasks across APIs, webhooks, and AI models via a clean React Flow canvas.

By leveraging Inngest for background execution, the system serializes workflow state at every node boundary. This ensures complete idempotency, meaning failed HTTP calls or AI timeouts can be instantly resumed without re-running the entire workflow.

MIT open source license
DAG workflow architecture
30+ integrations & nodes
System design

Architecture diagram

An event-driven execution engine processes DAGs, utilizing Inngest to safely step through nodes and pass serializable context.

Webhook Triggers Stripe · Polar · Custom
+
Schedule & APIs cron · Telegram API
↓
Inngest Engine durable execution functions
⟷
DAG Traverser topological sort · branch prune
⟷
Prisma (PostgreSQL) state checkpointing
↓
AI SDK Nodes OpenAI · DeepSeek · Anthropic
Action Nodes HTTP · Discord · Resend
Logic Nodes If/Else · Code Sandbox
↓
Next.js + tRPC typesafe frontend api
⟷
React Flow Canvas live node status tracking
Interface

Screenshots

openflowx.run
Marketing Landing Page
High-conversion entry point detailing capabilities, available AI integrations, and open-source deployment instructions.
Workflow Editor Dashboard
React Flow-based drag-and-drop canvas allowing users to connect triggers, AI logic, and conditional branching visually.
Execution Logs & Configuration
Per-node step logs showing inputs, API responses, generated text, and real-time step duration metrics.
Engineering

Technical deep-dive

01
Durable DAG Execution via Inngest
To prevent complex workflows from failing halfway through due to a server crash, I implemented a custom DAG traverser wrapping Inngest's `step.run()`. The engine performs a topological sort on the nodes, executing them sequentially. Because every node boundary is an Inngest step, execution states are perfectly checkpointed, allowing safe, idempotent retries on failure.
const sorted = await step.run("toposort", () =>
topologicalSort(nodes, connections)
);
02
Dynamic AI Tool Injection
The AI Agent node doesn't just generate text—it uses a ReAct loop to interact with the graph. The engine parses incoming connections to the Agent node, identifies available tool nodes (like Web Search or GitHub API), and dynamically injects them into the Vercel AI SDK context. This allows an LLM to autonomously call other nodes in your canvas as functions.
agent.data = {
...agent.data,
connectedTools: extractTools(incoming)
};
03
Real-time Node Status Channels
Users need to see their workflow executing live. Rather than polling the database, the backend uses Inngest event publishing (`step.publish`) combined with custom channels (e.g., `openAIChannel().status()`). This pushes granular, real-time node states (Loading, Success, Failed) directly to the Next.js React Flow UI via SSE or WebSockets.
await publish(
openAIChannel().status({ nodeId, status: "success" })
);
04
Conditional Pruning & Security
OpenFlowX supports logical branching (If/Else). When a condition fails, a reachability algorithm (`disableSubtree`) recursively traverses the DAG to safely prune and skip all downstream nodes. Furthermore, to support safe self-hosting, all user API credentials (OpenAI, Stripe) are symmetrically encrypted before entering the PostgreSQL database and decrypted only inside the execution worker.
if (!shouldRun) {
disableSubtree(c.toNodeId, connections, currentDisabled);
}
Previous ViralRot AI Video · Distributed GPU Next SketchWiz AI Canvas · WebSockets