Kryptonite — Autonomous AI Workflow Builder

Build
Connect
Demo
Deploy
Features
Landing page

Inspiration

Most workflow automation tools — Zapier, Make, n8n — treat every step as an isolated box: trigger fires, API call happens, data moves on. That model works fine for simple integrations, but it falls apart the moment you want reasoning baked into a workflow instead of just plumbing.

We wanted to see what happens if you replace the "isolated API step" model with a shared workspace where AI agents actually collaborate — reading each other's outputs, building on each other's reasoning, and passing context downstream the way a team of humans would in a group chat. That's the core idea behind Kryptonite: a visual, drag-and-drop canvas where nodes aren't just functions, they're autonomous agents with a live transcript.

What it does

Kryptonite is an open-source workflow automation platform built around three ideas:

Visual canvas. Built on React Flow, you drag out triggers (cron, webhook, Stripe, Google Forms), AI agent nodes, and action nodes, and wire them into multi-branch graphs.
Multi-agent collaboration via Band.ai. Every workflow run that touches an AI node spins up a live Band room. Agents post their prompts, intermediate thoughts, and outputs into a shared transcript, and downstream nodes pull context forward using Handlebars templating (e.g. {{openaiAgent.text}}). It's less "function chaining" and more "agents talking to each other in a room."
Model flexibility for free. AI nodes run through OpenRouter, so a workflow can mix Llama 3.3, DeepSeek R1, and Gemma 3 with automatic fallback chains — all on free-tier models, so anyone can run the whole thing without paying for API access.

On top of that: 30+ native nodes across triggers, AI/agent execution, messaging (Slack, Discord, Telegram, WhatsApp, Twitter/X, Instagram, LinkedIn, Notion), notifications (Resend, Twilio), and data utilities (summarization, classification, text splitting + vector store for RAG).

How we built it

Frontend: Next.js 15 + React Flow for the canvas, Tailwind CSS v4 for styling.
Backend: Node execution happens server-side via /api/workflows/[id]/nodes/[nodeId]/execute-step, so credentials and API keys never touch the client.
Execution engine: A topological-sort based runner (src/lib/run-workflow.ts) analyzes the graph, groups independent nodes into parallel execution levels, and resolves Handlebars expressions against upstream outputs before running each step.
Timeout mitigation: Vercel serverless functions cap out at 10s (Hobby) / 300s (Pro), which is a hard wall for long multi-agent reasoning chains. We built a standalone VPS worker (worker/server.ts) that the Vercel route can delegate to when WORKER_URL is configured, so long-running workflows aren't capped by serverless limits.
Auth & data: Better Auth handles JWT session cookies and credential encryption; Neon serverless Postgres (via Prisma) stores workflow graphs, run history, and node state.
Scheduling: Cron-based triggers use cron-parser combined with Inngest for reliable recurring execution.

Challenges we ran into

Serverless timeouts vs. multi-agent reasoning loops. A workflow with several chained agents easily blows past Vercel's function limits. Splitting execution across a "fast path" (self-call) and a "slow path" (VPS worker) — decided per-workflow based on whether WORKER_URL is set — took several iterations to get right without duplicating state.
Context passing between agents. Getting Handlebars-style templating to reliably resolve nested/partial outputs from upstream nodes (especially across parallel execution levels) required rethinking how the merged state payload was structured.
Free-tier model reliability. Free OpenRouter models occasionally rate-limit or go cold; building automatic fallback chains so a workflow doesn't just die mid-run was necessary to keep the whole thing usable without a paid API key.
Security boundaries. Making sure node execution — especially arbitrary HTTP Request nodes — stays server-side and rate-limited so the visual builder can't be turned into an SSRF vector.

What we learned

Treating AI agents as participants in a shared, persistent transcript (rather than stateless function calls) makes multi-step reasoning workflows dramatically easier to debug and reason about.
Topological execution planning is the right abstraction for "some nodes can run in parallel, some can't" — much cleaner than manually sequencing everything.
Serverless platforms are great until your workflow needs to think for more than a few seconds; having an escape hatch (the VPS worker) instead of forcing everything into short-lived functions matters a lot for real agentic workloads.

What's next for Kryptonite

More native integrations (calendar, CRM, and payment nodes)
A visual debugger that replays a workflow run node-by-node against its Band room transcript
Shared/marketplace workflow templates so people can fork and remix each other's agent graphs