Implementing a Fuzzy Logic Decision Engine in n8n

[Haian_Abou-Karam]

This article builds directly on my previous work:
Beyond the IF Chain: Decision Dispatcher — Advanced Rule Scoring and Decision Confidence in n8n.

In that post, I introduced a weighted scoring model to move beyond rigid IF/ELSE chains. While effective, that approach remains fundamentally linear: it aggregates signals into a single score and applies thresholds.

In this article, we take the next architectural step:

From linear scoring → to fuzzy inference → to explainable decision systems

To keep the focus clear, the example here is intentionally simple (two inputs, three rules). In real world systems, this pattern can scale to many variables, rule sets, and governance layers.

---

1. From Linear Scoring to Fuzzy Reasoning

In the previous model:

score = (urgency * 0.5) + (risk * 0.5)

decision = score > 0.9 ? "auto" : "human"

This approach has limitations:

• It assumes linear relationships

• It cannot express semantic rules

• It relies on hard thresholds

Fuzzy logic addresses this by replacing arithmetic aggregation with rule-based inference over degrees of truth.

---

2. What is Fuzzy Logic (Technically)?

Fuzzy logic is a framework for reasoning under uncertainty using continuous truth values between 0 and 1.

Instead of:

• urgency is HIGH (true/false)

We have:

• urgency is HIGH with degree 0.7

• urgency is LOW with degree 0.2

A fuzzy system typically consists of:

1. Fuzzification: map inputs to membership functions

2. Inference: valuate rule base (e.g., Mamdani min/max)

3. Defuzzification: convert fuzzy output to crisp decision

---

3. System Architecture (LLM + Fuzzy Logic)

Refer to Figure 1 (Conceptual Architecture):

• LLM Agent: extracts structured signals from text

• Fuzzy Logic Node: performs reasoning

• Dispatch Layer: executes action

Key idea:

The LLM does interpretation, not decision making
The fuzzy engine does deterministic reasoning

---

4. Workflow Overview in n8n

---

5. Implementation: Fuzzy Logic Engine

5.1 Input

const inputData = $input.first().json;

const urgency = inputData.urgency;       // 0 → 1
const complexity = inputData.complexity; // 0 → 1

---

5.2 Fuzzification (Membership Functions)

We define piecewise linear membership functions

const isLow = (x) => Math.max(0, Math.min(1, (0.4 - x) / 0.4));
const isHigh = (x) => Math.max(0, Math.min(1, (x - 0.6) / 0.4));

Interpretation:

• Values are not binary

• A single input can belong to multiple sets simultaneously

This corresponds to Figure 1(Membership Function Visualization).

5.3 Inference (Rule Evaluation)

We use a simplified Mamdani inference model

// Rule A: High Urgency + Low Complexity ==> Auto
const ruleA = Math.min(isHigh(urgency), isLow(complexity));

// Rule B: High Urgency + High Complexity ==> Human
const ruleB = Math.min(isHigh(urgency), isHigh(complexity));

// Rule C: Low Urgency ==> Queue
const ruleC = isLow(urgency);

Important:

• Math.min = logical AND

• Each rule outputs a truth strength ∈ [0,1]

---

5.4 Defuzzification (Decision Selection)

We use max-membership (argmax):

const outcomes = [
  { action: "Fast-Track Auto", truth: ruleA, rule: "High Urgency + Low Complexity" },
  { action: "Human Escalation", truth: ruleB, rule: "High Urgency + High Complexity" },
  { action: "Standard Queue", truth: ruleC, rule: "Low Urgency" }
];

const winner = outcomes.reduce((prev, curr) =>
  curr.truth > prev.truth ? curr : prev
);

---

5.5 Output (Explainable Decision)

return {
  ...inputData,
  decision: winner.truth > 0 ? winner.action : "Manual Review Required",
  decisionRule: winner.rule,
  decisionConfidence: (winner.truth * 100).toFixed(0) + "%",
  explanationTrace: outcomes
};

---

6. Explainability: The Key Advantage

Unlike weighted scoring, this system produces a traceable reasoning structure:

[
  { "action": "Fast-Track Auto", "truth": 0.75 },
  { "action": "Human Escalation", "truth": 0.10 },
  { "action": "Standard Queue", "truth": 0.00 }
]

This enables:

• Debugging decisions

• Auditing automation

• Explaining outcomes to stakeholders

The system doesn’t just decide — it shows why.

---

7. Routing Layer (Switch Node)

The fuzzy engine does reasoning, but n8n still handles execution.

Example routing logic:

This keeps a clean separation:

• Code Node ==> intelligence

• Switch Node ==> orchestration

---

8. Why This Outperforms Weighted Scoring

Feature	Weighted Model	Fuzzy Model
Logic	Linear	Rule-based
Interpretability	Low	High (trace)
Flexibility	Limited	High
Thresholding	Hard	Smooth
Expressiveness	Numeric only	Semantic rules

---

9. Extending the Model

This example uses:

• 2 inputs

• 3 rules

In production, you can extend to:

• Additional signals: sentiment, risk, SLA, customer tier

• More granular membership functions (triangular, trapezoidal)

• Advanced defuzzification (centroid instead of max)

• Hybrid models (LLM + fuzzy + guardrails)

---

10. Conclusion

This architecture introduces a key shift:

From automating tasks ==> to automating decisions

By combining:

• LLMs for signal extraction

• Fuzzy logic for structured reasoning

• n8n for execution

You get a system that is:

• More flexible than IF chains

• More expressive than weighted scoring

• More explainable than black box AI

And most importantly: It behaves closer to how humans reason under uncertainty, without losing determinism.

---

Resources:

• Fuzzy Logic fundamentals

• Fuzzy inference systems (Mamdani)

• n8n Code Node docs

• n8n Switch Node docs

---