[opensourcedex]

Slickflow is a free, open source orchestration & scheduling project written in C# and released under MIT. It has 922 GitHub stars, 265 forks and 11 open issues, and was last pushed 4 months ago. On this registry it ranks #102 of 130 tracked projects in Orchestration & Scheduling, with 5 head-to-head comparisons available. It gained 1 stars over the last 30 tracked days.

What is Slickflow?

Slickflow is an MIT-licensed, .NET 8 open source workflow engine that treats large language model nodes, business rules, and multi-agent orchestration as first-class steps inside BPMN process diagrams, aimed at .NET developers and teams building AI-driven business process automation.

What it is

Slickflow is a C# workflow engine that executes BPMN process models on the .NET 8 runtime. It gives a .NET application a runtime for gateways, service tasks, user activities, and process state, and it extends that runtime with native LLM, RAG, and Agent nodes so AI steps sit beside traditional tasks on the same diagram. The engine ships as the Slickflow.Engine NuGet package and pairs with a designer at slickflow.net for authoring processes.

The concrete problem it replaces is hand-wired AI calls, conditional routing, and state management inside application code. In a typical .NET application, approval chains, threshold routing, and model invocations become ad-hoc service calls and nested if blocks scattered across the codebase. Slickflow lifts that logic into a modelled BPMN process where split gateways evaluate stored rules, LLM nodes emit structured output, and the engine persists process state, so the same routing logic does not have to be rebuilt in every consuming application.

Key capabilities

  • BPMN process execution on .NET 8, with LLM, RAG, and Agent nodes handled as first-class workflow steps alongside traditional service tasks.
  • Multi-provider LLM integration covering the OpenAI API (GPT-4, GPT-3.5) and Alibaba's QianWen, with an extensible architecture for DeepSeek and custom gateways.
  • Retrieval-Augmented Generation and image understanding through dedicated LLM nodes, combining vector search or knowledge bases with model reasoning.
  • A built-in Business Rules Engine that stores rule sets in the wf_rule_set table and evaluates them through WorkflowService.EvaluateRuleSet against process variables.
  • Conditional routing on gateway transitions, covering amount threshold routing, status-based branching, and AI output routing on a confidence score, without custom code.
  • Multi-agent orchestration inside a single workflow using the ReAct loop (Reason, Act, Observe), driven by AgentMultiTurnService.InvokeWithHistoryAsync.
  • Rule and AI combination, where an LLM node emits JSON with a score field and a split gateway branches on that value.

Who uses it and how

  • .NET teams building approval or credit-check flows that need rules-driven branching without recompiling, for example routing orders above 10,000 to a senior approval branch.
  • Applications that already call LLMs and want prompt construction, tool calls, knowledge base retrieval, and persistence modelled as process steps rather than scattered through code.
  • Products needing human-in-the-loop AI, where an LLM confidence score routes a case to automatic acceptance or to a human review branch.
  • Image classification pipelines, where a process diagram calls an LLM node to classify or analyse an image and then routes on the result.
  • Enterprise environments already standardised on the .NET stack that want a workflow runtime installable from a NuGet package.

Getting started

Install the Slickflow.Engine NuGet package and reference it from a .NET 8 application, or use the hosted designer at slickflow.net to model a process. Rules are authored in the designer or through the API and persisted in the wf_rule_set table.

How it compares

No list of paid products this project replaces was provided in the facts, and the facts name no similar tools. It stands alone in this registry on that basis.

When to use it — and when not to

A self-hoster must run a database to hold the wf_rule_set table and process state, and must supply and manage credentials for at least one external LLM provider such as OpenAI or QianWen; AI nodes depend on that outbound access. Teams on .NET 8 that are comfortable with BPMN modelling get the most from it. Teams not on .NET, teams wanting a fully managed cloud workflow service, or teams needing AI inference to run entirely offline should look elsewhere.

project readme (upstream, from github) — read inline

Slickflow

Current Version: NET8

1. 🤖 AI-Powered Workflow Automation

SlickFlow: Intelligent Workflow Automation with Large Language Models

Slickflow integrates cutting-edge Large Language Model (LLM) nodes directly into BPMN workflows, enabling advanced conversational reasoning, RAG (Retrieval-Augmented Generation), image understanding and other AI capabilities as first-class workflow steps.
This transforms traditional workflow systems into dynamic, AI-driven orchestration platforms.

1.1 Native LLM Node Integration

  • Add LLM / RAG / Agent nodes into your process diagrams as easily as traditional service tasks.
  • Orchestrate multi-step AI pipelines: prompt construction, tool calls, knowledge base retrieval, post-processing, persistence, notification, etc.

1.2 Multi-Provider LLM Support

Flexible integration with leading AI services:

  • OpenAI API (GPT-4, GPT-3.5, and beyond)
  • QianWen (Alibaba’s large language model)
  • Extensible architecture for additional providers (DeepSeek, custom gateways, etc.)

1.3 Image Understanding & RAG

  • Image classification & analysis directly through LLM nodes
  • Retrieval-Augmented Generation (RAG): combine vector search / knowledge bases with LLM reasoning to provide grounded, up-to-date answers

1.4 AI Feature Reference

1.5 AI Demo (Key GIF)

AI Image Classification Process Demo
AI Image Classification Demo

2. 📐 Business Rules Engine

Slickflow includes a built-in Business Rules Engine that lets you define, store and evaluate conditional logic without changing application code.

2.1 Rule Definition

Rules are authored in the designer or via API and stored in the wf_rule_set table. Each rule set contains one or more expressions that evaluate process variables at runtime.

// Evaluate a rule set by name against the current process variables
IWorkflowService wfService = new WorkflowService();
var ruleResult = wfService.EvaluateRuleSet("CreditCheckRules", variableDict);

2.2 Conditional Routing

Rules are attached to gateway transitions in BPMN diagrams. When the engine reaches a split gateway, it evaluates the rule expressions and follows the matching branch automatically — no custom code required.

Typical patterns:

  • Amount threshold routing – order amount > 10,000 → senior approval branch
  • Status-based branching – inventory level check → reorder or skip branch
  • AI output routing – LLM confidence score → accept or human-review branch

2.3 Rule + AI Combination

Business rules can be combined with AI nodes in the same process:

  1. An LLM node produces a structured output (JSON with a score field).
  2. A split gateway evaluates a rule against the score variable.
  3. The process routes to different downstream activities accordingly.

3. 🤝 Multi-Agent Interaction

Slickflow supports multi-agent orchestration within a single workflow, based on the ReAct (Reason → Act → Observe) loop pattern.

3.1 ReAct Agent Loop

Each Agent node in the process diagram runs an autonomous reasoning loop:

  1. Reason – the agent analyzes the current task and available tools.
  2. Act – it calls a registered tool (API, sub-agent, database query, etc.).
  3. Observe – it receives the tool result and decides the next step.
  4. The loop repeats until the agent produces a final answer.
// Agent node execution (simplified internal flow)
var agentService = new AgentMultiTurnService();
var response = await agentService.InvokeWithHistoryAsync(axConfig, inputVariables, history);

3.2 Agent Tool Registry

Tools are registered per activity via AgentToolRegistry. Each tool is a typed C# class implementing IAgentTool:

AgentToolRegistry.Register("PriceQuery", activityId, new PriceQueryTool());
AgentToolRegistry.Register("InventoryCheck", activityId, new InventoryCheckTool());

The agent selects and invokes tools autonomously based on its reasoning.

3.3 Multi-Agent Workflow Example

A 5-agent procurement process demonstrates cross-agent collaboration:

Agent Node Role
NeedsAnalysisAgent Analyzes purchase requirements
SupplierQueryAgent Queries supplier catalog and pricing
PriceNegotiationAgent Negotiates terms with selected supplier
RiskAssessmentAgent Evaluates compliance and financial risk
ApprovalDecisionAgent Makes final approval recommendation

Each agent passes its structured output as process variables to the next agent, enabling a full collaborative reasoning chain within one BPMN process.

3.4 Agent Memory

AgentConversationMemory maintains per-session dialogue history across agent turns, allowing agents to reference earlier reasoning steps without re-processing.

4. 🔌 MCP Server

Slickflow provides a Model Context Protocol (MCP) Server (sfmcp) that exposes the workflow engine as a set of callable tools for AI orchestration platforms.

4.1 What It Does

AI assistants (Claude, GPT, etc.) can call Slickflow MCP tools directly to:

  • Create and manage workflow process definitions
  • Start process instances and run task steps
  • Query running instances and task lists
  • Read and write process variables
  • Trigger AI-node execution within running workflows

4.2 Available Tools (14)

Category Tools
Process Definition GetProcessList, GetProcessDetail, CreateProcess
Instance Control StartProcess, RunProcess, GetProcessInstance
Task Management GetTaskList, GetTaskDetail, CompleteTask
Variables GetVariables, SetVariable
Knowledge Base SearchDocuments, SaveDocument, GetDocuments

4.3 Quick Start

# Run the MCP server
cd source/sfmcp
dotnet run

Configure your AI platform to point at the MCP endpoint. The server communicates over the standard MCP protocol (stdio or HTTP transport).

4.4 Use Cases

  • AI-driven process automation: let an AI assistant start and advance workflows based on natural-language instructions.
  • Workflow introspection: query running instances and diagnose stuck processes via chat.
  • Dynamic variable injection: an AI agent writes computed results back into a live process instance.

5. 🚀 Code-Defined Auto-Execution Engine

Besides designer-based processes, Slickflow provides a code-first auto-execution model based on Slickflow.Graph and WorkflowExecutor.
You can define workflows in C#, run them fully in memory, and let the engine automatically execute all steps without human interaction.

5.1 Code-First Workflow Definition

Use Slickflow.Graph.Model.Workflow to build BPMN-style flows programmatically:

using Slickflow.Graph.Model;

var wf = new Workflow("Order Process", "OrderProcess_Code");

wf.Start("Start")
  .ServiceTask("Validate Order", "Validate001", "ValidateOrder")   // LocalMethod
  .ServiceTask("Calculate Amount", "Calc001", "CalcAmount")       // LocalMethod
  .RagService("RAG Reply", "RAG001")                              // RAG AI node
  .LlmService("LLM Enrich", "LLM001")                             // General LLM node
  .ServiceTask<SaveOrderService>("Save Order", "Save001")         // Local service class
  .End("End");

Key points:

  • Workflow supports rich node types: Start, Task, ServiceTask, RagService, LlmService, Agent, Parallels, Branch, End, etc.
  • BuildInMemory() produces an in-memory ProcessEntity without touching the database.
  • WorkflowExecutorExtensions.UseProcess(Workflow) binds this in-memory model to the runtime engine and caches it by ProcessId:Version.

5.2 Auto-Execution with WorkflowExecutor

Auto-execution loop (conceptual):

  1. Start the process and create an instance.
  2. While there are executable activities:
    • Collect next activities.
    • Execute each activity (local method, service class, AI/RAG/LLM, external API, etc.).
    • Move the process forward to the next activity.
  3. Return execution result (status, message, variables, AI response, etc.).

Typical code pattern:

using Slickflow.Engine.Executor;
using Slickflow.Engine.Core.Result;

var result = await new WorkflowExecutor()
    .UseApp("OrderApp-001", "OrderApp")
    .UseProcess(wf)                      // Use code-defined workflow
    .AddVariable("OrderId", "ORD-2025-001")
    .AddVariable("Quantity", "3")
    .AddVariable("UnitPrice", "99.50")
    .Run();

This mode is ideal for:

  • ETL and data pipelines
  • Backend batch / microservice orchestration
  • AI agents and chat workflows
  • Unit tests and demos (no DB dependency)

5.3 Engine Capabilities (.NET8 Core)

  • .NET, cross-platform: works on Windows, Linux, macOS.
  • BPMN2-style diagrams with an HTML5 designer for visual modeling.
  • High performance with Dapper.NET micro-ORM.
  • Multi-database support: SQL Server, Oracle, MySQL, PostgreSQL and others (via Dapper / EF Core).

6. ✅ Human Approval Workflows (BPM)

On top of AI and auto-execution, Slickflow remains a full-featured human-centric workflow engine for traditional BPM scenarios: approvals, reviews, multi-level routing, etc.

6.1 Workflow Patterns (Key GIFs/Images)

Supported patterns (BPMN-style):

Workflow Pattern

  • Sequence – the most common pattern
  • Split / Merge – AND / OR gateways with conditions on transitions
  • Sub-process – start a child process from the main flow
  • Multi-instance – multiple performers handle the same task (sequence or parallel), with count/percentage thresholds

Multiple Instance Pattern

6.2 Core Human-Task Operations (Brief)

Slickflow manages human tasks with features such as:

  • Start / Run – launch and move a process instance to the next step
  • Withdraw – pull back a task you just sent to the next user
  • SendBack – send a task back to the previous step
  • Resend / Reverse / Jump – advanced control for exception handling and special routing

Code style (simplified):

// Start a process instance
IWorkflowService wfService = new WorkflowService();
var startResult = wfService.CreateRunner("10", "Jack")
    .UseApp("DS-100", "Book-Order", "DS-100-LX")
    .UseProcess("PriceProcessCode")
    .Start();

// Run to next step
var runResult = wfService.CreateRunner("10", "Jack")
    .UseApp("DS-100", "Book-Order", "DS-100-LX")
    .UseProcess("PriceProcessCode")
    .NextStepInt("20", "Alice")
    .Run();

6.3 Code-Style Modeling for Human Approval

You can also define simple approval processes purely in code (sequence example) using Workflow:

using Slickflow.Graph.Model;

// create a simple sequence process diagram by hand code rather than an HTML designer
var wf = new Workflow("simple-process-name", "simple-process-code");

wf.Start("Start")
  .Task("Task1")
  .Task("Task2")
  .End("End");

simple sequence diagram

This gives developers both designer-based and code-based options for modeling human approval workflows.

7. 📦 Demos, Target Users and License

7.1 Demo Projects

  • WebDemo, MvcDemo, WinformDemo – example integration with different enterprise application types.

7.2 Target Users

  • Software teams or companies who want to embed a workflow engine into their products.
  • Developers who prefer combining AI orchestration, auto-execution, and human approval in one engine.

7.3 License & Support

  • License: Slickflow follows the MIT open source license and can be used in commercial projects.
  • Technical Support: Enterprise, Ultimate and Universe editions can be provided with technical support and upgrade services.

If you have any further inquiry, please feel free to contact:

8. 📚 Resources & Docker Deployment

8.1 Documentation

8.2 Wiki

8.3 CodeProject Articles

8.4 Official Website

8.5 Online Demo

8.6 Docker Hub

Pre-built Docker images are available on Docker Hub. Get started in minutes without building from source.

All-in-One Image (Recommended)

The easiest way to get started – pull one image and run all three services:

docker pull besley2096/slickflow-all:latest
docker run -d \
  -p 5000:5000 \
  -p 5001:5001 \
  -p 8090:8090 \
  -e WfDBConnectionType=PGSQL \
  -e WfDBConnectionString="Server=host.docker.internal;Port=5432;Database=wfdbbpmn2;User Id=postgres;Password=your-password;TimeZone=UTC;" \
  --name slickflow-all \
  besley2096/slickflow-all:latest

Access:

Docker Hub: https://hub.docker.com/r/besley2096/slickflow-all

Separate Images

For better isolation and scaling, use separate images:

Backend API

docker pull besley2096/slickflow-api:latest
docker run -d -p 5000:5000 \
  -e WfDBConnectionType=PGSQL \
  -e WfDBConnectionString="Server=host.docker.internal;Port=5432;Database=wfdbbpmn2;User Id=postgres;Password=your-password;TimeZone=UTC;" \
  --name slickflow-api \
  besley2096/slickflow-api:latest

Frontend Designer

docker pull besley2096/slickflow-designer:latest
docker run -d -p 8090:8090 \
  --name slickflow-designer \
  besley2096/slickflow-designer:latest

WebTest

docker pull besley2096/slickflow-webtest:latest
docker run -d -p 5001:5001 \
  -e WfDBConnectionType=PGSQL \
  -e WfDBConnectionString="Server=host.docker.internal;Port=5432;Database=wfdbbpmn2;User Id=postgres;Password=your-password;TimeZone=UTC;" \
  --name slickflow-webtest \
  besley2096/slickflow-webtest:latest
Docker Compose

Use docker-compose.hub.yml from this repository:

docker-compose -f docker-compose.hub.yml pull
docker-compose -f docker-compose.hub.yml up -d
Image Tags

Available tags for each image:

  • latest – Latest stable version
  • v3.5.0 – Version 3.5.0
Docker Hub Links
Database Configuration

API and WebTest containers require database configuration. Supported databases: PostgreSQL, MySQL, SQL Server, Oracle.

Database on Host Machine

-e WfDBConnectionString="Server=host.docker.internal;Port=5432;Database=wfdbbpmn2;User Id=postgres;Password=your-password;TimeZone=UTC;"

Database in Docker Container

-e WfDBConnectionString="Server=postgres;Port=5432;Database=wfdbbpmn2;User Id=postgres;Password=your-password;TimeZone=UTC;"

Remote Database

-e WfDBConnectionString="Server=192.168.1.100;Port=5432;Database=wfdbbpmn2;User Id=postgres;Password=your-password;TimeZone=UTC;"

9. 📞 Contact & 💰 Donation

9.1 Contact

9.2 Donation

Your donation will be used for the continuous research and development of the product and community building.
您的捐赠将用于产品的持续研发和社区建设。

Donate with PayPal

Frequently asked questions

Is Slickflow free to use?

Slickflow is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Slickflow do?

.NET Open Source Workflow Engine, AI Empowerment

What is Slickflow written in?

Slickflow is primarily written in C#. Its source is publicly available at https://github.com/besley/Slickflow, and it has 922 GitHub stars.