Open-source · Self-hostable · MIT License

Your AI pipelines deserve
the same rigor
as your code.

Waiflo is a versionable JSON standard for multi-step AI workflows — with a visual editor, a REST API, and zero vendor lock-in. Ship AI features faster without losing control.

⬡ Open Editor — no signup ★ GitHub ⚡ Quickstart
Git-friendly JSON workflows Self-hosted, your infra API-first, integrates anywhere Works with any LLM provider
Sound familiar?
Prompts in application code
Impossible to version, test, or reuse
Your LLM logic lives in a Python script, a string constant, or a config file that nobody dares touch. No structure. No contracts between steps. No visibility on what changed.
LangChain / LlamaIndex
Powerful, but you're locked into their abstractions
You're writing their code, not yours. Upgrades break things. The pipeline logic is hidden in Python objects, not in a file you can read, diff, or deploy independently.
Dify / Flowise / n8n
Visual but opaque — no Git, no API, no control
Great for prototyping. Terrible for production. Your workflows live in a database you can't version. The vendor is between you and your own logic.
The Waiflo way

One JSON file.
The full pipeline.

Define steps, wire them together, run the whole thing with a single API call. Every workflow is a plain .waiflo.json file you can commit, review, and deploy like any other artifact.

support_triage.waiflo.json git diff-able · CI/CD ready 
{
  "lang_name": "support_triage",
  "steps": [
    {
      "ws_name":             "classify_ticket",
      "ws_type":             "prompt",
      "ws_llm":              { "provider": "anthropic", "model": "claude-sonnet-4-20250514", "temperature": 0 },
      "ws_system_prompt":    "You are a support triage expert. Classify tickets with high precision.",
      "ws_inputs_schema":    { "required": ["ticket_body"], "properties": { "ticket_body": { "type": "string" } } },
      "ws_output_schema":    { "properties": { "priority": { "type": "string" }, "category": { "type": "string" } } }
    },
    {
      "ws_name": "enrich_customer",  "ws_type": "api",
      "ws_api":  { "method": "GET", "url": "https://crm.internal/customers/" }
    },
    {
      "ws_name": "draft_response",  "ws_type": "prompt",
      "ws_llm":  { "provider": "anthropic", "model": "claude-sonnet-4-20250514", "temperature": 0.3 }
    }
  ],
  "workflows": [ { "wf_name": "triage_and_respond", "wf_nodes": [...] } ]
}
How it works

Define once.
Run anywhere.

Three primitives. No magic, no hidden state, no framework to learn.

01
Steps — the atomic unit
Each step has a type (prompt, api, transform, tool, script), typed input/output schemas, and its full configuration. Reusable across pipelines.
ws_name · ws_type · ws_inputs_schema
02
Workflows — the DAG
Wire steps into a directed acyclic graph via wf_nodes and depends_on. The runtime resolves execution order. You define the intent.
wf_nodes · depends_on · step_id
03
Execute via REST API
One POST /api/exec/step call with inputs. SSE streaming for prompt steps. JSON response for API steps. Your backend stays in control — Waiflo is the engine, not the owner.
SSE streaming · JSON response · typed outputs
Why Waiflo

Stop choosing between
speed and control.

Every other approach forces a trade-off. Waiflo doesn't.

Roll your own
✓Full control
—Rewritten from scratch every project
—No reusability between teams
—Prompt logic buried in application code
—New dev has no way to understand pipelines
LangChain / Dify / Flowise
✓Fast to start
—Locked into vendor abstractions
—Workflows not Git-versionable
—Hard or impossible to self-host cleanly
—API integration is an afterthought
Waiflo
✓Plain JSON — git diff your pipelines
✓Self-hostable, zero vendor lock-in
✓API-first — integrates in any stack
✓Visual editor included, no account needed
✓Works with any LLM provider
Design API

Surgical edits.
No clobbering.

PATCH endpoints use recursive deep merge — only the fields you send are updated. Built for autosave, inline editors, and AI-assisted pipeline builders that need to modify one field without touching the rest.

Current step
{
  "ws_name": "classify",
  "ws_llm": {
    "provider": "anthropic",
    "model": "claude-sonnet",
    "temperature": 0
  },
  "ws_system_prompt":
    "You are an expert…"
}
+
PATCH body
{
  "workflow_name": "triage",
  "ws_name": "classify",
  "patch": {
    "ws_llm": {
      "temperature": 0.4
    }
  }
}
→
Result
{
  "ws_name": "classify",
  "ws_llm": {
    "provider": "anthropic", ✓
    "model": "claude-sonnet", ✓
    "temperature": 0.4  ← patched
  },
  "ws_system_prompt":
    "You are…"  ✓
}
Step types

5 primitives.
Every use case covered.

Each step has a ws_type that determines runtime behavior, required fields, and execution semantics.

prompt
LLM call. System prompt, {{var}} template, typed output schema. Streams via SSE.
ws_llm
ws_system_prompt
ws_prompt_template
api
HTTP call. URL supports {{input}} substitution. Returns parsed JSON or raw text.
ws_api.method
ws_api.url
ws_api.headers
transform
Data reshape between steps. Filter, compute, or derive fields from upstream outputs.
ws_transform_fn
— coming soon
tool
MCP tool call. Google Maps, Asana, Gmail, Slack… via ws_tools array.
ws_tools: [
"maps_search"
]
script
Custom code execution in a sandboxed runtime with bound inputs and typed outputs.
ws_script
— coming soon
Get started

Up and running
in 3 minutes.

Self-host with Docker. Zero external services — just a JWT secret and your Anthropic key.

1
Clone and configure
Two secrets to generate: one for JWT signing, one for API key encryption at rest.
git clone https://github.com/jpdesmontils/waiflo
cd waiflo && cp .env.example .env
# Set JWT_SECRET and MASTER_SECRET in .env
2
Start the server
Spins up the API + visual editor. Persists workflow files to a mounted volume — no database required.
docker compose up -d
# Editor available at http://localhost:3001/editor
3
Open the editor — or call the API directly
Explore the visual editor without an account. Or register and start pushing workflows programmatically from your CI pipeline, your agent, or your backend.
# Try the editor first — no account needed
open http://localhost:3001/editor

# Or go API-first
curl -X POST http://localhost:3001/api/auth/register \
  -d '{"email":"you@example.com","password":"secret"}'

Most teams are up
and running in under 10 minutes.

Visual editor included. No signup to explore. Your API keys never leave your infrastructure.

On durability: MIT licensed. Your workflows are plain JSON files — they'll outlive any SaaS, any framework, any vendor. If Waiflo disappeared tomorrow, your pipelines would still run.
⬡ Open Editor ★ GitHub