diff --git a/.gitignore b/.gitignore
index 71baa505a..49ba3ea31 100644
--- a/.gitignore
+++ b/.gitignore
@@ -36,4 +36,4 @@ testBuild
 
 gurobi-9.1.0.jar
 isula-1.1.1.jar
-logs/server.log.lck
+/org-tweetyproject-web/logs/server.log.lck
diff --git a/org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/reasoner/AbstractBipolarExtensionReasoner.java b/org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/reasoner/AbstractBipolarExtensionReasoner.java
index 68aa09c03..d80276f87 100644
--- a/org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/reasoner/AbstractBipolarExtensionReasoner.java
+++ b/org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/reasoner/AbstractBipolarExtensionReasoner.java
@@ -22,7 +22,6 @@
 import org.tweetyproject.arg.bipolar.syntax.BipolarArgumentationFramework;
 import org.tweetyproject.arg.dung.semantics.Extension;
 import org.tweetyproject.arg.dung.syntax.Argument;
-import org.tweetyproject.arg.dung.syntax.DungTheory;
 import org.tweetyproject.commons.InferenceMode;
 import org.tweetyproject.commons.ModelProvider;
 import org.tweetyproject.commons.QualitativeReasoner;
@@ -56,6 +55,11 @@ public static AbstractBipolarExtensionReasoner getSimpleReasonerForSemantics(Sem
             case BCF -> new SimpleStronglyConflictFreeReasoner();
             case BCOH -> new SimpleCoherentReasoner();
             case BAD -> new SimpleCoherentAdmissibleReasoner();
+            case CAD -> new SimpleCoalitionReasoner(org.tweetyproject.arg.dung.semantics.Semantics.ADM);
+            case CCO -> new SimpleCoalitionReasoner(org.tweetyproject.arg.dung.semantics.Semantics.CO);
+            case CGR -> new SimpleCoalitionReasoner(org.tweetyproject.arg.dung.semantics.Semantics.GR);
+            case CPR -> new SimpleCoalitionReasoner(org.tweetyproject.arg.dung.semantics.Semantics.PR);
+            case CST -> new SimpleCoalitionReasoner(org.tweetyproject.arg.dung.semantics.Semantics.ST);
             default -> throw new IllegalArgumentException("Unknown semantics.");
         };
     }
diff --git a/org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/semantics/Semantics.java b/org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/semantics/Semantics.java
index 4bffb5509..d7dec713d 100644
--- a/org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/semantics/Semantics.java
+++ b/org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/semantics/Semantics.java
@@ -18,6 +18,8 @@
  */
 package org.tweetyproject.arg.bipolar.semantics;
 
+import java.util.NoSuchElementException;
+
 /**
  * Enum of semantics for bipolar argumentation
  *
@@ -27,30 +29,29 @@ public enum Semantics {
     /**
      * CF
      */
-    BCF("conflict-free semantics", "B-CF"),
+    BCF("conflict-free semantics", "BCF"),
     /**
      * COH
      */
-    BCOH("coherent semantics", "B-COH"),
+    BCOH("coherent semantics", "BCOH"),
     /**
      * ADM
      */
-    BAD("admissible semantics", "B-AD"),
+    BAD("admissible semantics", "BAD"),
+    /** coalition-admissible semantics */
+    CAD("Coalition-Admissible", "CAD"),
+    /** coalition-complete semantics */
+    CCO("Coalition-Complete", "CCO"),
+    /** coalition-grounded semantics */
+    CGR("Coalition-Grounded", "CGR"),
+    /** coalition-preferred semantics */
+    CPR("Coalition-Preferred", "CPR"),
+    /** coalition-stable semantics */
+    CST("Coalition-Stable", "CST"),
     /**
      * diverse
      */
     diverse("diverse semantics", "div");
-    /**
-     * all semantics
-     */
-    @SuppressWarnings("javadoc")
-    public static final Semantics
-            /** CONFLICT_FREE SEMANTICS*/
-            B_CONFLICT_FREE_SEMANTICS = BCF,
-            /** COHERENT SEMANTICS*/
-            B_COHERENT_SEMANTICS = BCOH,
-            /** COHERENT_ADMISSIBLE SEMANTICS */
-            B_ADMISSIBLE_SEMANTICS = BAD;
 
     /**
      * The description of the semantics.
@@ -89,5 +90,19 @@ public String description() {
     public String abbreviation() {
         return this.abbreviation;
     }
+
+    /**
+     * Returns the semantics whose abbreviation matched the given string.
+     * @param abbreviation Abbreviation of the semantics to return.
+     * @return Semantics with the specified abbreviation.
+     */
+    public static Semantics getSemantics(String abbreviation) {
+        for (Semantics element : Semantics.values()) {
+            if (element.abbreviation().equals(abbreviation)) {
+                return element;
+            }
+        }
+        throw new NoSuchElementException();
+    }
 }
 
diff --git a/org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/syntax/Support.java b/org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/syntax/Support.java
index 62766d822..f4620795a 100644
--- a/org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/syntax/Support.java
+++ b/org-tweetyproject-arg-bipolar/src/main/java/org/tweetyproject/arg/bipolar/syntax/Support.java
@@ -18,11 +18,7 @@
  */
 package org.tweetyproject.arg.bipolar.syntax;
 
-import org.tweetyproject.arg.dung.ldo.syntax.LdoFormula;
-import org.tweetyproject.arg.dung.ldo.syntax.LdoRelation;
 import org.tweetyproject.arg.dung.syntax.Argument;
-import org.tweetyproject.arg.dung.syntax.DungSignature;
-import org.tweetyproject.commons.Signature;
 import org.tweetyproject.graphs.DirectedEdge;
 
 /**
@@ -108,6 +104,22 @@ public enum Type {
         /** inverse of simple deductive */
         SIMPLE_NECESSITY,
         /** arguments must be supported by evidence*/
-        EVIDENTIAL
+        EVIDENTIAL;
+
+        public static Type getType(String type) {
+            switch (type) {
+                case "none", "default", "coalition" -> {
+                    return DEFAULT;
+                } case "ded_simple" -> {
+                    return SIMPLE_DEDUCTIVE;
+                } case "ded" -> {
+                    return DEDUCTIVE;
+                } case "nec_simple" -> {
+                    return SIMPLE_NECESSITY;
+                } case "nec" -> {
+                    return NECESSITY;
+                } default -> throw new IllegalArgumentException("unknown support type " + type);
+            }
+        }
     }
 }
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/AbstractExtensionSetAfReasoner.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/AbstractSetAfExtensionReasoner.java
similarity index 76%
rename from org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/AbstractExtensionSetAfReasoner.java
rename to org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/AbstractSetAfExtensionReasoner.java
index 4f864de23..99aef0adb 100644
--- a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/AbstractExtensionSetAfReasoner.java
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/AbstractSetAfExtensionReasoner.java
@@ -19,6 +19,7 @@
 package org.tweetyproject.arg.setaf.reasoners;
 
 import java.util.Collection;
+import java.util.HashSet;
 
 import org.tweetyproject.arg.dung.semantics.Extension;
 import org.tweetyproject.arg.dung.semantics.Semantics;
@@ -29,17 +30,17 @@
 import org.tweetyproject.commons.postulates.PostulateEvaluatable;
 
 /**
- * Ancestor class for all SetAf-extension-based reasoners.
+ * Ancestor class for all SetAF-extension-based reasoners.
  *
  * @author Sebastian Franke
  */
-public abstract class AbstractExtensionSetAfReasoner extends AbstractSetAfReasoner
+public abstract class AbstractSetAfExtensionReasoner extends AbstractSetAfReasoner
 		implements ModelProvider<Argument, SetAf, Extension<SetAf>>, PostulateEvaluatable<Argument> {
 
 	/**
 	 * Default constructor for {@code AbstractExtensionSetAfReasoner}.
 	 */
-	public AbstractExtensionSetAfReasoner() {
+	public AbstractSetAfExtensionReasoner() {
 		// No specific initialization required
 	}
 
@@ -56,10 +57,29 @@ public Boolean query(SetAf beliefbase, Argument formula) {
 	}
 
 	/**
-	 * Queries the given AAF for the given argument using the given
+	 * Determine the set of acceptable arguments wrt. the given inference mode
+	 * @param bbase some SetAF
+	 * @param inferenceMode the inference mode
+	 * @return the set of acceptable arguments
+	 */
+	public Collection<Argument> queryAll(SetAf bbase, InferenceMode inferenceMode) {
+		Collection<Argument> result = new HashSet<>();
+		if(inferenceMode.equals(InferenceMode.CREDULOUS))
+			for(Collection<Argument> extension: this.getModels(bbase))
+				result.addAll(extension);
+		else {
+			result.addAll(bbase);
+			for(Collection<Argument> extension: this.getModels(bbase))
+				result.retainAll(extension);
+		}
+		return result;
+	}
+
+	/**
+	 * Queries the given SetAf for the given argument using the given
 	 * inference type.
 	 *
-	 * @param beliefbase    an AAF
+	 * @param beliefbase    an SetAF
 	 * @param formula       a single argument
 	 * @param inferenceMode either InferenceMode.SKEPTICAL or
 	 *                      InferenceMode.CREDULOUS
@@ -85,9 +105,9 @@ public Boolean query(SetAf beliefbase, Argument formula, InferenceMode inference
 	 * Creates a reasoner for the given semantics.
 	 *
 	 * @param semantics a semantics
-	 * @return a reasoner for the given Dung theory, inference type, and semantics
+	 * @return a reasoner for the given SetAF, inference type, and semantics
 	 */
-	public static AbstractExtensionSetAfReasoner getSimpleReasonerForSemantics(Semantics semantics) {
+	public static AbstractSetAfExtensionReasoner getSimpleReasonerForSemantics(Semantics semantics) {
 		switch (semantics) {
 			case CO:
 				return new SimpleCompleteSetAfReasoner();
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/ReductionBasedSetAfReasoner.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/ReductionBasedSetAfReasoner.java
new file mode 100644
index 000000000..8b1cf4893
--- /dev/null
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/ReductionBasedSetAfReasoner.java
@@ -0,0 +1,107 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.arg.setaf.reasoners;
+
+import org.tweetyproject.arg.dung.reasoner.AbstractExtensionReasoner;
+import org.tweetyproject.arg.dung.semantics.Extension;
+import org.tweetyproject.arg.dung.semantics.Semantics;
+import org.tweetyproject.arg.dung.syntax.Argument;
+import org.tweetyproject.arg.dung.syntax.DungTheory;
+import org.tweetyproject.arg.setaf.syntax.SetAf;
+import org.tweetyproject.arg.setaf.syntax.SetAttack;
+
+import java.util.Collection;
+import java.util.HashSet;
+
+/**
+ * Reasoner for SetAfs that reduces the SetAf to a dung theory via a polynomial reduction
+ *
+ * @see "Modgil and Bench-Capon (2011), 'Metalevel argumentation', J. Log. Comput."
+ *
+ * @author Lars Bengel
+ */
+public class ReductionBasedSetAfReasoner extends AbstractSetAfExtensionReasoner {
+
+    /** the underlying semantics reasoner */
+    private final AbstractExtensionReasoner reasoner;
+
+    /**
+     * Initializes new SetAf reasoner with the given dung reasoner
+     * @param reasoner some dung reasoner
+     */
+    public ReductionBasedSetAfReasoner(AbstractExtensionReasoner reasoner) {
+        this.reasoner = reasoner;
+    }
+
+    /**
+     * Initializes new SetAf reasoner with the given dung semantics
+     * @param semantics some semantics
+     */
+    public ReductionBasedSetAfReasoner(Semantics semantics) {
+        this(AbstractExtensionReasoner.getSimpleReasonerForSemantics(semantics));
+    }
+
+    @Override
+    public Collection<Extension<SetAf>> getModels(SetAf bbase) {
+        DungTheory theory = getDungTheory(bbase);
+        Collection<Extension<SetAf>> result = new HashSet<>();
+        for (Extension<DungTheory> ext : reasoner.getModels(theory)) {
+            Extension<SetAf> new_ext = new Extension<>();
+            for (Argument arg : ext) {
+                if (bbase.contains(arg)) {
+                    new_ext.add(arg);
+                }
+            }
+            result.add(new_ext);
+        }
+        return result;
+    }
+
+    @Override
+    public Extension<SetAf> getModel(SetAf bbase) {
+        return getModels(bbase).iterator().next();
+    }
+
+    /**
+     * Computes a dung theory for the given SetAf
+     * @param bbase some SetAf
+     * @return the corresponding dung theory
+     */
+    public DungTheory getDungTheory(SetAf bbase) {
+        DungTheory theory = new DungTheory();
+        theory.addAll(bbase);
+        for (SetAttack att : bbase.getAttacks()) {
+            Argument arg1 = new Argument(String.format("_att(%s,%s)", att.getAttackers(), att.getAttacked()));
+            theory.add(arg1);
+            theory.addAttack(arg1, att.getAttacked());
+            for (Argument x : att.getAttackers()) {
+                Argument arg2 = new Argument(String.format("_att(%s,%s,%s)", att.getAttackers(), att.getAttacked(), x));
+                theory.add(arg2);
+                theory.addAttack(x, arg2);
+                theory.addAttack(arg2, arg1);
+            }
+        }
+        return theory;
+    }
+
+    @Override
+    public boolean isInstalled() {
+        return true;
+    }
+}
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleAdmissibleSetAfReasoner.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleAdmissibleSetAfReasoner.java
index d9c794f71..6da8f33cd 100644
--- a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleAdmissibleSetAfReasoner.java
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleAdmissibleSetAfReasoner.java
@@ -33,7 +33,7 @@
  * @author Matthias Thimm, Sebastian Franke
  *
  */
-public class SimpleAdmissibleSetAfReasoner extends AbstractExtensionSetAfReasoner {
+public class SimpleAdmissibleSetAfReasoner extends AbstractSetAfExtensionReasoner {
 	/** Default */
 	public SimpleAdmissibleSetAfReasoner(){
 		// Default
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleCompleteSetAfReasoner.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleCompleteSetAfReasoner.java
index 7af7b6b7d..8b5d0d7c8 100644
--- a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleCompleteSetAfReasoner.java
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleCompleteSetAfReasoner.java
@@ -25,13 +25,13 @@
 import org.tweetyproject.arg.dung.syntax.*;
 
 
-	/**
-	 * This reasoner for SetAf theories performs inference on the complete extensions.
-	 * Computes the set of all complete extensions, i.e., all admissible sets that contain all their acceptable arguments.
-	 * @author Matthias Thimm, Sebastian Franke
-	 *
-	 */
-public class SimpleCompleteSetAfReasoner extends AbstractExtensionSetAfReasoner {
+/**
+ * This reasoner for SetAf theories performs inference on the complete extensions.
+ * Computes the set of all complete extensions, i.e., all admissible sets that contain all their acceptable arguments.
+ * @author Matthias Thimm, Sebastian Franke
+ *
+ */
+public class SimpleCompleteSetAfReasoner extends AbstractSetAfExtensionReasoner {
 
 		/**
 		 * Default constructor.
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleConflictFreeSetAfReasoner.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleConflictFreeSetAfReasoner.java
index b208f9ef8..a1e23ace8 100644
--- a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleConflictFreeSetAfReasoner.java
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleConflictFreeSetAfReasoner.java
@@ -32,7 +32,7 @@
  * @author Matthias Thimm, Sebastian Franke
  *
  */
-public class SimpleConflictFreeSetAfReasoner extends AbstractExtensionSetAfReasoner {
+public class SimpleConflictFreeSetAfReasoner extends AbstractSetAfExtensionReasoner {
 
 
 		/** Default */
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleEagerSetAfReasoner.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleEagerSetAfReasoner.java
index 5abd94b36..8b8d43e3e 100644
--- a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleEagerSetAfReasoner.java
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleEagerSetAfReasoner.java
@@ -33,7 +33,7 @@
  *
  * @author Lars Bengel, Sebastian Franke
  */
-public class SimpleEagerSetAfReasoner extends AbstractExtensionSetAfReasoner {
+public class SimpleEagerSetAfReasoner extends AbstractSetAfExtensionReasoner {
 
 
 		/** Default */
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleGroundedSetAfReasoner.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleGroundedSetAfReasoner.java
index ab6f4a5ff..b5b1b59fb 100644
--- a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleGroundedSetAfReasoner.java
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleGroundedSetAfReasoner.java
@@ -32,7 +32,7 @@
  * @author Matthias Thimm, Sebastian Franke
  *
  */
-public class SimpleGroundedSetAfReasoner extends AbstractExtensionSetAfReasoner {
+public class SimpleGroundedSetAfReasoner extends AbstractSetAfExtensionReasoner {
 
 	/** Default */
 			public SimpleGroundedSetAfReasoner(){
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleIdealSetAfReasoner.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleIdealSetAfReasoner.java
index bd5c08dd4..f0ac32508 100644
--- a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleIdealSetAfReasoner.java
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleIdealSetAfReasoner.java
@@ -32,7 +32,7 @@
  * @author Matthias Thimm, Sebastian Franke
  *
  */
-public class SimpleIdealSetAfReasoner extends AbstractExtensionSetAfReasoner {
+public class SimpleIdealSetAfReasoner extends AbstractSetAfExtensionReasoner {
 
 
 
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimplePreferredSetAfReasoner.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimplePreferredSetAfReasoner.java
index 0eb12b846..359d98175 100644
--- a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimplePreferredSetAfReasoner.java
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimplePreferredSetAfReasoner.java
@@ -33,7 +33,7 @@
  * @author Matthias Thimm, Sebastian Franke
  *
  */
-public class SimplePreferredSetAfReasoner extends AbstractExtensionSetAfReasoner {
+public class SimplePreferredSetAfReasoner extends AbstractSetAfExtensionReasoner {
 
 
 
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleSemiStableSetAfReasoner.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleSemiStableSetAfReasoner.java
index f0b475c08..c4a695134 100644
--- a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleSemiStableSetAfReasoner.java
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleSemiStableSetAfReasoner.java
@@ -33,7 +33,7 @@
  * @author Matthias Thimm, Sebastian Franke
  *
  */
-public class SimpleSemiStableSetAfReasoner extends AbstractExtensionSetAfReasoner {
+public class SimpleSemiStableSetAfReasoner extends AbstractSetAfExtensionReasoner {
 
 
 		/** Default */
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleStableSetAfReasoner.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleStableSetAfReasoner.java
index 8e8cb9cd9..2d7abee48 100644
--- a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleStableSetAfReasoner.java
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleStableSetAfReasoner.java
@@ -31,7 +31,7 @@
  * @author Matthias Thimm, Sebastian Franke
  *
  */
-public class SimpleStableSetAfReasoner extends AbstractExtensionSetAfReasoner {
+public class SimpleStableSetAfReasoner extends AbstractSetAfExtensionReasoner {
 
 
 
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleStageSetAfReasoner.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleStageSetAfReasoner.java
index d82b1a6cf..584accedc 100644
--- a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleStageSetAfReasoner.java
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/reasoners/SimpleStageSetAfReasoner.java
@@ -32,7 +32,7 @@
  * @author Matthias Thimm, Sebastian Franke
  *
  */
-public class SimpleStageSetAfReasoner extends AbstractExtensionSetAfReasoner {
+public class SimpleStageSetAfReasoner extends AbstractSetAfExtensionReasoner {
 
 
 
diff --git a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/syntax/SetAf.java b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/syntax/SetAf.java
index f90509927..965f3b76a 100644
--- a/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/syntax/SetAf.java
+++ b/org-tweetyproject-arg-setaf/src/main/java/org/tweetyproject/arg/setaf/syntax/SetAf.java
@@ -432,6 +432,16 @@ public boolean add(SetAttack edge) {
         return true;
     }
 
+    /**
+     * Add a new set-attack so the theory
+     * @param attackers the set of attacking arguments
+     * @param attacked the attacked argument
+     * @return "true" if the set-attack has been added
+     */
+    public boolean addSetAttack(Set<Argument> attackers, Argument attacked) {
+        return this.add(new SetAttack(attackers, attacked));
+    }
+
     @Override
     public Collection<Argument> getNodes() {
         return this.nodes;
diff --git a/org-tweetyproject-web/pom.xml b/org-tweetyproject-web/pom.xml
index 2d9425389..4586fc810 100644
--- a/org-tweetyproject-web/pom.xml
+++ b/org-tweetyproject-web/pom.xml
@@ -159,8 +159,13 @@
 			<artifactId>prob</artifactId>
 			<version>1.31-SNAPSHOT</version>
 		</dependency>
+        <dependency>
+            <groupId>org.tweetyproject.arg</groupId>
+            <artifactId>setaf</artifactId>
+            <version>1.31-SNAPSHOT</version>
+        </dependency>
 
-		<!-- SLF4J API
+        <!-- SLF4J API
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/RequestController.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/RequestController.java
index ff6d039f8..8a96704c9 100644
--- a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/RequestController.java
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/RequestController.java
@@ -18,39 +18,34 @@
  */
 package org.tweetyproject.web.services;
 
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.ObjectMapper;
+import javafx.util.Pair;
 import org.json.JSONException;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.HttpStatus;
-import org.springframework.lang.Nullable;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.ResponseBody;
 import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.server.ResponseStatusException;
+import org.tweetyproject.arg.aba.parser.AbaParser;
+import org.tweetyproject.arg.aba.reasoner.GeneralAbaReasoner;
+import org.tweetyproject.arg.aba.syntax.AbaTheory;
+import org.tweetyproject.arg.aba.syntax.Assumption;
 import org.tweetyproject.arg.adf.reasoner.AbstractADFReasoner;
-import org.tweetyproject.arg.adf.semantics.interpretation.Interpretation;
 import org.tweetyproject.arg.adf.syntax.adf.AbstractDialecticalFramework;
 import org.tweetyproject.arg.bipolar.reasoner.AbstractBipolarExtensionReasoner;
 import org.tweetyproject.arg.bipolar.syntax.BipolarArgumentationFramework;
+import org.tweetyproject.arg.delp.parser.DelpParser;
+import org.tweetyproject.arg.delp.reasoner.DelpReasoner;
+import org.tweetyproject.arg.delp.semantics.ComparisonCriterion;
+import org.tweetyproject.arg.delp.semantics.DelpAnswer;
+import org.tweetyproject.arg.delp.semantics.EmptyCriterion;
+import org.tweetyproject.arg.delp.semantics.GeneralizedSpecificity;
+import org.tweetyproject.arg.delp.syntax.DefeasibleLogicProgram;
+import org.tweetyproject.arg.dung.reasoner.AbstractExtensionReasoner;
 import org.tweetyproject.arg.dung.reasoner.IncompleteReasoner;
+import org.tweetyproject.arg.dung.semantics.Extension;
 import org.tweetyproject.arg.dung.semantics.Semantics;
+import org.tweetyproject.arg.dung.serialisability.syntax.SelectionFunction;
+import org.tweetyproject.arg.dung.serialisability.syntax.TerminationFunction;
 import org.tweetyproject.arg.dung.syntax.Argument;
 import org.tweetyproject.arg.dung.syntax.Attack;
 import org.tweetyproject.arg.dung.syntax.DungTheory;
@@ -59,13 +54,12 @@
 import org.tweetyproject.arg.prob.syntax.ProbabilisticArgumentationFramework;
 import org.tweetyproject.arg.rankings.reasoner.AbstractRankingReasoner;
 import org.tweetyproject.arg.rankings.semantics.RankingSemantics;
-import org.tweetyproject.causal.parser.CausalParser;
-import org.tweetyproject.causal.syntax.CausalKnowledgeBase;
+import org.tweetyproject.arg.setaf.reasoners.AbstractSetAfExtensionReasoner;
+import org.tweetyproject.arg.setaf.syntax.SetAf;
 import org.tweetyproject.commons.BeliefSet;
 import org.tweetyproject.commons.Formula;
 import org.tweetyproject.commons.Parser;
 import org.tweetyproject.commons.ParserException;
-import org.tweetyproject.comparator.GeneralComparator;
 import org.tweetyproject.logics.commons.analysis.InconsistencyMeasure;
 import org.tweetyproject.logics.commons.analysis.NaiveMusEnumerator;
 import org.tweetyproject.logics.fol.parser.FolParser;
@@ -87,14 +81,9 @@
 import org.tweetyproject.math.opt.solver.ApacheCommonsSimplex;
 import org.tweetyproject.math.opt.solver.GlpkSolver;
 import org.tweetyproject.math.opt.solver.Solver;
-import org.tweetyproject.web.services.aba.AbaGetSemanticsResponse;
-import org.tweetyproject.web.services.aba.AbaReasonerCalleeFactory;
-import org.tweetyproject.web.services.aba.AbaReasonerPost;
-import org.tweetyproject.web.services.aba.AbaReasonerResponse;
-import org.tweetyproject.web.services.aba.GeneralAbaReasonerFactory;
+import org.tweetyproject.web.services.aba.*;
 import org.tweetyproject.web.services.adf.*;
 import org.tweetyproject.web.services.bipolar.*;
-import org.tweetyproject.web.services.causal.*;
 import org.tweetyproject.web.services.delp.DeLPCallee;
 import org.tweetyproject.web.services.delp.DeLPPost;
 import org.tweetyproject.web.services.delp.DeLPResponse;
@@ -104,901 +93,444 @@
 import org.tweetyproject.web.services.incmes.InconsistencyGetMeasuresResponse;
 import org.tweetyproject.web.services.incmes.InconsistencyPost;
 import org.tweetyproject.web.services.incmes.InconsistencyValueResponse;
-import org.tweetyproject.web.services.rankings.*;
 import org.tweetyproject.web.services.paf.*;
+import org.tweetyproject.web.services.rankings.*;
 import org.tweetyproject.web.services.sequenceexplanation.*;
 import org.tweetyproject.web.services.sequenceexplanation.SequenceExplanationPost.GetSequenceExplanationsCmd;
 import org.tweetyproject.web.services.sequenceexplanation.SequenceExplanationPost.SequenceExplanationCmd;
 import org.tweetyproject.web.services.sequenceexplanation.SequenceExplanationResponse.GetSequenceExplanationsResult;
 import org.tweetyproject.web.services.sequenceexplanation.SequenceExplanationResponse.SequenceExplanationResult;
-import org.springframework.web.bind.annotation.ResponseBody;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.tweetyproject.arg.aba.parser.AbaParser;
-import org.tweetyproject.arg.aba.reasoner.GeneralAbaReasoner;
-import org.tweetyproject.arg.aba.semantics.AbaExtension;
-import org.tweetyproject.arg.aba.syntax.AbaTheory;
-import org.tweetyproject.arg.aba.syntax.Assumption;
-import org.tweetyproject.arg.delp.parser.DelpParser;
-import org.tweetyproject.arg.delp.reasoner.DelpReasoner;
-import org.tweetyproject.arg.delp.semantics.ComparisonCriterion;
-import org.tweetyproject.arg.delp.semantics.DelpAnswer;
-import org.tweetyproject.arg.delp.semantics.EmptyCriterion;
-import org.tweetyproject.arg.delp.semantics.GeneralizedSpecificity;
-import org.tweetyproject.arg.delp.syntax.DefeasibleLogicProgram;
-import org.tweetyproject.arg.dung.reasoner.AbstractExtensionReasoner;
-import org.tweetyproject.arg.dung.semantics.Extension;
-
-import javafx.util.Pair;
+import org.tweetyproject.web.services.serialisation.*;
+import org.tweetyproject.web.services.setaf.*;
 
 import javax.validation.Valid;
+import java.io.IOException;
+import java.util.*;
+import java.util.concurrent.*;
 import java.util.logging.Level;
 
-import static org.tweetyproject.web.services.causal.CausalReasonerResponse.Status.SUCCESS;
-import static org.tweetyproject.web.services.causal.CausalReasonerResponse.Status.TIMEOUT;
-
 
 /**
- * handles HTTP POST requests at the provided endpoints
+ * Handles HTTP POST requests for all TweetyProject web service endpoints.
  */
 @RestController
 public class RequestController {
 
-		/** Timeout for Dung argumentation framework services */
-		private final int SERVICES_TIMEOUT_DUNG = 600;
-		/** Timeout for Delp services */
-		private final int SERVICES_TIMEOUT_DELP = 600;
-		/** Timeout for inconsistency measure services */
-		private final int SERVICES_TIMEOUT_INCMES = 300;
-		/** Timeout for sequence explanation services */
-		private final int SERVICES_TIMEOUT_SEQUENCE_EXPLANATION = 300;
-		/** Timeout for causal reasoner services */
-		private final int SERVICES_TIMEOUT_CAUSAL = 300;
-
-		/** Service for sequence explanation reasoning */
-		private final SequenceExplanationService sequenceExplanationService;
-		/** Object mapper for JSON serialization */
-		private final ObjectMapper objectMapper;
-		/** Service for causal reasoning operations */
-		private final CausalReasonerService causalReasonerService;
+	private final int SERVICES_TIMEOUT_DUNG = 600;
+	private final int SERVICES_TIMEOUT_DELP = 600;
+	private final int SERVICES_TIMEOUT_INCMES = 300;
+	private final int SERVICES_TIMEOUT_SEQUENCE_EXPLANATION = 300;
+
+	private final SequenceExplanationService sequenceExplanationService;
 
-	/**
-	 * Constructs a RequestController with the required services
-	 * @param sequenceExplanationService the sequence explanation service
-	 * @param objectMapper			     the object mapper
-	 * @param causalReasonerService		 the causal reasoner service
-	 */
 	@Autowired
-	public RequestController(SequenceExplanationService sequenceExplanationService,
-	                         ObjectMapper objectMapper,
-	                         CausalReasonerService causalReasonerService) {
+	public RequestController(SequenceExplanationService sequenceExplanationService) {
 		this.sequenceExplanationService = sequenceExplanationService;
-		this.objectMapper = objectMapper;
-		this.causalReasonerService = causalReasonerService;
 	}
 
+	/** Holds the outcome of a timed callee execution. */
+	private static final class ExecutionResult {
+		final String answer;
+		final double time;
+		final String status;
+
+		ExecutionResult(String answer, double time, String status) {
+			this.answer = answer;
+			this.time = time;
+			this.status = status;
+		}
+	}
+
+	/**
+	 * Submits {@code callee} to a single-threaded executor, waits up to {@code userTimeout},
+	 * and returns an {@link ExecutionResult} with answer/time/status filled in.
+	 */
+	@SuppressWarnings({"rawtypes", "unchecked"})
+	private static ExecutionResult runCallee(Callee callee, int userTimeout, double requestTimeout, TimeUnit unit) {
+		ExecutorService executor = Executors.newSingleThreadExecutor();
+		try {
+			Future<Object> future = executor.submit((Callable<Object>) callee);
+			Pair<Object, Long> result = Utils.runServicesWithTimeout(future, userTimeout, unit);
+			executor.shutdownNow();
+			return new ExecutionResult(result.getKey().toString(), (double) result.getValue(), "SUCCESS");
+		} catch (TimeoutException e) {
+			executor.shutdownNow();
+			return new ExecutionResult(null, requestTimeout, "TIMEOUT");
+		} catch (Exception e) {
+			executor.shutdownNow();
+			return new ExecutionResult(null, 0.0, "Error");
+		}
+	}
+
+	// ── ABA ──────────────────────────────────────────────────────────────────
 
-/**
- * Handles HTTP POST requests at the endpoint "/aba". Parses and processes the incoming
- * JSON payload to perform various ABA reasoning commands.
- * Supported commands are:
- * - get_models: Return all models for a given semantics and beliefbase
- * - get_model: Return some model for a given semantics and beliefbase
- * - query: Query an assumption
- * - semantics: Return supported semantics
- *
- * @param AbaReasonerPost The request payload containing information for ABA reasoning.
- * @return A Response object containing the result of the ABA reasoning operation.
- * @throws ParserException If there is an error while parsing the input data.
- * @throws IOException If there is an error reading or writing data.
- * @throws JSONException If there is an error with JSON processing.
- * @throws org.codehaus.jettison.json.JSONException If there is an error with Jettison JSON processing.
- */
 	@PostMapping(value = "/aba", produces = "application/json", consumes = "application/json")
 	@ResponseBody
-	public Response handleRequest(
-			@RequestBody AbaReasonerPost AbaReasonerPost) throws ParserException, IOException, JSONException, org.codehaus.jettison.json.JSONException {
+	public Response handleRequest(@RequestBody AbaReasonerPost post)
+			throws ParserException, IOException, JSONException, org.codehaus.jettison.json.JSONException {
 
-			LoggerUtil.logger.info(String.format("User: %s  Command: %s", AbaReasonerPost.getEmail(), AbaReasonerPost.getCmd()));
-			if (AbaReasonerPost.getCmd().equals("semantics")) {
-				return handleGetSemantics(AbaReasonerPost);
-			}
-			Callee callee = null;
-			SatSolver.setDefaultSolver(new Sat4jSolver());
-			if (AbaReasonerPost.getKb_format().equals("pl")) {
-				AbaParser<PlFormula> parser1 = new AbaParser<PlFormula>(new PlParser());
-				Assumption<PlFormula> a = new Assumption<>(new Proposition(AbaReasonerPost.getQuery_assumption()));
-				AbaTheory<PlFormula> abat1 = null;
-				try {
-					abat1 = parser1.parseBeliefBase(AbaReasonerPost.getKb());
-				} catch (FileNotFoundException e) {
-					LoggerUtil.logger.log(Level.SEVERE,(String.format("Error while parsing the Beliefbase: %s", e.getClass().getSimpleName())));
-
-					e.printStackTrace();
-				} catch (ParserException e) {
-					LoggerUtil.logger.log(Level.SEVERE,(String.format("Error while parsing the Beliefbase: %s", e.getClass().getSimpleName())));
-
-					e.printStackTrace();
-				} catch (IOException e) {
-					LoggerUtil.logger.log(Level.SEVERE,(String.format("Error while parsing the Beliefbase: %s", e.getClass().getSimpleName())));
-					e.printStackTrace();
-				}
-
-				GeneralAbaReasoner<PlFormula> r1 = GeneralAbaReasonerFactory
-						.getReasoner(GeneralAbaReasonerFactory.Semantics.getSemantics(AbaReasonerPost.getSemantics()));
-				callee = AbaReasonerCalleeFactory
-						.getCallee(AbaReasonerCalleeFactory.Command.getCommand(AbaReasonerPost.getCmd()), r1, abat1,a);
-			}
+		LoggerUtil.logger.info(String.format("User: %s  Command: %s", post.getEmail(), post.getCmd()));
+		if (post.getCmd().equals("semantics"))
+			return handleGetSemantics(post);
 
-			if (AbaReasonerPost.getKb_format().equals("fol")) {
-				FolParser folparser = new FolParser();
-				FolSignature sig = folparser.parseSignature(AbaReasonerPost.getFol_signature());
-				AbaParser<FolFormula> parser1 = new AbaParser<FolFormula>(folparser);
-				Assumption<FolFormula> a = new Assumption<>(folparser.parseFormula(AbaReasonerPost.getQuery_assumption()));
-				parser1.setSymbolComma(";");
-				AbaTheory<FolFormula> abat1 = null;
-				folparser.setSignature(sig);
-				try {
-					abat1 = parser1.parseBeliefBase(AbaReasonerPost.getKb());
-					System.out.println("Parsed belief base: " + abat1);
-				} catch (FileNotFoundException e) {
-					LoggerUtil.logger.log(Level.SEVERE,(String.format("Error while parsing the Beliefbase: %s", e.getClass().getSimpleName())));
-					e.printStackTrace();
-				} catch (ParserException e) {
-					LoggerUtil.logger.log(Level.SEVERE,(String.format("Error while parsing the Beliefbase: %s", e.getClass().getSimpleName())));
-
-					e.printStackTrace();
-				} catch (IOException e) {
-					LoggerUtil.logger.log(Level.SEVERE,(String.format("Error while parsing the Beliefbase: %s", e.getClass().getSimpleName())));
-
-					e.printStackTrace();
-				}
-
-				GeneralAbaReasoner<FolFormula> r1 = GeneralAbaReasonerFactory
-						.getReasoner(GeneralAbaReasonerFactory.Semantics.getSemantics(AbaReasonerPost.getSemantics()));
-
-				try {
-					callee = AbaReasonerCalleeFactory
-						.getCallee(AbaReasonerCalleeFactory.Command.getCommand(AbaReasonerPost.getCmd()), r1, abat1,a);
-				}
-				catch (Exception e) {
-					LoggerUtil.logger.log(Level.SEVERE,(String.format("Error while creating ABAReasonerCallee:%s", e.getClass().getSimpleName())));
-				}
+		SatSolver.setDefaultSolver(new Sat4jSolver());
+		Callee callee = null;
 
+		if (post.getKb_format().equals("pl")) {
+			AbaParser<PlFormula> parser = new AbaParser<>(new PlParser());
+			Assumption<PlFormula> assumption = new Assumption<>(new Proposition(post.getQuery_assumption()));
+			AbaTheory<PlFormula> theory = null;
+			try {
+				theory = parser.parseBeliefBase(post.getKb());
+			} catch (ParserException | IOException e) {
+				LoggerUtil.logger.log(Level.SEVERE, String.format("Error while parsing the Beliefbase: %s", e.getClass().getSimpleName()));
 			}
+			GeneralAbaReasoner<PlFormula> reasoner = GeneralAbaReasonerFactory.getReasoner(
+					GeneralAbaReasonerFactory.Semantics.getSemantics(post.getSemantics()));
+			callee = AbaReasonerCalleeFactory.getCallee(
+					AbaReasonerCalleeFactory.Command.getCommand(post.getCmd()), reasoner, theory, assumption);
+		}
 
-			ExecutorService executor = Executors.newSingleThreadExecutor();
-			AbaReasonerResponse reasonerResponse = new AbaReasonerResponse(AbaReasonerPost.getCmd(),
-					AbaReasonerPost.getEmail(), AbaReasonerPost.getKb(), AbaReasonerPost.getKb_format(),
-					AbaReasonerPost.getFol_signature(), AbaReasonerPost.getQuery_assumption(),
-					AbaReasonerPost.getSemantics(), AbaReasonerPost.getTimeout(), "", 0.0,
-					AbaReasonerPost.getUnit_timeout(), "");
-			TimeUnit unit = Utils.getTimeoutUnit(AbaReasonerPost.getUnit_timeout());
-			int user_timeout = Utils.checkUserTimeout(AbaReasonerPost.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
+		if (post.getKb_format().equals("fol")) {
+			FolParser folParser = new FolParser();
+			FolSignature sig = folParser.parseSignature(post.getFol_signature());
+			folParser.setSignature(sig);
+			AbaParser<FolFormula> parser = new AbaParser<>(folParser);
+			parser.setSymbolComma(";");
+			Assumption<FolFormula> assumption = new Assumption<>(folParser.parseFormula(post.getQuery_assumption()));
+			AbaTheory<FolFormula> theory = null;
 			try {
-				// handle timeout
-				LoggerUtil.logger.info(String.format("Run command \"%s\" with timeout: %s %s", AbaReasonerPost.getCmd(),user_timeout, AbaReasonerPost.getUnit_timeout()));
-				if (AbaReasonerPost.getCmd().equals("get_models") || AbaReasonerPost.getCmd().equals("get_model")) {
-
-					Future<Collection<AbaExtension<Formula>>> future = executor.submit(callee);
-					Pair<Collection<AbaExtension<Formula>>, Long> result = Utils.runServicesWithTimeout(future,
-						user_timeout, unit);
-					LoggerUtil.logger.info(String.format("Execution of command \"%s\" finished after %s %s ", AbaReasonerPost.getCmd(),result.getValue(),AbaReasonerPost.getUnit_timeout()));
-						reasonerResponse.setTime(result.getValue());
-						reasonerResponse.setAnswer(result.getKey().toString());
-						reasonerResponse.setStatus("SUCCESS");
-					}
-					else if (AbaReasonerPost.getCmd().equals("query")){
-					Future<Boolean> future = executor.submit(callee);
-					Pair<Boolean, Long> result = Utils.runServicesWithTimeout(future,
-						user_timeout, unit);
-
-					LoggerUtil.logger.info(String.format("Execution of command \"%s\" finished after %s %s ", AbaReasonerPost.getCmd(),result.getValue(),AbaReasonerPost.getUnit_timeout()));
-
-						reasonerResponse.setTime(result.getValue());
-					reasonerResponse.setAnswer(result.getKey().toString());
-					reasonerResponse.setStatus("SUCCESS");
-				}
-				else{
-					LoggerUtil.logger.log(Level.SEVERE,String.format("Command \"%s\"  not found.", AbaReasonerPost.getCmd()));
-					Pair<String,Integer> result = new Pair<String,Integer>("Command not found",0 );
-					System.out.println(result.getKey().toString());
-					reasonerResponse.setTime(result.getValue());
-					reasonerResponse.setAnswer(result.getKey().toString());
-					reasonerResponse.setStatus("ERROR");
-				}
-
-				executor.shutdownNow();
-			} catch (TimeoutException e) {
-				LoggerUtil.logger.info(String.format("Execution of command \"%s\" reached timeout of %s %s and was aborted.", AbaReasonerPost.getCmd(),AbaReasonerPost.getTimeout(),AbaReasonerPost.getUnit_timeout()));
-				reasonerResponse.setTime(AbaReasonerPost.getTimeout());
-				reasonerResponse.setAnswer(null);
-				reasonerResponse.setStatus("TIMEOUT");
-				executor.shutdownNow();
+				theory = parser.parseBeliefBase(post.getKb());
+			} catch (ParserException | IOException e) {
+				LoggerUtil.logger.log(Level.SEVERE, String.format("Error while parsing the Beliefbase: %s", e.getClass().getSimpleName()));
+			}
+			GeneralAbaReasoner<FolFormula> reasoner = GeneralAbaReasonerFactory.getReasoner(
+					GeneralAbaReasonerFactory.Semantics.getSemantics(post.getSemantics()));
+			try {
+				callee = AbaReasonerCalleeFactory.getCallee(
+						AbaReasonerCalleeFactory.Command.getCommand(post.getCmd()), reasoner, theory, assumption);
 			} catch (Exception e) {
-				LoggerUtil.logger.log(Level.SEVERE,(String.format("Error while running command \"%s\": %s",AbaReasonerPost.getCmd(), e.getClass().getSimpleName())));
-				reasonerResponse.setTime(0.0);
-				reasonerResponse.setAnswer(null);
-				reasonerResponse.setStatus("Error");
-
-				executor.shutdownNow();
+				LoggerUtil.logger.log(Level.SEVERE, String.format("Error while creating ABAReasonerCallee: %s", e.getClass().getSimpleName()));
 			}
-			return reasonerResponse;
+		}
+
+		AbaReasonerResponse response = new AbaReasonerResponse(post.getCmd(), post.getEmail(), post.getKb(),
+				post.getKb_format(), post.getFol_signature(), post.getQuery_assumption(),
+				post.getSemantics(), post.getTimeout(), "", 0.0, post.getUnit_timeout(), "");
+
+		if (!post.getCmd().equals("get_models") && !post.getCmd().equals("get_model") && !post.getCmd().equals("query")) {
+			LoggerUtil.logger.log(Level.SEVERE, String.format("Command \"%s\" not found.", post.getCmd()));
+			response.setAnswer("Command not found");
+			response.setStatus("ERROR");
+			return response;
+		}
+
+		TimeUnit unit = Utils.getTimeoutUnit(post.getUnit_timeout());
+		int userTimeout = Utils.checkUserTimeout(post.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
+		LoggerUtil.logger.info(String.format("Run command \"%s\" with timeout: %s %s", post.getCmd(), userTimeout, post.getUnit_timeout()));
 
+		ExecutionResult r = runCallee(callee, userTimeout, post.getTimeout(), unit);
+		response.setAnswer(r.answer);
+		response.setTime(r.time);
+		response.setStatus(r.status);
+		LoggerUtil.logger.info(String.format("Command \"%s\" finished with status: %s", post.getCmd(), r.status));
+		return response;
 	}
 
-	/**
- 	* Handles HTTP POST requests for Dung Reasoner operations.
- 	*
- 	* <p>This method processes requests with the endpoint "/dung" that have the specified content types
- 	* for both request and response. It takes a DungReasonerPost object as the request body and returns
- 	* a Response object as the response body.</p>
- 	*
- 	* <p>The method checks the command (cmd) from the DungReasonerPost object and performs different
- 	* operations based on the command. If the command is "info," it delegates the request to the getInfo
- 	* method. If the command is "get_models" or "get_model," it processes the request using the DungTheory,
- 	* AbstractExtensionReasoner, and other components. The result includes information about the execution
- 	* time, answer, and status, which is encapsulated in a DungReasonerResponse object.</p>
- 	*
- 	* <p>In case of a timeout during execution, the method sets the response status to "TIMEOUT" and includes
- 	* the specified timeout duration. If any other exception occurs, the response status is set to "Error,"
- 	* and the method provides a generic response with a time of 0.0 and a null answer.</p>
- 	*
- 	* <p>If the command is not recognized or not applicable, the method returns a default DungReasonerResponse.</p>
- 	*
- 	* @param dungReasonerPost The DungReasonerPost object representing the request payload.
- 	* @return A Response object representing the response payload.
- 	*/
+	// ── Dung ─────────────────────────────────────────────────────────────────
+
 	@PostMapping(value = "/dung", produces = "application/json", consumes = "application/json")
 	@ResponseBody
-	public Response handleRequest(
-			@RequestBody DungReasonerPost dungReasonerPost) {
-		if (dungReasonerPost.getCmd().equals("info"))
-			return (Response) getInfo(dungReasonerPost);
-
-		if (dungReasonerPost.getCmd().equals("get_models") || dungReasonerPost.getCmd().equals("get_model") || dungReasonerPost.getCmd().equals("get_credulous") || dungReasonerPost.getCmd().equals("get_skeptical")) {
-			DungTheory dungTheory = AbstractExtensionReasonerFactory.getDungTheory(dungReasonerPost.getNr_of_arguments(),
-					dungReasonerPost.getAttacks());
-			ExecutorService executor = Executors.newSingleThreadExecutor();
-			DungReasonerResponse reasonerResponse = new DungReasonerResponse(dungReasonerPost.getCmd(),
-					dungReasonerPost.getEmail(), dungReasonerPost.getNr_of_arguments(), dungReasonerPost.getAttacks(),
-					dungReasonerPost.getSemantics(), dungReasonerPost.getSolver(), null, 0,
-					dungReasonerPost.getUnit_timeout(), "ERRORs");
-			TimeUnit unit = Utils.getTimeoutUnit(dungReasonerPost.getUnit_timeout());
-			AbstractExtensionReasoner reasoner = AbstractExtensionReasonerFactory.getReasoner(
-					Semantics.getSemantics(dungReasonerPost.getSemantics()));
-			Callee callee = DungReasonerCalleeFactory.getCallee(
-					Command.getCommand(dungReasonerPost.getCmd()), reasoner, dungTheory);
-			int user_timeout = Utils.checkUserTimeout(dungReasonerPost.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
-			try {
-				// handle timeout
-				Future<Collection<Extension<DungTheory>>> future = executor.submit(callee);
-				Pair<Collection<Extension<DungTheory>>, Long> result = Utils.runServicesWithTimeout(future,
-						user_timeout, unit);
-				executor.shutdownNow();
-				reasonerResponse.setTime(result.getValue());
-				reasonerResponse.setAnswer(result.getKey().toString());
-				reasonerResponse.setStatus("SUCCESS");
-			} catch (TimeoutException e) {
-				reasonerResponse.setTime(dungReasonerPost.getTimeout());
-				reasonerResponse.setAnswer(null);
-				reasonerResponse.setStatus("TIMEOUT");
-				executor.shutdownNow();
-			} catch (Exception e) {
-				reasonerResponse.setTime(0.0);
-				reasonerResponse.setAnswer(null);
-				reasonerResponse.setStatus("Error");
+	public Response handleRequest(@RequestBody DungReasonerPost post) {
+		if (post.getCmd().equals("info"))
+			return getInfo(post);
 
-				executor.shutdownNow();
-			}
-			return reasonerResponse;
-		} else {
+		Command cmd = Command.getCommand(post.getCmd());
+		if (cmd == null)
 			return new DungReasonerResponse();
-		}
+
+		DungTheory theory = AbstractExtensionReasonerFactory.getDungTheory(post.getNr_of_arguments(), post.getAttacks());
+		AbstractExtensionReasoner reasoner = AbstractExtensionReasonerFactory.getReasoner(post.getSemantics(), post.getArgs());
+		Callee callee = DungReasonerCalleeFactory.getCallee(cmd, reasoner, theory);
+		TimeUnit unit = Utils.getTimeoutUnit(post.getUnit_timeout());
+		int userTimeout = Utils.checkUserTimeout(post.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
+
+		DungReasonerResponse response = new DungReasonerResponse(post.getCmd(), post.getEmail(),
+				post.getNr_of_arguments(), post.getAttacks(), post.getSemantics(), post.getSolver(),
+				null, 0, post.getUnit_timeout(), "ERROR");
+		ExecutionResult r = runCallee(callee, userTimeout, post.getTimeout(), unit);
+		response.setAnswer(r.answer);
+		response.setTime(r.time);
+		response.setStatus(r.status);
+		return response;
 	}
 
-	/**
-	 * Handles HTTP POST requests for Dung Reasoner operations.
-	 *
-	 * <p>This method processes requests with the endpoint "/dung" that have the specified content types
-	 * for both request and response. It takes a DungReasonerPost object as the request body and returns
-	 * a Response object as the response body.</p>
-	 *
-	 * <p>The method checks the command (cmd) from the DungReasonerPost object and performs different
-	 * operations based on the command. If the command is "info," it delegates the request to the getInfo
-	 * method. If the command is "get_models" or "get_model," it processes the request using the DungTheory,
-	 * AbstractExtensionReasoner, and other components. The result includes information about the execution
-	 * time, answer, and status, which is encapsulated in a DungReasonerResponse object.</p>
-	 *
-	 * <p>In case of a timeout during execution, the method sets the response status to "TIMEOUT" and includes
-	 * the specified timeout duration. If any other exception occurs, the response status is set to "Error,"
-	 * and the method provides a generic response with a time of 0.0 and a null answer.</p>
-	 *
-	 * <p>If the command is not recognized or not applicable, the method returns a default DungReasonerResponse.</p>
-	 *
-	 * @param iafReasonerPost The DungReasonerPost object representing the request payload.
-	 * @return A Response object representing the response payload.
-	 */
+	@PostMapping(value = "/info", produces = "application/json")
+	@ResponseBody
+	public DungServicesInfoResponse getInfo(@RequestBody DungReasonerPost post) {
+		DungServicesInfoResponse response = new DungServicesInfoResponse();
+		response.setReply("info");
+		response.setEmail(post.getEmail());
+		response.setBackend_timeout(SERVICES_TIMEOUT_DUNG);
+		ArrayList<String> semantics_ids = new ArrayList<>();
+		for (Semantics s : AbstractExtensionReasonerFactory.getSemantics())
+			semantics_ids.add(s.abbreviation());
+		response.setSemantics(semantics_ids);
+		ArrayList<String> command_ids = new ArrayList<>();
+		for (Command c : DungReasonerCalleeFactory.getCommands())
+			command_ids.add(c.id);
+		response.setCommands(command_ids);
+		return response;
+	}
+
+	// ── IAF ──────────────────────────────────────────────────────────────────
+
 	@PostMapping(value = "/iaf", produces = "application/json", consumes = "application/json")
 	@ResponseBody
-	public Response handleRequest(
-			@RequestBody IafReasonerPost iafReasonerPost) {
-		if (iafReasonerPost.getCmd().equals("info"))
-			return (Response) getIafInfo(iafReasonerPost.getEmail());
-
-		if (iafReasonerPost.getCmd().equals("get_models_pos") || iafReasonerPost.getCmd().equals("get_credulous_pos") || iafReasonerPost.getCmd().equals("get_skeptical_pos") || iafReasonerPost.getCmd().equals("get_models_nec") || iafReasonerPost.getCmd().equals("get_credulous_nec") || iafReasonerPost.getCmd().equals("get_skeptical_nec")) {
-			IncompleteTheory incompleteTheory = IafReasonerFactory.getIncompleteTheory(iafReasonerPost.getNr_of_arguments(),
-					iafReasonerPost.getUncertainArguments(), iafReasonerPost.getDefiniteAttacks(), iafReasonerPost.getUncertainAttacks());
-			ExecutorService executor = Executors.newSingleThreadExecutor();
-			IafReasonerResponse reasonerResponse = new IafReasonerResponse(iafReasonerPost.getCmd(),
-					iafReasonerPost.getEmail(), iafReasonerPost.getNr_of_arguments(), iafReasonerPost.getUncertainArguments(),
-					iafReasonerPost.getDefiniteAttacks(), iafReasonerPost.getUncertainAttacks(),
-					iafReasonerPost.getSemantics(), iafReasonerPost.getSolver(), null, 0,
-					iafReasonerPost.getUnit_timeout(), "ERRORs");
-			TimeUnit unit = Utils.getTimeoutUnit(iafReasonerPost.getUnit_timeout());
-			IncompleteReasoner reasoner = IafReasonerFactory.getReasoner(
-					Semantics.getSemantics(iafReasonerPost.getSemantics()));
-			Callee callee = IafReasonerCalleeFactory.getCallee(
-					IafReasonerCalleeFactory.Command.getCommand(iafReasonerPost.getCmd()), reasoner, incompleteTheory);
-			int user_timeout = Utils.checkUserTimeout(iafReasonerPost.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
-			try {
-				// handle timeout
-				Future<Collection<Extension<IncompleteTheory>>> future = executor.submit(callee);
-				Pair<Collection<Extension<IncompleteTheory>>, Long> result = Utils.runServicesWithTimeout(future,
-						user_timeout, unit);
-				executor.shutdownNow();
-				reasonerResponse.setTime(result.getValue());
-				reasonerResponse.setAnswer(result.getKey().toString());
-				reasonerResponse.setStatus("SUCCESS");
-			} catch (TimeoutException e) {
-				reasonerResponse.setTime(iafReasonerPost.getTimeout());
-				reasonerResponse.setAnswer(null);
-				reasonerResponse.setStatus("TIMEOUT");
-				executor.shutdownNow();
-			} catch (Exception e) {
-				reasonerResponse.setTime(0.0);
-				reasonerResponse.setAnswer(null);
-				reasonerResponse.setStatus("Error");
+	public Response handleRequest(@RequestBody IafReasonerPost post) {
+		if (post.getCmd().equals("info"))
+			return getIafInfo(post.getEmail());
 
-				executor.shutdownNow();
-			}
-			return reasonerResponse;
-		} else {
+		IafReasonerCalleeFactory.Command cmd = IafReasonerCalleeFactory.Command.getCommand(post.getCmd());
+		if (cmd == null)
 			return new IafReasonerResponse();
-		}
+
+		IncompleteTheory theory = IafReasonerFactory.getIncompleteTheory(post.getNr_of_arguments(),
+				post.getUncertainArguments(), post.getDefiniteAttacks(), post.getUncertainAttacks());
+		IncompleteReasoner reasoner = IafReasonerFactory.getReasoner(Semantics.getSemantics(post.getSemantics()));
+		Callee callee = IafReasonerCalleeFactory.getCallee(cmd, reasoner, theory);
+		TimeUnit unit = Utils.getTimeoutUnit(post.getUnit_timeout());
+		int userTimeout = Utils.checkUserTimeout(post.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
+
+		IafReasonerResponse response = new IafReasonerResponse(post.getCmd(), post.getEmail(),
+				post.getNr_of_arguments(), post.getUncertainArguments(), post.getDefiniteAttacks(),
+				post.getUncertainAttacks(), post.getSemantics(), post.getSolver(),
+				null, 0, post.getUnit_timeout(), "ERROR");
+		ExecutionResult r = runCallee(callee, userTimeout, post.getTimeout(), unit);
+		response.setAnswer(r.answer);
+		response.setTime(r.time);
+		response.setStatus(r.status);
+		return response;
 	}
 
-	/**
-	 * Retrieves IAF services information
-	 * @param email the email address
-	 * @return IafServicesInfoResponse containing service information
-	 */
 	private IafServicesInfoResponse getIafInfo(String email) {
 		IafServicesInfoResponse response = new IafServicesInfoResponse();
 		response.setReply("info");
 		response.setEmail(email);
 		response.setBackend_timeout(SERVICES_TIMEOUT_DUNG);
-		var sem = IafReasonerFactory.getSemantics();
-		ArrayList<String> semantics_ids = new ArrayList<String>();
-		for (var s : sem) {
+		ArrayList<String> semantics_ids = new ArrayList<>();
+		for (var s : IafReasonerFactory.getSemantics())
 			semantics_ids.add(s.abbreviation());
-		}
 		response.setSemantics(semantics_ids);
-
-		IafReasonerCalleeFactory.Command[] com = IafReasonerCalleeFactory.getCommands();
-		ArrayList<String> command_ids = new ArrayList<String>();
-		for (var c : com) {
+		ArrayList<String> command_ids = new ArrayList<>();
+		for (var c : IafReasonerCalleeFactory.getCommands())
 			command_ids.add(c.id);
-		}
 		response.setCommands(command_ids);
-
 		return response;
 	}
 
-	/**
-	 * Handles HTTP POST requests for Ranking Reasoner operations.
-	 *
-	 * <p>This method processes requests with the endpoint "/rankings" that have the specified content types
-	 * for both request and response. It takes a DungReasonerPost object as the request body and returns
-	 * a Response object as the response body.</p>
-	 *
-	 * <p>The method checks the command (cmd) from the DungReasonerPost object and performs different
-	 * operations based on the command. If the command is "info," it delegates the request to the getInfo
-	 * method. If the command is "get_models" or "get_model," it processes the request using the DungTheory,
-	 * AbstractRankingReasoner, and other components. The result includes information about the execution
-	 * time, answer, and status, which is encapsulated in a DungReasonerResponse object.</p>
-	 *
-	 * <p>In case of a timeout during execution, the method sets the response status to "TIMEOUT" and includes
-	 * the specified timeout duration. If any other exception occurs, the response status is set to "Error,"
-	 * and the method provides a generic response with a time of 0.0 and a null answer.</p>
-	 *
-	 * <p>If the command is not recognized or not applicable, the method returns a default DungReasonerResponse.</p>
-	 *
-	 * @param rankingReasonerPost The DungReasonerPost object representing the request payload.
-	 * @return A Response object representing the response payload.
-	 */
+	// ── Rankings ─────────────────────────────────────────────────────────────
+
 	@PostMapping(value = "/rankings", produces = "application/json", consumes = "application/json")
 	@ResponseBody
-	public Response handleRequest(
-			@RequestBody RankingReasonerPost rankingReasonerPost) {
-		if (rankingReasonerPost.getCmd().equals("info"))
-			return (Response) getRankingInfo(rankingReasonerPost.getEmail());
-
-		if (rankingReasonerPost.getCmd().equals("get_model")) {
-			DungTheory dungTheory = AbstractExtensionReasonerFactory.getDungTheory(rankingReasonerPost.getNr_of_arguments(),
-					rankingReasonerPost.getAttacks());
-			ExecutorService executor = Executors.newSingleThreadExecutor();
-			RankingReasonerResponse reasonerResponse = new RankingReasonerResponse(rankingReasonerPost.getCmd(),
-					rankingReasonerPost.getEmail(), rankingReasonerPost.getNr_of_arguments(), rankingReasonerPost.getAttacks(),
-					rankingReasonerPost.getSemantics(), AbstractRankingReasonerFactory.getRankingType(rankingReasonerPost.getSemantics()), rankingReasonerPost.getSolver(), null, 0,
-					rankingReasonerPost.getUnit_timeout(), "ERRORs");
-			TimeUnit unit = Utils.getTimeoutUnit(rankingReasonerPost.getUnit_timeout());
-			AbstractRankingReasoner<?> reasoner = AbstractRankingReasonerFactory.getReasoner(
-					RankingSemantics.getSemantics(rankingReasonerPost.getSemantics()));
-			Callee callee = RankingReasonerCalleeFactory.getCallee(
-					RankingReasonerCalleeFactory.Command.getCommand(rankingReasonerPost.getCmd()), reasoner, dungTheory);
-			int user_timeout = Utils.checkUserTimeout(rankingReasonerPost.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
-			try {
-				// handle timeout
-				Future<GeneralComparator<Argument,DungTheory>> future = executor.submit(callee);
-				Pair<GeneralComparator<Argument, DungTheory>, Long> result = Utils.runServicesWithTimeout(future,
-						user_timeout, unit);
-				executor.shutdownNow();
-				reasonerResponse.setTime(result.getValue());
-				reasonerResponse.setAnswer(result.getKey().toString());
-				reasonerResponse.setStatus("SUCCESS");
-			} catch (TimeoutException e) {
-				reasonerResponse.setTime(rankingReasonerPost.getTimeout());
-				reasonerResponse.setAnswer(null);
-				reasonerResponse.setStatus("TIMEOUT");
-				executor.shutdownNow();
-			} catch (Exception e) {
-				reasonerResponse.setTime(0.0);
-				reasonerResponse.setAnswer(null);
-				reasonerResponse.setStatus("Error");
+	public Response handleRequest(@RequestBody RankingReasonerPost post) {
+		if (post.getCmd().equals("info"))
+			return getRankingInfo(post.getEmail());
 
-				executor.shutdownNow();
-			}
-			return reasonerResponse;
-		} else {
+		RankingReasonerCalleeFactory.Command cmd = RankingReasonerCalleeFactory.Command.getCommand(post.getCmd());
+		if (cmd == null)
 			return new RankingReasonerResponse();
-		}
+
+		DungTheory theory = AbstractExtensionReasonerFactory.getDungTheory(post.getNr_of_arguments(), post.getAttacks());
+		AbstractRankingReasoner<?> reasoner = AbstractRankingReasonerFactory.getReasoner(RankingSemantics.getSemantics(post.getSemantics()), post.getArgs());
+		Callee callee = RankingReasonerCalleeFactory.getCallee(cmd, reasoner, theory);
+		TimeUnit unit = Utils.getTimeoutUnit(post.getUnit_timeout());
+		int userTimeout = Utils.checkUserTimeout(post.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
+
+		RankingReasonerResponse response = new RankingReasonerResponse(post.getCmd(), post.getEmail(),
+				post.getNr_of_arguments(), post.getAttacks(), post.getSemantics(),
+				AbstractRankingReasonerFactory.getRankingType(post.getSemantics()),
+				post.getSolver(), null, 0, post.getUnit_timeout(), "ERROR");
+		ExecutionResult r = runCallee(callee, userTimeout, post.getTimeout(), unit);
+		response.setAnswer(r.answer);
+		response.setTime(r.time);
+		response.setStatus(r.status);
+		return response;
 	}
 
-	/**
-	 * Retrieves Ranking services information
-	 * @param email the email address
-	 * @return RankingServicesInfoResponse containing service information
-	 */
 	private RankingServicesInfoResponse getRankingInfo(String email) {
 		RankingServicesInfoResponse response = new RankingServicesInfoResponse();
 		response.setReply("info");
 		response.setEmail(email);
 		response.setBackend_timeout(SERVICES_TIMEOUT_DUNG);
-		var sem = AbstractRankingReasonerFactory.getSemantics();
-		ArrayList<String> semantics_ids = new ArrayList<String>();
-		for (var s : sem) {
+		ArrayList<String> semantics_ids = new ArrayList<>();
+		for (var s : AbstractRankingReasonerFactory.getSemantics())
 			semantics_ids.add(s.getId());
-		}
 		response.setSemantics(semantics_ids);
-
-		RankingReasonerCalleeFactory.Command[] com = RankingReasonerCalleeFactory.getCommands();
-		ArrayList<String> command_ids = new ArrayList<String>();
-		for (var c : com) {
+		ArrayList<String> command_ids = new ArrayList<>();
+		for (var c : RankingReasonerCalleeFactory.getCommands())
 			command_ids.add(c.id);
-		}
 		response.setCommands(command_ids);
-
 		return response;
 	}
 
-	/**
-	 * Handles HTTP POST requests for ADF Reasoner operations.
-	 *
-	 * <p>This method processes requests with the endpoint "/dung" that have the specified content types
-	 * for both request and response. It takes a AdfReasonerPost object as the request body and returns
-	 * a Response object as the response body.</p>
-	 *
-	 * <p>The method checks the command (cmd) from the AdfReasonerPost object and performs different
-	 * operations based on the command. If the command is "info," it delegates the request to the getInfo
-	 * method. If the command is "get_models" or "get_model," it processes the request using the ADF,
-	 * AbstractExtensionReasoner, and other components. The result includes information about the execution
-	 * time, answer, and status, which is encapsulated in a DungReasonerResponse object.</p>
-	 *
-	 * <p>In case of a timeout during execution, the method sets the response status to "TIMEOUT" and includes
-	 * the specified timeout duration. If any other exception occurs, the response status is set to "Error,"
-	 * and the method provides a generic response with a time of 0.0 and a null answer.</p>
-	 *
-	 * <p>If the command is not recognized or not applicable, the method returns a default DungReasonerResponse.</p>
-	 *
-	 * @param adfReasonerPost The DungReasonerPost object representing the request payload.
-	 * @return A Response object representing the response payload.
-	 */
+	// ── ADF ──────────────────────────────────────────────────────────────────
+
 	@PostMapping(value = "/adf", produces = "application/json", consumes = "application/json")
 	@ResponseBody
-	public Response handleRequest(
-			@RequestBody AdfReasonerPost adfReasonerPost) {
-		if (adfReasonerPost.getCmd().equals("info"))
-			return (Response) getAdfInfo(adfReasonerPost.getEmail());
+	public Response handleRequest(@RequestBody AdfReasonerPost post) {
+		if (post.getCmd().equals("info"))
+			return getAdfInfo(post.getEmail());
 
-		if (adfReasonerPost.getCmd().equals("get_models") || adfReasonerPost.getCmd().equals("get_credulous") || adfReasonerPost.getCmd().equals("get_skeptical")) {
-			ExecutorService executor = Executors.newSingleThreadExecutor();
-			AdfReasonerResponse reasonerResponse = new AdfReasonerResponse(adfReasonerPost.getCmd(),
-					adfReasonerPost.getEmail(), adfReasonerPost.getNr_of_arguments(), adfReasonerPost.getConditions(),
-					adfReasonerPost.getSemantics(), adfReasonerPost.getSolver(), null, 0,
-					adfReasonerPost.getUnit_timeout(), "ERRORs");
-			TimeUnit unit = Utils.getTimeoutUnit(adfReasonerPost.getUnit_timeout());
-			try {
-				AbstractDialecticalFramework adf = AbstractAdfReasonerFactory.getAdf(adfReasonerPost.getNr_of_arguments(),
-						adfReasonerPost.getConditions());
-				AbstractADFReasoner reasoner = AbstractAdfReasonerFactory.getReasoner(
-						Semantics.getSemantics(adfReasonerPost.getSemantics()));
-				Callee callee = AdfReasonerCalleeFactory.getCallee(
-						AdfReasonerCalleeFactory.Command.getCommand(adfReasonerPost.getCmd()), reasoner, adf);
-				int user_timeout = Utils.checkUserTimeout(adfReasonerPost.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
-				// handle timeout
-				Future<Collection<Interpretation>> future = executor.submit(callee);
-				Pair<Collection<Interpretation>, Long> result = Utils.runServicesWithTimeout(future,
-						user_timeout, unit);
-				executor.shutdownNow();
-				reasonerResponse.setTime(result.getValue());
-				reasonerResponse.setAnswer(result.getKey().toString().replace("[","{").replace("]", "}"));
-				reasonerResponse.setStatus("SUCCESS");
-			} catch (TimeoutException e) {
-				reasonerResponse.setTime(adfReasonerPost.getTimeout());
-				reasonerResponse.setAnswer(null);
-				reasonerResponse.setStatus("TIMEOUT");
-				executor.shutdownNow();
-			} catch (Exception e) {
-				reasonerResponse.setTime(0.0);
-				reasonerResponse.setAnswer(null);
-				reasonerResponse.setStatus("Error");
-				executor.shutdownNow();
-			}
-			return reasonerResponse;
-		} else {
+		AdfReasonerCalleeFactory.Command cmd = AdfReasonerCalleeFactory.Command.getCommand(post.getCmd());
+		if (cmd == null)
 			return new AdfReasonerResponse();
-		}
+
+		AbstractDialecticalFramework adf = AbstractAdfReasonerFactory.getAdf(post.getNr_of_arguments(), post.getConditions());
+		AbstractADFReasoner reasoner = AbstractAdfReasonerFactory.getReasoner(Semantics.getSemantics(post.getSemantics()));
+		Callee callee = AdfReasonerCalleeFactory.getCallee(cmd, reasoner, adf);
+		TimeUnit unit = Utils.getTimeoutUnit(post.getUnit_timeout());
+		int userTimeout = Utils.checkUserTimeout(post.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
+
+		AdfReasonerResponse response = new AdfReasonerResponse(post.getCmd(), post.getEmail(),
+				post.getNr_of_arguments(), post.getConditions(), post.getSemantics(), post.getSolver(),
+				null, 0, post.getUnit_timeout(), "ERROR");
+		ExecutionResult r = runCallee(callee, userTimeout, post.getTimeout(), unit);
+		// ADF uses curly braces instead of square brackets in the answer format
+		response.setAnswer(r.answer != null ? r.answer.replace("[", "{").replace("]", "}") : null);
+		response.setTime(r.time);
+		response.setStatus(r.status);
+		return response;
 	}
 
-	/**
-	 * Retrieves ADF services information
-	 * @param email the email address
-	 * @return AdfServicesInfoResponse containing service information
-	 */
 	private AdfServicesInfoResponse getAdfInfo(String email) {
 		AdfServicesInfoResponse response = new AdfServicesInfoResponse();
 		response.setReply("info");
 		response.setEmail(email);
 		response.setBackend_timeout(SERVICES_TIMEOUT_DUNG);
-		var sem = AbstractAdfReasonerFactory.getSemantics();
-		ArrayList<String> semantics_ids = new ArrayList<String>();
-		for (var s : sem) {
+		ArrayList<String> semantics_ids = new ArrayList<>();
+		for (var s : AbstractAdfReasonerFactory.getSemantics())
 			semantics_ids.add(s.abbreviation());
-		}
 		response.setSemantics(semantics_ids);
-
-		AdfReasonerCalleeFactory.Command[] com = AdfReasonerCalleeFactory.getCommands();
-		ArrayList<String> command_ids = new ArrayList<String>();
-		for (var c : com) {
+		ArrayList<String> command_ids = new ArrayList<>();
+		for (var c : AdfReasonerCalleeFactory.getCommands())
 			command_ids.add(c.id);
-		}
 		response.setCommands(command_ids);
-
 		return response;
 	}
 
-	/**
- 	* Handles HTTP POST requests for ping operations.
- 	*
- 	* <p>This method processes requests with the endpoint "/ping" that have the specified content type
- 	* for the request and response. It takes a Ping object as the request body and returns the same
- 	* Ping object as the response body.</p>
- 	*
- 	* <p>The method echoes the received Ping object, providing a simple way to test the connectivity
- 	* or response of the service. The response contains the same information as the request, including
- 	* the identifier (id) and content of the Ping object.</p>
- 	*
- 	* @param ping_Greeting The Ping object representing the request payload.
- 	* @return A Ping object representing the response payload.
- 	*/
-	@PostMapping(value = "/ping", produces = "application/json")
-	@ResponseBody
-	public Ping ping(@RequestBody Ping ping_Greeting) {
-		return ping_Greeting;
-	}
-
-	/**
-	 * Handles a POST request to retrieve information about the Dung reasoner services. This method constructs a response
-	 * with general information about the services available, such as available semantics and commands. The input data
-	 * includes email and other user-specific details, which are used to tailor the response.
-	 *
-	 * @param dungPost A {@link DungReasonerPost} object containing the data sent by the client in the POST request body.
-	 *                 This typically includes identifiers like email that can be used to personalize or secure the response.
-	 * @return A {@link DungServicesInfoResponse} object containing a variety of information about the services,
-	 *         including available semantics and commands supported by the Dung reasoner. The response is structured
-	 *         for JSON representation suitable for client-side consumption.
-	 */
-	@PostMapping(value = "/info", produces = "application/json")
-	@ResponseBody
-	public DungServicesInfoResponse getInfo(@RequestBody DungReasonerPost dungPost) {
-		DungServicesInfoResponse response = new DungServicesInfoResponse();
-		response.setReply("info");
-		response.setEmail(dungPost.getEmail());
-		response.setBackend_timeout(SERVICES_TIMEOUT_DUNG);
-		Semantics[] sem = AbstractExtensionReasonerFactory.getSemantics();
-		ArrayList<String> semantics_ids = new ArrayList<String>();
-		for (Semantics s : sem) {
-			semantics_ids.add(s.abbreviation());
-		}
-		response.setSemantics(semantics_ids);
-
-		Command[] com = DungReasonerCalleeFactory.getCommands();
-		ArrayList<String> command_ids = new ArrayList<String>();
-		for (Command c : com) {
-			command_ids.add(c.id);
-		}
-		response.setCommands(command_ids);
-
-		// response.setSemantics(AbstractExtensionReasonerFactory.Semantics.values());
-		return response;
-	}
+	// ── Bipolar ──────────────────────────────────────────────────────────────
 
-	/**
-	 * Handles HTTP POST requests for bipolar extension reasoner operations.
-	 *
-	 * <p>This method processes requests with the endpoint "/bipolar" that have the specified content types
-	 * for both request and response. It takes a BipolarReasonerPost object as the request body and returns
-	 * a Response object as the response body.</p>
-	 *
-	 * <p>The method checks the command (cmd) from the BipolarReasonerPost object and performs different
-	 * operations based on the command. If the command is "info," it delegates the request to the getInfo
-	 * method. If the command is "get_models" or "get_model," it processes the request using the DungTheory,
-	 * AbstractExtensionReasoner, and other components. The result includes information about the execution
-	 * time, answer, and status, which is encapsulated in a BipolarReasonerResponse object.</p>
-	 *
-	 * <p>In case of a timeout during execution, the method sets the response status to "TIMEOUT" and includes
-	 * the specified timeout duration. If any other exception occurs, the response status is set to "Error,"
-	 * and the method provides a generic response with a time of 0.0 and a null answer.</p>
-	 *
-	 * <p>If the command is not recognized or not applicable, the method returns a default BipolarReasonerResponse.</p>
-	 *
-	 * @param bipolarReasonerPost The BipolarReasonerPost object representing the request payload.
-	 * @return A Response object representing the response payload.
-	 */
 	@PostMapping(value = "/bipolar", produces = "application/json", consumes = "application/json")
 	@ResponseBody
-	public Response handleRequest(
-			@RequestBody BipolarReasonerPost bipolarReasonerPost) {
-
-		if (bipolarReasonerPost.getCmd().equals("info"))
-			return (Response) getBipolarInfo(bipolarReasonerPost.getEmail());
-
-		if (bipolarReasonerPost.getCmd().equals("get_models") || bipolarReasonerPost.getCmd().equals("get_model") || bipolarReasonerPost.getCmd().equals("get_credulous") || bipolarReasonerPost.getCmd().equals("get_skeptical")) {
-			BipolarArgumentationFramework bbase = AbstractBipolarFrameworkFactory.getArgumentationFramework(bipolarReasonerPost.getNr_of_arguments(),
-					bipolarReasonerPost.getAttacks(),
-					bipolarReasonerPost.getSupports());
-			BipolarSemantics semantics = BipolarSemantics.getSemantics(bipolarReasonerPost.getSemantics());
-			AbstractBipolarExtensionReasoner reasoner = AbstractBipolarExtensionReasonerFactory.getReasoner(semantics);
-			ExecutorService executor = Executors.newSingleThreadExecutor();
-			BipolarReasonerResponse reasonerResponse = new BipolarReasonerResponse(
-					bipolarReasonerPost.getCmd(),
-					bipolarReasonerPost.getEmail(),
-					bipolarReasonerPost.getNr_of_arguments(),
-					bipolarReasonerPost.getAttacks(),
-					bipolarReasonerPost.getSupports(),
-					bipolarReasonerPost.getSemantics(),
-					bipolarReasonerPost.getSolver(),
-					null,
-					0,
-					bipolarReasonerPost.getUnit_timeout(),
-					"ERRORs");
-			TimeUnit unit = Utils.getTimeoutUnit(bipolarReasonerPost.getUnit_timeout());
-			var command = BipolarReasonerCalleeFactory.Command.getCommand(bipolarReasonerPost.getCmd());
-			Callee callee = BipolarReasonerCalleeFactory.getCallee(command, reasoner, bbase);
-			int user_timeout = Utils.checkUserTimeout(bipolarReasonerPost.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
-			try {
-				// handle timeout
-				Future<Collection<Extension<DungTheory>>> future = executor.submit(callee);
-				Pair<Collection<Extension<DungTheory>>, Long> result = Utils.runServicesWithTimeout(future,
-						user_timeout, unit);
-				executor.shutdownNow();
-				reasonerResponse.setTime(result.getValue());
-				reasonerResponse.setAnswer(result.getKey().toString());
-				reasonerResponse.setStatus("SUCCESS");
-			} catch (TimeoutException e) {
-				reasonerResponse.setTime(bipolarReasonerPost.getTimeout());
-				reasonerResponse.setAnswer(null);
-				reasonerResponse.setStatus("TIMEOUT");
-				executor.shutdownNow();
-			} catch (Exception e) {
-				reasonerResponse.setTime(0.0);
-				reasonerResponse.setAnswer(null);
-				reasonerResponse.setStatus("Error");
+	public Response handleRequest(@RequestBody BipolarReasonerPost post) {
+		if (post.getCmd().equals("info"))
+			return getBipolarInfo(post.getEmail());
 
-				executor.shutdownNow();
-			}
-			return reasonerResponse;
-		} else {
+		BipolarReasonerCalleeFactory.Command cmd = BipolarReasonerCalleeFactory.Command.getCommand(post.getCmd());
+		if (cmd == null)
 			return new BipolarReasonerResponse();
-		}
+
+		BipolarArgumentationFramework bbase = AbstractBipolarFactory.getBAF(
+				post.getNr_of_arguments(), post.getAttacks(), post.getSupports());
+		Semantics semantics = Semantics.getSemantics(post.getSemantics());
+		AbstractBipolarExtensionReasoner reasoner = AbstractBipolarFactory.getReasoner(semantics, post.getSupport_type());
+		Callee callee = BipolarReasonerCalleeFactory.getCallee(cmd, reasoner, bbase);
+		TimeUnit unit = Utils.getTimeoutUnit(post.getUnit_timeout());
+		int userTimeout = Utils.checkUserTimeout(post.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
+
+		BipolarReasonerResponse response = new BipolarReasonerResponse(post.getCmd(), post.getEmail(),
+				post.getNr_of_arguments(), post.getAttacks(), post.getSupports(), post.getSupport_type(), post.getSemantics(),
+				post.getSolver(), null, 0, post.getUnit_timeout(), "ERROR");
+		ExecutionResult r = runCallee(callee, userTimeout, post.getTimeout(), unit);
+		response.setAnswer(r.answer);
+		response.setTime(r.time);
+		response.setStatus(r.status);
+		return response;
 	}
 
-	/**
-	 * Retrieves Bipolar services information
-	 * @param email the email address
-	 * @return BipolarServicesInfoResponse containing service information
-	 */
 	private BipolarServicesInfoResponse getBipolarInfo(String email) {
 		BipolarServicesInfoResponse response = new BipolarServicesInfoResponse();
 		response.setReply("info");
 		response.setEmail(email);
 		response.setBackend_timeout(SERVICES_TIMEOUT_DUNG);
-		var sem = AbstractBipolarExtensionReasonerFactory.getSemantics();
-		ArrayList<String> semantics_ids = new ArrayList<String>();
-		for (var s : sem) {
-			semantics_ids.add(s.id);
+		List<String> support_types = List.of("coalition", "ded", "nec");
+		response.setSupport_type(support_types);
+		ArrayList<String> semantics_ids = new ArrayList<>();
+		for (Semantics sem : AbstractExtensionReasonerFactory.getSemantics()) {
+			if (sem.equals(Semantics.diverse)) continue;
+			semantics_ids.add(sem.abbreviation());
 		}
 		response.setSemantics(semantics_ids);
-
-		BipolarReasonerCalleeFactory.Command[] com = BipolarReasonerCalleeFactory.getCommands();
-		ArrayList<String> command_ids = new ArrayList<String>();
-		for (var c : com) {
+		ArrayList<String> command_ids = new ArrayList<>();
+		for (var c : BipolarReasonerCalleeFactory.getCommands())
 			command_ids.add(c.id);
-		}
 		response.setCommands(command_ids);
-
 		return response;
 	}
 
+	// ── DeLP ─────────────────────────────────────────────────────────────────
 
-	/**
- * Handles HTTP POST requests for Defeasible logic programming DeLP Reasoner operations.
- *
- * This method processes requests with the endpoint "/delp" that have the specified content types
- * for both request and response. It takes a DeLPPost object as the request body and returns a
- * DelpResponse object as the response body.
- *
- * The method prints the received DelpPost object to the console for debugging purposes. It then
- * constructs a DeLPResponse object with default values, prepares the DelpReasoner, and executes it
- * asynchronously using a separate thread. The result includes information about the execution time,
- * answer, and status, encapsulated in a DelpResponse object.
- *
- * If the execution times out, the method sets the response status to "TIMEOUT" and includes the
- * specified timeout duration. If a parsing exception occurs during knowledge base or query parsing,
- * the method throws a JSONException with an appropriate error message. If any other unexpected exception
- * occurs, the method prints the stack trace and throws a JSONException with a generic error message.
- *
- * @param delpPost The DelpPost object representing the request payload.
- * @return A Response object representing the response payload.
- * @throws JSONException If there is a parsing error or an unexpected error occurs during processing.
- */
 	@PostMapping(value = "/delp", produces = "application/json", consumes = "application/json")
 	@ResponseBody
-	public Response handleRequest(
-			@RequestBody DeLPPost delpPost) {
-
-		System.out.println(delpPost.toString());
-
-		DeLPResponse delpResponse = new DeLPResponse("query", delpPost.getEmail(), delpPost.getCompcriterion(),
-				delpPost.getKb(), delpPost.getQuery(), delpPost.getTimeout(), null, 0.0, delpPost.getUnit_timeout(),
-				null);
-		TimeUnit unit = Utils.getTimeoutUnit(delpPost.getUnit_timeout());
-		int user_timeout = Utils.checkUserTimeout(delpPost.getTimeout(), SERVICES_TIMEOUT_DELP, unit);
+	public Response handleRequest(@RequestBody DeLPPost post) {
+		DeLPResponse response = new DeLPResponse("query", post.getEmail(), post.getCompcriterion(),
+				post.getKb(), post.getQuery(), post.getTimeout(), null, 0.0, post.getUnit_timeout(), null);
+		TimeUnit unit = Utils.getTimeoutUnit(post.getUnit_timeout());
+		int userTimeout = Utils.checkUserTimeout(post.getTimeout(), SERVICES_TIMEOUT_DELP, unit);
 		ExecutorService executor = Executors.newSingleThreadExecutor();
 		try {
-
 			DelpParser parser = new DelpParser();
-			DefeasibleLogicProgram delp = parser.parseBeliefBase(delpPost.getKb());
+			DefeasibleLogicProgram delp = parser.parseBeliefBase(post.getKb());
 			ComparisonCriterion comp = null;
-			if (delpPost.getCompcriterion().equals("compcriterion"))
+			if (post.getCompcriterion().equals("compcriterion"))
 				comp = new EmptyCriterion();
-			if (delpPost.getCompcriterion().equals("genspec"))
+			if (post.getCompcriterion().equals("genspec"))
 				comp = new GeneralizedSpecificity();
 			if (comp == null)
 				throw new JSONException("Malformed JSON: unknown value for attribute \"compcriterion\"");
 			DelpReasoner reasoner = new DelpReasoner(comp);
 			FolParser folParser = new FolParser();
 			folParser.setSignature(parser.getSignature());
-			String qString = delpPost.getQuery().trim();
-			Formula f = null;
-			if (qString.startsWith("~"))
-				f = new Negation((FolFormula) folParser.parseFormula(qString.substring(1)));
-			else
-				f = folParser.parseFormula(qString);
-			Callee delpCallee = new DeLPCallee(delp, reasoner, f);
-			Future<DelpAnswer.Type> future = executor.submit(delpCallee);
-			Pair<DelpAnswer.Type, Long> result = Utils.runServicesWithTimeout(future, user_timeout, unit);
-
-			System.out.println(result.toString());
-
-			delpResponse.setAnswer(result.getKey().toString());
-			delpResponse.setTime(result.getValue());
-			delpResponse.setStatus("SUCCESS");
-			System.out.println(delpResponse.toString());
-
+			String qString = post.getQuery().trim();
+			Formula f = qString.startsWith("~")
+					? new Negation((FolFormula) folParser.parseFormula(qString.substring(1)))
+					: folParser.parseFormula(qString);
+			Future<DelpAnswer.Type> future = executor.submit(new DeLPCallee(delp, reasoner, f));
+			Pair<DelpAnswer.Type, Long> result = Utils.runServicesWithTimeout(future, userTimeout, unit);
+			response.setAnswer(result.getKey().toString());
+			response.setTime(result.getValue());
+			response.setStatus("SUCCESS");
 		} catch (TimeoutException e) {
-			delpResponse.setTime(delpPost.getTimeout());
-			delpResponse.setAnswer(null);
-			delpResponse.setStatus("TIMEOUT");
-			executor.shutdownNow();
-		} catch (ParserException e) {
-			executor.shutdownNow();
-			throw new JSONException(
-					"Malformed JSON: syntax of knowledge base and/or query does not conform to the given format.");
-		} catch (IOException e) {
-			executor.shutdownNow();
-			throw new JSONException(
-					"Malformed JSON: syntax of knowledge base and/or query does not conform to the given format.");
+			response.setTime(post.getTimeout());
+			response.setAnswer(null);
+			response.setStatus("TIMEOUT");
+		} catch (ParserException | IOException e) {
+			throw new JSONException("Malformed JSON: syntax of knowledge base and/or query does not conform to the given format.");
 		} catch (Exception e) {
-			executor.shutdownNow();
-			e.printStackTrace();
 			throw new JSONException("An unexpected error occured. Please contact an administrator.");
+		} finally {
+			executor.shutdownNow();
 		}
-		return delpResponse;
+		return response;
 	}
 
-	/**
- 	* Handles HTTP POST requests for Inconsistency Measures operations.
- 	*
- 	* This method processes requests with the endpoint "/incmes" that have the specified content type
- 	* for the request and response. It takes an InconsistencyPost object as the request body and returns a
- 	* Response object as the response body.
- 	*
- 	* The method initializes an InconsistencyValueResponse object for the response. It then checks the
- 	* command (cmd) from the InconsistencyPost object and delegates the request to specific methods based on
- 	* the command. If the command is "value," it calls the handleGetICMESValue method. If the command is
- 	* "measures," it calls the handleGetMeasures method. Any exceptions that occur during the processing are
- 	* caught, and a generic error message is printed to the console.
- 	*
- 	* If the command is not recognized or not applicable, the method returns a default InconsistencyValueResponse.
- 	*
- 	* @param incmesPost The InconsistencyPost object representing the request payload.
- 	* @return A Response object representing the response payload.
- 	*/
+	// ── Inconsistency Measures ────────────────────────────────────────────────
 
 	@PostMapping(value = "/incmes", produces = "application/json")
 	@ResponseBody
-	public Response handleRequest(
-			@RequestBody InconsistencyPost incmesPost) {
-		InconsistencyValueResponse icmesResponse = new InconsistencyValueResponse();
-
+	public Response handleRequest(@RequestBody InconsistencyPost post) {
 		try {
-
-			if (incmesPost.getCmd().equals("value")) {
-				return handleGetICMESValue(incmesPost);
-			}
-
-			if (incmesPost.getCmd().equals("measures")) {
-
-				return handleGetMeasures(incmesPost);
-			}
+			if (post.getCmd().equals("value"))
+				return handleGetICMESValue(post);
+			if (post.getCmd().equals("measures"))
+				return handleGetMeasures(post);
 		} catch (Exception e) {
-			System.out.println(e.getMessage());
+			LoggerUtil.logger.log(Level.SEVERE, e.getMessage());
 		}
-
-		return icmesResponse;
+		return new InconsistencyValueResponse();
 	}
 
-	/**
- 	* Private inner class representing a Callable task for measuring inconsistency of a belief set.
- 	*
- 	* The MeasurementCallee class implements the Callable interface with a generic type of Double.
- 	* Instances of this class are used to perform asynchronous calculations of inconsistency measures
- 	* for a given BeliefSet using a specific InconsistencyMeasure.
- 	*
- 	* The class has two fields: "measure," representing the InconsistencyMeasure to be applied,
- 	* and "beliefSet," representing the BeliefSet for which the inconsistency measure is calculated.
- 	*
- 	* The constructor initializes the MeasurementCallee with a specific InconsistencyMeasure and
- 	* a BeliefSet.
- 	*
- 	* The call method, required by the Callable interface, invokes the inconsistencyMeasure method
- 	* of the provided InconsistencyMeasure on the given BeliefSet, returning the calculated inconsistency
- 	* measure value as a Double.
- 	*
- 	* @param <T> The type of formulas in the belief set, e.g., PlFormula.
- 	* @param <S> The type of signature associated with the belief set, e.g., PlSignature.
- 	*/
 	private class MeasurementCallee implements Callable<Double> {
 		/** The inconsistency measure used for the computation. */
 		InconsistencyMeasure<BeliefSet<PlFormula, ?>> measure;
@@ -1023,112 +555,64 @@ public Double call() throws Exception {
 		}
 	}
 
-	/**
-	 *
-	 * Handles the computation of the inconsistency value for a given belief set and inconsistency measure.
-	 * This method takes an InconsistencyPost object representing the request payload and calculates
-	 * the inconsistency value based on the specified belief set, inconsistency measure, and other parameters.
-	 *
-	 * The method initializes an InconsistencyValueResponse object for the response and sets up the necessary
-	 * sub-solvers for the computation. It then retrieves the inconsistency measure and parser based on the request's
-	 * attributes. The belief set is parsed from the knowledge base using the selected parser, and an asynchronous
-	 * calculation of the inconsistency measure is performed using a separate thread. The execution time and result
-	 * are then encapsulated in the InconsistencyValueResponse object.
-	 *
-	 * If the calculation times out, the method sets the response status to "TIMEOUT" and includes the specified
-	 * timeout duration. If a parsing exception occurs during knowledge base parsing, the method throws a JSONException
-	 * with an appropriate error message. If any other unexpected exception occurs, the method logs the error and
-	 * throws a JSONException with a generic error message.
-	 *
-	 * The inconsistency value is set to specific sentinel values (-1 for timeout, -2 for general error, -3 for infinity),
-	 * and the response object includes information about the request and the computed inconsistency value.
-	 *
-	 * @param query The InconsistencyPost object representing the request payload.
-	 * @return An InconsistencyValueResponse object representing the response payload.
-	 * @throws JSONException If there is a parsing error or an unexpected error occurs during processing.
-	 */
-
 	private InconsistencyValueResponse handleGetICMESValue(InconsistencyPost query) throws JSONException {
-		InconsistencyValueResponse icmesResponse = new InconsistencyValueResponse();
+		InconsistencyValueResponse response = new InconsistencyValueResponse();
 		TimeUnit unit = Utils.getTimeoutUnit(query.getUnit_timeout());
-		int user_timeout = Utils.checkUserTimeout(query.getTimeout(), SERVICES_TIMEOUT_INCMES, unit);
-		// set sub-solvers
+		int userTimeout = Utils.checkUserTimeout(query.getTimeout(), SERVICES_TIMEOUT_INCMES, unit);
 		SatSolver.setDefaultSolver(new Sat4jSolver());
 		PlMusEnumerator.setDefaultEnumerator(new NaiveMusEnumerator<PlFormula>(new Sat4jSolver()));
 		Solver.setDefaultLinearSolver(new ApacheCommonsSimplex());
 		Solver.setDefaultIntegerLinearSolver(new GlpkSolver());
-		// get measure
 		InconsistencyMeasure<BeliefSet<PlFormula, ?>> measure = InconsistencyMeasureFactory.getInconsistencyMeasure(
 				Measure.getMeasure(query.getMeasure()));
 		if (measure == null)
 			throw new JSONException("Malformed JSON: unknown value for attribute \"measure\"");
-		Parser<PlBeliefSet, PlFormula> parser = PlParserFactory.getParserForFormat(
-				Format.getFormat(query.getFormat()));
+		Parser<PlBeliefSet, PlFormula> parser = PlParserFactory.getParserForFormat(Format.getFormat(query.getFormat()));
 		if (parser == null)
 			throw new JSONException("Malformed JSON: unknown value for attribute \"format\"");
 		double val = -3;
 		try {
 			PlBeliefSet beliefSet = parser.parseBeliefBase(query.getKb());
 			ExecutorService executor = Executors.newSingleThreadExecutor();
-			long millis = System.currentTimeMillis();
 			try {
-				// handle timeout
 				Future<Double> future = executor.submit(new MeasurementCallee(measure, beliefSet));
-				Pair<Double, Long> result = Utils.runServicesWithTimeout(future, user_timeout, unit);
+				Pair<Double, Long> result = Utils.runServicesWithTimeout(future, userTimeout, unit);
 				val = result.getKey();
-				icmesResponse.setTime(result.getValue());
-				icmesResponse.setStatus("SUCCESS");
-				// val = future.get(InconsistencyMeasurementService.timeout, TimeUnit.SECONDS);
+				response.setTime(result.getValue());
+				response.setStatus("SUCCESS");
 				executor.shutdownNow();
 			} catch (TimeoutException e) {
-				// inconsistency value of -1 indicates that a timeout has occurred
-				icmesResponse.setTime(query.getTimeout());
-				icmesResponse.setStatus("TIMEOUT");
+				response.setTime(query.getTimeout());
+				response.setStatus("TIMEOUT");
 				executor.shutdownNow();
 				val = -1;
 			} catch (Exception e) {
-				// inconsistency value of -2 indicates some general error
-				icmesResponse.setStatus("ERROR");
+				response.setStatus("ERROR");
 				executor.shutdownNow();
 				val = -2;
 			}
-			// inconsistency value of -3 indicates infinity
 			if (val == Double.POSITIVE_INFINITY)
 				val = -3;
-			millis = System.currentTimeMillis() - millis;
-
-			icmesResponse.setEmail(query.getEmail());
-			icmesResponse.setFormat(query.getFormat());
-			icmesResponse.setKb(query.getKb());
-			icmesResponse.setMeasure(query.getMeasure());
-			icmesResponse.setReply("value");
-			icmesResponse.setValue(val);
-
-			return icmesResponse;
-		} catch (ParserException e) {
-			throw new JSONException("Malformed JSON: syntax of knowledge base does not conform to the given format.");
-		} catch (IOException e) {
+			response.setEmail(query.getEmail());
+			response.setFormat(query.getFormat());
+			response.setKb(query.getKb());
+			response.setMeasure(query.getMeasure());
+			response.setReply("value");
+			response.setValue(val);
+			return response;
+		} catch (ParserException | IOException e) {
 			throw new JSONException("Malformed JSON: syntax of knowledge base does not conform to the given format.");
 		} catch (Exception e) {
 			throw new JSONException("An unexpected error occured. Please contact an administrator.");
 		}
 	}
 
-	/**
-	 * Handles the "List inconsistency measures" command
-	 *
-	 * @param query some query
-	 * @return the reply
-	 * @throws JSONException                            if some JSON issue occurs.
-	 * @throws org.codehaus.jettison.json.JSONException  if some JSON issue occurs.
-	 */
 	private InconsistencyGetMeasuresResponse handleGetMeasures(InconsistencyPost query)
 			throws JSONException, org.codehaus.jettison.json.JSONException {
 		InconsistencyGetMeasuresResponse response = new InconsistencyGetMeasuresResponse();
-		List<HashMap<String, String>> value = new LinkedList<HashMap<String, String>>();
-		HashMap<String, String> jsonMes;
+		List<HashMap<String, String>> value = new LinkedList<>();
 		for (Measure m : InconsistencyMeasureFactory.Measure.values()) {
-			jsonMes = new HashMap<String, String>();
+			HashMap<String, String> jsonMes = new HashMap<>();
 			jsonMes.put("id", m.id);
 			jsonMes.put("label", m.label);
 			value.add(jsonMes);
@@ -1139,24 +623,13 @@ private InconsistencyGetMeasuresResponse handleGetMeasures(InconsistencyPost que
 		return response;
 	}
 
-
-	/**
-	 * Handles the "List semanctics" command for aba
-	 *
-	 * @param query some query
-	 * @return the reply
-	 * @throws JSONException                            if some JSON issue occurs.
-	 * @throws org.codehaus.jettison.json.JSONException  if some JSON issue occurs.
-	 */
 	private AbaGetSemanticsResponse handleGetSemantics(AbaReasonerPost query)
 			throws JSONException, org.codehaus.jettison.json.JSONException {
-
 		LoggerUtil.logger.info(String.format("User: %s  Command: %s", query.getEmail(), query.getCmd()));
 		AbaGetSemanticsResponse response = new AbaGetSemanticsResponse();
-		List<HashMap<String, String>> value = new LinkedList<HashMap<String, String>>();
-		HashMap<String, String> jsonMes;
-		for (org.tweetyproject.web.services.aba.GeneralAbaReasonerFactory.Semantics m : GeneralAbaReasonerFactory.Semantics.values()) {
-			jsonMes = new HashMap<String, String>();
+		List<HashMap<String, String>> value = new LinkedList<>();
+		for (GeneralAbaReasonerFactory.Semantics m : GeneralAbaReasonerFactory.Semantics.values()) {
+			HashMap<String, String> jsonMes = new HashMap<>();
 			jsonMes.put("id", m.id);
 			jsonMes.put("label", m.label);
 			value.add(jsonMes);
@@ -1167,59 +640,40 @@ private AbaGetSemanticsResponse handleGetSemantics(AbaReasonerPost query)
 		return response;
 	}
 
-	/**
-	 * handler for the /sequence-explanation endpoint
-	 * @param request the sequence explanation request
-	 * @return the server response
-	 */
+	// ── Sequence Explanation ──────────────────────────────────────────────────
+
 	@PostMapping(value = "/sequence-explanation", produces = "application/json")
 	@ResponseBody
 	public SequenceExplanationResponse handleRequest(@Valid @RequestBody SequenceExplanationPost request) {
 		LoggerUtil.logger.info(String.format("Run sequence explanation command \"%s\" for user \"%s\" with timeout: %s %s",
-				request.getCmd().getClass().getSimpleName(),
-				request.getEmail(),
-				request.getTimeout(),
-				request.getUnit_timeout()));
+				request.getCmd().getClass().getSimpleName(), request.getEmail(),
+				request.getTimeout(), request.getUnit_timeout()));
 
 		TimeUnit timeoutUnit = Utils.getTimeoutUnit(request.getUnit_timeout());
 		int timeout = Utils.checkUserTimeout(request.getTimeout(), SERVICES_TIMEOUT_SEQUENCE_EXPLANATION, timeoutUnit);
-
 		ExecutorService executor = Executors.newSingleThreadExecutor();
-		Pair<SequenceExplanationResult, Long> resultAndExecutionTime;
+		Pair<SequenceExplanationResult, Long> resultAndTime;
 		try {
 			var future = executor.submit(() -> processCommand(request.getCmd()));
-			resultAndExecutionTime = Utils.runServicesWithTimeout(future, timeout, timeoutUnit);
+			resultAndTime = Utils.runServicesWithTimeout(future, timeout, timeoutUnit);
 		} catch (TimeoutException e) {
 			LoggerUtil.logger.info("Timeout while running sequence explanation.");
-			return new SequenceExplanationResponse(
-					null,
-					request.getEmail(),
-					timeout,
-					request.getUnit_timeout(),
-					SequenceExplanationResponse.Status.TIMEOUT
-			);
+			return new SequenceExplanationResponse(null, request.getEmail(), timeout,
+					request.getUnit_timeout(), SequenceExplanationResponse.Status.TIMEOUT);
 		} catch (ExecutionException e) {
 			LoggerUtil.logger.warning(() -> "Error while running sequence explanation reasoner: " + e.getMessage());
 			e.printStackTrace();
 			throw new RuntimeException(e);
 		} catch (InterruptedException e) {
-			LoggerUtil.logger.warning(() -> "Interrupt while running  sequence explanation: " + e.getMessage());
+			LoggerUtil.logger.warning(() -> "Interrupt while running sequence explanation: " + e.getMessage());
 			e.printStackTrace();
 			Thread.currentThread().interrupt();
 			throw new RuntimeException("Thread was interrupted.");
 		} finally {
 			executor.shutdownNow();
 		}
-
-		double executionTime = resultAndExecutionTime.getValue();
-		var result = resultAndExecutionTime.getKey();
-		return new SequenceExplanationResponse(
-				result,
-				request.getEmail(),
-				executionTime,
-				request.getUnit_timeout(),
-				SequenceExplanationResponse.Status.SUCCESS
-		);
+		return new SequenceExplanationResponse(resultAndTime.getKey(), request.getEmail(),
+				resultAndTime.getValue(), request.getUnit_timeout(), SequenceExplanationResponse.Status.SUCCESS);
 	}
 
 	/**
@@ -1229,11 +683,9 @@ public SequenceExplanationResponse handleRequest(@Valid @RequestBody SequenceExp
 	 * @return the computed sequence explanation result
 	 */
 	private SequenceExplanationResult processCommand(SequenceExplanationCmd cmd) {
-		if (cmd instanceof GetSequenceExplanationsCmd) {
+		if (cmd instanceof GetSequenceExplanationsCmd)
 			return processSequenceExplanationCmd((GetSequenceExplanationsCmd) cmd);
-		} else {
-			throw new IllegalStateException("Encountered invalid command:" + cmd.getClass().getSimpleName());
-		}
+		throw new IllegalStateException("Encountered invalid command:" + cmd.getClass().getSimpleName());
 	}
 
 	/**
@@ -1244,309 +696,162 @@ private SequenceExplanationResult processCommand(SequenceExplanationCmd cmd) {
 	 */
 	private GetSequenceExplanationsResult processSequenceExplanationCmd(GetSequenceExplanationsCmd cmd) {
 		var theory = new DungTheory();
-		for (AttackDTO attackDTO: cmd.getAttacks()) {
+		for (AttackDTO attackDTO : cmd.getAttacks()) {
 			var attacker = new Argument(attackDTO.getAttacker());
 			var attacked = new Argument(attackDTO.getAttacked());
 			theory.add(attacker);
 			theory.add(attacked);
-			var attack = new Attack(attacker, attacked);
-			theory.add(attack);
+			theory.add(new Attack(attacker, attacked));
 		}
 		Set<Argument> argumentFilter = ArgumentFilterSerialization.deserialize(cmd.getArgumentFilter());
-		if (argumentFilter != null) {
+		if (argumentFilter != null)
 			theory.addAll(argumentFilter);
-		}
-		var sequenceExplanation = sequenceExplanationService.querySequenceExplanations(theory, argumentFilter);
-		return GetSequenceExplanationsResult.from(sequenceExplanation);
-	}
-
-	/**
-	 * Executes the causal reasoner as specified by the provided {@link CausalReasonerPost}
-	 *
-	 * @param request The request payload containing information for causal reasoning
-	 * @return A Response object containing the result of the ABA reasoning operation.
-	 */
-	@PostMapping(value = "/causal", produces = "application/json")
-	@ResponseBody
-	public CausalReasonerResponse handleRequest(@Valid @RequestBody CausalReasonerPost request) {
-		LoggerUtil.logger.info(String.format("Run causal reasoner command \"%s\" for user \"%s\" with timeout: %s %s",
-				request.getCmd(),
-				request.getEmail(),
-				request.getTimeout(),
-				request.getUnit_timeout()));
-
-		TimeUnit timoutUnit = Utils.getTimeoutUnit(request.getUnit_timeout());
-		int timout = Utils.checkUserTimeout(request.getTimeout(), SERVICES_TIMEOUT_CAUSAL, timoutUnit);
-
-		ExecutorService executor = Executors.newSingleThreadExecutor();
-		Pair<String, Long> resultAndExecutionTime;
-		try {
-			var future = executor.submit(() -> processCommand(request));
-			resultAndExecutionTime = Utils.runServicesWithTimeout(future, timout, timoutUnit);
-		} catch (TimeoutException e) {
-			LoggerUtil.logger.info("Timeout while running causal reasoner.");
-			return new CausalReasonerResponse(
-					null,
-					request.getEmail(),
-					timout,
-					request.getUnit_timeout(),
-					TIMEOUT
-			);
-		} catch (ExecutionException e) {
-			LoggerUtil.logger.warning(() -> "Error while running causal reasoner: " + e.getMessage());
-			e.printStackTrace();
-			throw new RuntimeException(e);
-		} catch (InterruptedException e) {
-			LoggerUtil.logger.warning(() -> "Interrupt while running causal reasoner: " + e.getMessage());
-			e.printStackTrace();
-			Thread.currentThread().interrupt();
-			throw new RuntimeException("Thread was interrupted.");
-		} finally {
-			executor.shutdownNow();
-		}
-
-		double executionTime = resultAndExecutionTime.getValue();
-		String result = resultAndExecutionTime.getKey();
-		return new CausalReasonerResponse(
-				result,
-				request.getEmail(),
-				executionTime,
-				request.getUnit_timeout(),
-				SUCCESS
-		);
-	}
-
-	/**
-	 * Dispatches a causal request to the concrete command handler.
-	 *
-	 * @param causalReasonerPost the incoming causal request
-	 * @return the serialized command result
-	 */
-	private String processCommand(CausalReasonerPost causalReasonerPost) {
-		return switch (causalReasonerPost.getCmd()) {
-			case GET_CONCLUSIONS -> processConclusionsCommand(causalReasonerPost);
-			case GET_SIGNIFICANT_ATOMS -> processSignificantAtomsCommand(causalReasonerPost);
-			case GET_ARGUMENTATION_FRAMEWORK -> processArgumentationFramework(causalReasonerPost);
-			case GET_SEQUENCE_EXPLANATIONS -> processSequenceExplanations(causalReasonerPost);
-		};
+		return GetSequenceExplanationsResult.from(sequenceExplanationService.querySequenceExplanations(theory, argumentFilter));
 	}
 
-	/**
-	 * Computes the conclusions for the given causal request.
-	 *
-	 * @param causalReasonerPost the incoming causal request
-	 * @return the conclusions as a string representation
-	 */
-	private String processConclusionsCommand(CausalReasonerPost causalReasonerPost) {
-		CausalKnowledgeBase causalKnowledgeBase = parseCausalKnowledgeBase(causalReasonerPost);
-		Collection<PlFormula> observations = parseObservations(causalReasonerPost);
-		var conclusionFilter = parseConclusionFilter(causalReasonerPost);
+	// ── PAF ──────────────────────────────────────────────────────────────────
 
-		Collection<PlFormula> conclusions = causalReasonerService.queryConclusions(causalKnowledgeBase, observations, conclusionFilter);
-		return conclusions.toString();
-	}
+	@PostMapping(value = "/paf", produces = "application/json", consumes = "application/json")
+	@ResponseBody
+	public Response handleRequest(@RequestBody PafReasonerPost post) {
+		if (post.getCmd().equals("info"))
+			return getPafInfo(post.getEmail());
 
-	/**
-	 * Computes the significant atoms for the given causal request.
-	 *
-	 * @param causalReasonerPost the incoming causal request
-	 * @return the significant atoms serialized as JSON
-	 */
-	private String processSignificantAtomsCommand(CausalReasonerPost causalReasonerPost) {
-		CausalKnowledgeBase causalKnowledgeBase = parseCausalKnowledgeBase(causalReasonerPost);
-		Collection<PlFormula> observations = parseObservations(causalReasonerPost);
-		var conclusionFilter = parseConclusionFilter(causalReasonerPost);
-
-		var perAtomSignificantAtoms = causalReasonerService.queryPerAtomSignificantAtoms(causalKnowledgeBase, observations, conclusionFilter);
-
-		Map<String, Collection<String>> jsonData = new HashMap<>();
-		for (Map.Entry<Proposition, Collection<Proposition>> entry : perAtomSignificantAtoms.entrySet()) {
-			List<String> list = new ArrayList<>();
-			for (Proposition proposition : entry.getValue()) {
-				String string = proposition.toString();
-				list.add(string);
-			}
-			jsonData.put(entry.getKey().toString(), list);
-		}
+		PafReasonerCalleeFactory.Command cmd = PafReasonerCalleeFactory.Command.getCommand(post.getCmd());
+		if (cmd == null)
+			return new PafReasonerResponse();
 
-		try {
-			return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(jsonData);
-		} catch (JsonProcessingException e) {
-			throw new RuntimeException(e);
-		}
+		ProbabilisticArgumentationFramework paf = AbstractPafReasonerFactory.getPaf(
+				post.getNr_of_arguments(), post.getArgument_probabilities(),
+				post.getAttacks(), post.getAttack_probabilities());
+		AbstractPafReasoner reasoner = AbstractPafReasonerFactory.getReasoner(
+				Semantics.getSemantics(post.getSemantics()), post.getSolver(), post.getNr_of_trials());
+		Callee callee = PafReasonerCalleeFactory.getCallee(cmd, reasoner, paf);
+		TimeUnit unit = Utils.getTimeoutUnit(post.getUnit_timeout());
+		int userTimeout = Utils.checkUserTimeout(post.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
+
+		PafReasonerResponse response = new PafReasonerResponse(post.getCmd(), post.getEmail(),
+				post.getNr_of_arguments(), post.getArgument_probabilities(), post.getAttacks(),
+				post.getAttack_probabilities(), post.getSemantics(), post.getSolver(),
+				post.getArgument(), null, 0, post.getUnit_timeout(), "ERROR");
+		ExecutionResult r = runCallee(callee, userTimeout, post.getTimeout(), unit);
+		response.setAnswer(r.answer);
+		response.setTime(r.time);
+		response.setStatus(r.status);
+		return response;
 	}
 
-	/**
-	 * Computes sequence explanations for the given causal request.
-	 *
-	 * @param causalReasonerPost the incoming causal request
-	 * @return the sequence explanations serialized as JSON
-	 */
-	private String processSequenceExplanations(CausalReasonerPost causalReasonerPost) {
-		CausalKnowledgeBase causalKnowledgeBase = parseCausalKnowledgeBase(causalReasonerPost);
-		Collection<PlFormula> observations = parseObservations(causalReasonerPost);
-		var conclusionFilter = parseConclusionFilter(causalReasonerPost);
-
-		var result = causalReasonerService.querySequenceExplanations(causalKnowledgeBase, observations, conclusionFilter);
-		var reply = SequenceExplanationReply.from(result);
-		try {
-			return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(reply);
-		} catch (JsonProcessingException e) {
-			throw new RuntimeException(e);
-		}
+	private PafServicesInfoResponse getPafInfo(String email) {
+		PafServicesInfoResponse response = new PafServicesInfoResponse();
+		response.setReply("info");
+		response.setEmail(email);
+		response.setBackend_timeout(SERVICES_TIMEOUT_DUNG);
+		ArrayList<String> semantics_ids = new ArrayList<>();
+		for (Semantics s : AbstractPafReasonerFactory.getSemantics())
+			semantics_ids.add(s.abbreviation());
+		response.setSemantics(semantics_ids);
+		ArrayList<String> command_ids = new ArrayList<>();
+		for (PafReasonerCalleeFactory.Command c : PafReasonerCalleeFactory.getCommands())
+			command_ids.add(c.id);
+		response.setCommands(command_ids);
+		response.setSolvers(AbstractPafReasonerFactory.getSolvers());
+		return response;
 	}
 
-	/**
-	 * Processes argumentation framework queries from causal reasoner posts
-	 * @param causalReasonerPost the causal reasoner request
-	 * @return JSON string containing the argumentation framework result
-	 */
-	private String processArgumentationFramework(CausalReasonerPost causalReasonerPost) {
-		CausalKnowledgeBase causalKnowledgeBase = parseCausalKnowledgeBase(causalReasonerPost);
-		Collection<PlFormula> observations = parseObservations(causalReasonerPost);
+	// ── Serialisation ─────────────────────────────────────────────────────────
 
-		var result = causalReasonerService.queryArgumentationFramework(causalKnowledgeBase, observations);
-		var reply = ArgumentationFrameworkReply.from(result);
-		try {
-			return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(reply);
-		} catch (JsonProcessingException e) {
-			throw new RuntimeException(e);
-		}
-	}
+	@PostMapping(value = "/serialisation", produces = "application/json", consumes = "application/json")
+	@ResponseBody
+	public Response handleRequest(@RequestBody SerialisationPost post) {
+		if (post.getCmd().equals("info"))
+			return getSerInfo(post.getEmail());
 
-	/**
-	 * Parses observations from a causal reasoner post
-	 * @param causalReasonerPost the causal reasoner request
-	 * @return Collection of propositional logic formulas
-	 */
-	private static Collection<PlFormula> parseObservations(CausalReasonerPost causalReasonerPost) {
-		CausalParser causalParser = new CausalParser();
-		Collection<PlFormula> observations;
-		try {
-			observations = causalParser.parseListOfFormulae(causalReasonerPost.getObservations(), ",");
-		} catch (ParserException e) {
-			throw new ResponseStatusException(HttpStatus.BAD_REQUEST, null, e);
-		} catch (IOException e) {
-			throw new RuntimeException(e);
-		}
-		return observations;
+		SerialisationCalleeFactory.Command cmd = SerialisationCalleeFactory.Command.getCommand(post.getCmd());
+		if (cmd == null)
+			return new SerialisationResponse();
+
+		DungTheory theory = AbstractExtensionReasonerFactory.getDungTheory(post.getNr_of_arguments(), post.getAttacks());
+		Extension<DungTheory> extension = SerialisationFactory.getExtension(post.getExtension());
+		SelectionFunction alpha = SerialisationFactory.getSelectionFunction(post.getSelectionFunction());
+		TerminationFunction beta = SerialisationFactory.getTerminationFunction(post.getTerminationFunction());
+		Callee callee = SerialisationCalleeFactory.getCallee(cmd, alpha, beta, theory, extension);
+		TimeUnit unit = Utils.getTimeoutUnit(post.getUnit_timeout());
+		int userTimeout = Utils.checkUserTimeout(post.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
+
+		SerialisationResponse response = new SerialisationResponse(post.getCmd(), post.getEmail(),
+				post.getNr_of_arguments(), post.getAttacks(), post.getExtension(),
+				post.getSelectionFunction(), post.getTerminationFunction(), null, 0,
+				post.getUnit_timeout(), "ERROR");
+		ExecutionResult r = runCallee(callee, userTimeout, post.getTimeout(), unit);
+		response.setAnswer(r.answer);
+		response.setTime(r.time);
+		response.setStatus(r.status);
+		return response;
 	}
 
-	/**
-	 * Parses the conclusion filter from a causal reasoner post
-	 * @param causalReasonerPost the causal reasoner request
-	 * @return Set of propositions or null if not specified
-	 */
-	private static @Nullable Set<Proposition> parseConclusionFilter(CausalReasonerPost causalReasonerPost) {
-		return ConclusionsFilterSerialization.parse(causalReasonerPost.getConclusionsFilter());
+	private SerialisationInfoResponse getSerInfo(String email) {
+		SerialisationInfoResponse response = new SerialisationInfoResponse();
+		response.setReply("info");
+		response.setEmail(email);
+		response.setBackend_timeout(SERVICES_TIMEOUT_DUNG);
+		response.setSelectionFunctions(SerialisationFactory.getSelectionFunctions());
+		response.setTerminationFunctions(SerialisationFactory.getTerminationFunction());
+		ArrayList<String> command_ids = new ArrayList<>();
+		for (SerialisationCalleeFactory.Command c : SerialisationCalleeFactory.getCommands())
+			command_ids.add(c.id);
+		response.setCommands(command_ids);
+		return response;
 	}
 
-	/**
-	 * Parses a causal knowledge base from a causal reasoner post
-	 * @param causalReasonerPost the causal reasoner request
-	 * @return CausalKnowledgeBase parsed from the request
-	 */
-	private static CausalKnowledgeBase parseCausalKnowledgeBase(CausalReasonerPost causalReasonerPost) {
-		CausalParser causalParser = new CausalParser();
-		CausalKnowledgeBase causalKnowledgeBase;
-		try {
-			causalKnowledgeBase = causalParser.parseBeliefBase(causalReasonerPost.getKb());
-		} catch (ParserException e) {
-			throw new ResponseStatusException(HttpStatus.BAD_REQUEST, null, e);
-		} catch (IOException e) {
-			throw new RuntimeException(e);
-		}
-		return causalKnowledgeBase;
-	}
+	// ── Serialisation ─────────────────────────────────────────────────────────
 
-	/**
-	 * Handles HTTP POST requests for Probabilistic Argumentation Framework (PAF) operations.
-	 *
-	 * <p>Supported commands:
-	 * <ul>
-	 *   <li>{@code info} – return supported semantics, commands, and solvers</li>
-	 *   <li>{@code get_credulous} – probability that the queried argument is credulously accepted</li>
-	 *   <li>{@code get_skeptical} – probability that the queried argument is skeptically accepted</li>
-	 * </ul>
-	 *
-	 * <p>Two solvers are available: {@code simple} (exact, enumerates all subgraphs) and
-	 * {@code montecarlo} (approximate sampling, configurable via {@code nr_of_trials}).</p>
-	 *
-	 * @param pafPost the request payload
-	 * @return a {@link Response} containing the computed probability or service info
-	 */
-	@PostMapping(value = "/paf", produces = "application/json", consumes = "application/json")
+	@PostMapping(value = "/setaf", produces = "application/json", consumes = "application/json")
 	@ResponseBody
-	public Response handleRequest(@RequestBody PafReasonerPost pafPost) {
-		if (pafPost.getCmd().equals("info"))
-			return getPafInfo(pafPost.getEmail());
+	public Response handleRequest(@RequestBody SetAfReasonerPost post) {
+		if (post.getCmd().equals("info"))
+			return getSetAfInfo(post.getEmail());
 
-		PafReasonerCalleeFactory.Command cmd = PafReasonerCalleeFactory.Command.getCommand(pafPost.getCmd());
+		SetAfReasonerCalleeFactory.Command cmd = SetAfReasonerCalleeFactory.Command.getCommand(post.getCmd());
 		if (cmd == null)
-			return new PafReasonerResponse();
-
-		ProbabilisticArgumentationFramework paf = AbstractPafReasonerFactory.getPaf(
-				pafPost.getNr_of_arguments(),
-				pafPost.getArgument_probabilities(),
-				pafPost.getAttacks(),
-				pafPost.getAttack_probabilities());
-		AbstractPafReasoner reasoner = AbstractPafReasonerFactory.getReasoner(
-				Semantics.getSemantics(pafPost.getSemantics()),
-				pafPost.getSolver(),
-				pafPost.getNr_of_trials());
-		Callee callee = PafReasonerCalleeFactory.getCallee(cmd, reasoner, paf);
-
-		ExecutorService executor = Executors.newSingleThreadExecutor();
-		PafReasonerResponse reasonerResponse = new PafReasonerResponse(
-				pafPost.getCmd(), pafPost.getEmail(), pafPost.getNr_of_arguments(),
-				pafPost.getArgument_probabilities(), pafPost.getAttacks(),
-				pafPost.getAttack_probabilities(), pafPost.getSemantics(),
-				pafPost.getSolver(), pafPost.getArgument(), null, 0,
-				pafPost.getUnit_timeout(), "ERROR");
-		TimeUnit unit = Utils.getTimeoutUnit(pafPost.getUnit_timeout());
-		int user_timeout = Utils.checkUserTimeout(pafPost.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
-		try {
-			Future<Map<Argument,Double>> future = executor.submit(callee);
-			Pair<Map<Argument,Double>, Long> result = Utils.runServicesWithTimeout(future, user_timeout, unit);
-			executor.shutdownNow();
-			reasonerResponse.setAnswer(result.getKey().toString());
-			reasonerResponse.setTime(result.getValue());
-			reasonerResponse.setStatus("SUCCESS");
-		} catch (TimeoutException e) {
-			reasonerResponse.setTime(pafPost.getTimeout());
-			reasonerResponse.setAnswer(null);
-			reasonerResponse.setStatus("TIMEOUT");
-			executor.shutdownNow();
-		} catch (Exception e) {
-			reasonerResponse.setTime(0.0);
-			reasonerResponse.setAnswer(null);
-			reasonerResponse.setStatus("Error");
-			executor.shutdownNow();
-		}
-		return reasonerResponse;
+			return new SetAfReasonerResponse();
+
+		SetAf theory = AbstractSetAfFactory.getSetAf(post.getNr_of_arguments(), post.getAttacks());
+		AbstractSetAfExtensionReasoner reasoner = AbstractSetAfFactory.getReasoner(Semantics.getSemantics(post.getSemantics()));
+		Callee callee = SetAfReasonerCalleeFactory.getCallee(cmd, reasoner, theory);
+		TimeUnit unit = Utils.getTimeoutUnit(post.getUnit_timeout());
+		int userTimeout = Utils.checkUserTimeout(post.getTimeout(), SERVICES_TIMEOUT_DUNG, unit);
+
+		SetAfReasonerResponse response = new SetAfReasonerResponse(post.getCmd(), post.getEmail(),
+				post.getNr_of_arguments(), post.getAttacks(), post.getSemantics(), post.getSolver(),
+				null, 0, post.getUnit_timeout(), "ERROR");
+		ExecutionResult r = runCallee(callee, userTimeout, post.getTimeout(), unit);
+		response.setAnswer(r.answer);
+		response.setTime(r.time);
+		response.setStatus(r.status);
+		return response;
 	}
 
-	/**
-	 * Retrieves PAF services information
-	 * @param email the email address
-	 * @return PafServicesInfoResponse containing service information
-	 */
-	private PafServicesInfoResponse getPafInfo(String email) {
-		PafServicesInfoResponse response = new PafServicesInfoResponse();
+	private SetAfServicesInfoResponse getSetAfInfo(String email) {
+		SetAfServicesInfoResponse response = new SetAfServicesInfoResponse();
 		response.setReply("info");
 		response.setEmail(email);
 		response.setBackend_timeout(SERVICES_TIMEOUT_DUNG);
-		Semantics[] sem = AbstractPafReasonerFactory.getSemantics();
-		ArrayList<String> semantics_ids = new ArrayList<>();
-		for (Semantics s : sem)
-			semantics_ids.add(s.abbreviation());
-		response.setSemantics(semantics_ids);
-		PafReasonerCalleeFactory.Command[] com = PafReasonerCalleeFactory.getCommands();
 		ArrayList<String> command_ids = new ArrayList<>();
-		for (PafReasonerCalleeFactory.Command c : com)
+		for (SetAfReasonerCalleeFactory.Command c : SetAfReasonerCalleeFactory.getCommands())
 			command_ids.add(c.id);
 		response.setCommands(command_ids);
-		response.setSolvers(AbstractPafReasonerFactory.getSolvers());
+		ArrayList<String> semantics_ids = new ArrayList<>();
+		for (Semantics s : AbstractSetAfFactory.getSemantics())
+			semantics_ids.add(s.abbreviation());
+		response.setSemantics(semantics_ids);
 		return response;
 	}
+
+	// ── Ping ─────────────────────────────────────────────────────────────────
+
+	@PostMapping(value = "/ping", produces = "application/json")
+	@ResponseBody
+	public Ping ping(@RequestBody Ping ping_Greeting) {
+		return ping_Greeting;
+	}
 }
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/AbstractBipolarExtensionReasonerFactory.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/AbstractBipolarExtensionReasonerFactory.java
deleted file mode 100644
index 05c94bd54..000000000
--- a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/AbstractBipolarExtensionReasonerFactory.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- *  This file is part of "TweetyProject", a collection of Java libraries for
- *  logical aspects of artificial intelligence and knowledge representation.
- *
- *  TweetyProject is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License version 3 as
- *  published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- *  Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
- */
-package org.tweetyproject.web.services.bipolar;
-
-import org.tweetyproject.arg.bipolar.reasoner.*;
-import org.tweetyproject.arg.dung.semantics.Semantics;
-
-/**
- * Abstract factory for retrieving bipolar extension reasoners.
- *
- * @author Lars Bengel
- */
-public abstract class AbstractBipolarExtensionReasonerFactory {
-
-	/**
-	 * Prevents instantiation.
-	 */
-	protected AbstractBipolarExtensionReasonerFactory() {
-	}
-
-	/**
-	 * Returns an array of all available semantics.
-	 *
-	 * @return An array of all available semantics.
-	 */
-	public static BipolarSemantics[] getSemantics() {
-		return BipolarSemantics.values();
-	}
-
-	/**
-	 * Creates a new reasoner measure of the given semantics with default
-	 * settings.
-	 * 
-	 * @param sem some identifier of a semantics.
-	 * @return the requested reasoner.
-	 */
-	public static AbstractBipolarExtensionReasoner getReasoner(BipolarSemantics sem) {
-        return switch (sem) {
-			case BCF -> new SimpleStronglyConflictFreeReasoner();
-			case BCOH -> new SimpleCoherentReasoner();
-			case BAD -> new SimpleCoherentAdmissibleReasoner();
-			case CAD -> new SimpleCoalitionReasoner(Semantics.ADM);
-			case CCO -> new SimpleCoalitionReasoner(Semantics.CO);
-			case CGR -> new SimpleCoalitionReasoner(Semantics.GR);
-			case CPR -> new SimpleCoalitionReasoner(Semantics.PR);
-			case CST -> new SimpleCoalitionReasoner(Semantics.ST);
-			case DAD -> new SimpleDeductiveReasoner(Semantics.ADM);
-			case DCO -> new SimpleDeductiveReasoner(Semantics.CO);
-			case DGR -> new SimpleDeductiveReasoner(Semantics.GR);
-			case DPR -> new SimpleDeductiveReasoner(Semantics.PR);
-			case DST -> new SimpleDeductiveReasoner(Semantics.ST);
-			case NAD -> new SimpleNecessityReasoner(Semantics.ADM);
-			case NCO -> new SimpleNecessityReasoner(Semantics.CO);
-			case NGR -> new SimpleNecessityReasoner(Semantics.GR);
-			case NPR -> new SimpleNecessityReasoner(Semantics.PR);
-			case NST -> new SimpleNecessityReasoner(Semantics.ST);
-
-            default -> throw new RuntimeException("No reasoner found for semantics " + sem.toString());
-        };
-	}
-}
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/AbstractBipolarFrameworkFactory.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/AbstractBipolarFactory.java
similarity index 56%
rename from org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/AbstractBipolarFrameworkFactory.java
rename to org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/AbstractBipolarFactory.java
index 3f43c365b..2cd795edd 100644
--- a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/AbstractBipolarFrameworkFactory.java
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/AbstractBipolarFactory.java
@@ -18,7 +18,10 @@
  */
 package org.tweetyproject.web.services.bipolar;
 
-import org.tweetyproject.arg.bipolar.syntax.*;
+import org.tweetyproject.arg.bipolar.reasoner.*;
+import org.tweetyproject.arg.bipolar.syntax.BipolarArgumentationFramework;
+import org.tweetyproject.arg.bipolar.syntax.Support;
+import org.tweetyproject.arg.dung.semantics.Semantics;
 import org.tweetyproject.arg.dung.syntax.Argument;
 import org.tweetyproject.arg.dung.syntax.Attack;
 
@@ -26,18 +29,43 @@
 import java.util.List;
 
 /**
- * Abstract factory for building bipolar argumentation frameworks from web requests.
- *
- * @author Oleksandr Dzhychko
+ * Main factory for retrieving bipolar extension reasoners as supported by the web service
+ * 
+ * @author Lars Bengel
  */
-public abstract class AbstractBipolarFrameworkFactory {
-
+public abstract class AbstractBipolarFactory {
 	/**
-	 * Prevents instantiation.
+	 * Returns an array of all available bipolar semantics.
+	 *
+	 * @return An array of all available bipolar semantics.
 	 */
-	protected AbstractBipolarFrameworkFactory() {
+	public static Semantics[] getSemantics() {
+		return Semantics.values();
+	}
+
+	public static Support.Type[] getSupportTypes() {
+		return new Support.Type[] {Support.Type.DEFAULT, Support.Type.DEDUCTIVE, Support.Type.NECESSITY};
 	}
 
+	/**
+	 * Creates a new reasoner measure of the given semantics with default
+	 * settings.
+	 * 
+	 * @param semantics some identifier of a semantics.
+	 * @return the requested reasoner.
+	 */
+	public static AbstractBipolarExtensionReasoner getReasoner(Semantics semantics, String type) {
+		Support.Type support_type = Support.Type.getType(type);
+		switch (support_type) {
+			case DEFAULT -> {
+				return new SimpleCoalitionReasoner(semantics);
+			} case DEDUCTIVE,SIMPLE_DEDUCTIVE -> {
+				return new SimpleDeductiveReasoner(semantics);
+			} case NECESSITY,SIMPLE_NECESSITY -> {
+				return new SimpleNecessityReasoner(semantics);
+			} default -> throw new IllegalArgumentException("unsupported combination of support type and semantics " + type + " and " + semantics);
+        }
+	}
 
 	/**
 	 * Creates a new bipolar argumentation framework.
@@ -47,9 +75,9 @@ protected AbstractBipolarFrameworkFactory() {
 	 * @param supports supports
 	 * @return the requested reasoner.
 	 */
-	public static BipolarArgumentationFramework getArgumentationFramework(int numberOfArguments,
-																	 List<List<Integer>> attacks,
-																	 List<List<Integer>> supports) {
+	public static BipolarArgumentationFramework getBAF(int numberOfArguments,
+													   List<List<Integer>> attacks,
+													   List<List<Integer>> supports) {
 		BipolarArgumentationFramework argumentationFramework = new BipolarArgumentationFramework();
 
 		List<Argument> arguments = new ArrayList<Argument>();
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarReasonerPost.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarReasonerPost.java
index 1d11d1b8e..66273fb27 100644
--- a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarReasonerPost.java
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarReasonerPost.java
@@ -21,202 +21,218 @@
 import java.util.List;
 
 /**
- * Request payload for bipolar reasoner web service calls.
+ * The BipolarReasonerPost class represents a data structure for holding information
+ * related to a bipolar argumentation reasoner post sent via HTTP POST.
  */
 public class BipolarReasonerPost {
 
-  /**
-   * Creates an empty request payload.
-   */
-  public BipolarReasonerPost() {
-  }
+    /** The command type for the bipolar reasoner post */
+    private String cmd;
 
-  /** The command type for the bipolar reasoner request */
-  private String cmd;
+    /** The email associated with the bipolar reasoner post */
+    private String email;
 
-  /** The email associated with the bipolar reasoner request */
-  private String email;
+    /** The number of arguments in the bipolar reasoner post */
+    private int nr_of_arguments;
 
-  /** The number of arguments in the bipolar reasoner request */
-  private int nr_of_arguments;
+    /** The attacks information in the bipolar reasoner post */
+    private List<List<Integer>> attacks;
 
-  /** The attacks information in the bipolar reasoner request */
-  private List<List<Integer>> attacks;
+    /** The supports information in the bipolar reasoner post */
+    private List<List<Integer>> supports;
 
-  /** The supports information in the bipolar reasoner request */
-  private List<List<Integer>> supports;
+    /** The type of support for the bipolar reasoner post */
+    private String support_type;
 
-  /** The semantics specified in the bipolar reasoner request */
-  private String semantics;
+    /** The semantics specified in the bipolar reasoner post */
+    private String semantics;
 
-  /** The solver specified in the bipolar reasoner request */
-  private String solver;
+    /** The solver specified in the bipolar reasoner post */
+    private String solver;
 
-  /** The timeout value (in seconds) specified in the bipolar reasoner request */
-  private int timeout;
+    /** The timeout value (in seconds) specified in the bipolar reasoner post */
+    private int timeout;
 
-  /** The unit timeout value specified in the bipolar reasoner request */
-  private String unit_timeout;
+    /** The unit timeout value specified in the bipolar reasoner post */
+    private String unit_timeout;
 
-  /**
-   * Gets the unit timeout value specified in the bipolar reasoner request.
-   *
-   * @return The unit timeout value
-   */
-  public String getUnit_timeout() {
+    /**
+    * Gets the unit timeout value specified in the bipolar reasoner post.
+    *
+    * @return The unit timeout value
+    */
+    public String getUnit_timeout() {
       return unit_timeout;
-  }
-
-  /**
-   * Sets the unit timeout value in the bipolar reasoner request.
-   *
-   * @param unit_timeout The unit timeout value to be set
-   */
-  public void setUnit_timeout(String unit_timeout) {
+    }
+
+    /**
+    * Sets the unit timeout value in the bipolar reasoner post.
+    *
+    * @param unit_timeout The unit timeout value to be set
+    */
+    public void setUnit_timeout(String unit_timeout) {
       this.unit_timeout = unit_timeout;
-  }
-
-  /**
-   * Gets the command type in the bipolar reasoner request.
-   *
-   * @return The command type
-   */
-  public String getCmd() {
+    }
+
+    /**
+    * Gets the command type in the bipolar reasoner post.
+    *
+    * @return The command type
+    */
+    public String getCmd() {
       return this.cmd;
-  }
-
-  /**
-   * Sets the command type in the bipolar reasoner request.
-   *
-   * @param cmd The command type to be set
-   */
-  public void setCmd(String cmd) {
+    }
+
+    /**
+    * Sets the command type in the bipolar reasoner post.
+    *
+    * @param cmd The command type to be set
+    */
+    public void setCmd(String cmd) {
       this.cmd = cmd;
-  }
-
-  /**
-   * Gets the email associated with the bipolar reasoner request.
-   *
-   * @return The email associated with the request
-   */
-  public String getEmail() {
+    }
+
+    /**
+    * Gets the email associated with the bipolar reasoner post.
+    *
+    * @return The email associated with the post
+    */
+    public String getEmail() {
       return this.email;
-  }
-
-  /**
-   * Sets the email associated with the bipolar reasoner request.
-   *
-   * @param email The email to be set
-   */
-  public void setEmail(String email) {
+    }
+
+    /**
+    * Sets the email associated with the bipolar reasoner post.
+    *
+    * @param email The email to be set
+    */
+    public void setEmail(String email) {
       this.email = email;
-  }
-
-  /**
-   * Gets the number of arguments in the bipolar reasoner request.
-   *
-   * @return The number of arguments
-   */
-  public int getNr_of_arguments() {
+    }
+
+    /**
+    * Gets the number of arguments in the bipolar reasoner post.
+    *
+    * @return The number of arguments
+    */
+    public int getNr_of_arguments() {
       return this.nr_of_arguments;
-  }
-
-  /**
-   * Sets the number of arguments in the bipolar reasoner request.
-   *
-   * @param nr_of_arguments The number of arguments to be set
-   */
-  public void setNr_of_arguments(int nr_of_arguments) {
+    }
+
+    /**
+    * Sets the number of arguments in the bipolar reasoner post.
+    *
+    * @param nr_of_arguments The number of arguments to be set
+    */
+    public void setNr_of_arguments(int nr_of_arguments) {
       this.nr_of_arguments = nr_of_arguments;
-  }
-
-  /**
-   * Gets the attacks information in the bipolar reasoner request.
-   *
-   * @return The attacks information
-   */
-  public List<List<Integer>> getAttacks() {
+    }
+
+    /**
+    * Gets the attacks information in the bipolar reasoner post.
+    *
+    * @return The attacks information
+    */
+    public List<List<Integer>> getAttacks() {
       return this.attacks;
-  }
-
-  /**
-   * Sets the attacks information in the bipolar reasoner request.
-   *
-   * @param attacks The attacks information to be set
-   */
-  public void setAttacks(List<List<Integer>> attacks) {
+    }
+
+    /**
+    * Sets the attacks information in the bipolar reasoner post.
+    *
+    * @param attacks The attacks information to be set
+    */
+    public void setAttacks(List<List<Integer>> attacks) {
       this.attacks = attacks;
-  }
-
-  /**
-   * Gets the supports information in the bipolar reasoner request.
-   *
-   * @return The supports information
-   */
-  public List<List<Integer>> getSupports() {
+    }
+
+    /**
+    * Gets the supports information in the bipolar reasoner post.
+    *
+    * @return The supports information
+    */
+    public List<List<Integer>> getSupports() {
       return this.supports;
-  }
-
-  /**
-   * Sets the supports information in the bipolar reasoner request.
-   *
-   * @param supports The supports information to be set
-   */
-  public void setSupports(List<List<Integer>> supports) {
+    }
+
+    /**
+    * Sets the supports information in the bipolar reasoner post.
+    *
+    * @param supports The supports information to be set
+    */
+    public void setSupports(List<List<Integer>> supports) {
       this.supports = supports;
-  }
-
-  /**
-   * Gets the semantics specified in the bipolar reasoner request.
-   *
-   * @return The semantics specified
-   */
-  public String getSemantics() {
+    }
+
+    /**
+     * Gets the support_type specified in the bipolar reasoner post.
+     *
+     * @return The support_type specified
+     */
+    public String getSupport_type() {
+        return this.support_type;
+    }
+
+    /**
+     * Sets the support_type in the bipolar reasoner post.
+     *
+     * @param support_type The support_type to be set
+     */
+    public void setSupport_type(String support_type) {
+        this.support_type = support_type;
+    }
+
+    /**
+    * Gets the semantics specified in the bipolar reasoner post.
+    *
+    * @return The semantics specified
+    */
+    public String getSemantics() {
       return this.semantics;
-  }
-
-  /**
-   * Sets the semantics in the bipolar reasoner request.
-   *
-   * @param semantics The semantics to be set
-   */
-  public void setSemantics(String semantics) {
+    }
+
+    /**
+    * Sets the semantics in the bipolar reasoner post.
+    *
+    * @param semantics The semantics to be set
+    */
+    public void setSemantics(String semantics) {
       this.semantics = semantics;
-  }
-
-  /**
-   * Gets the solver specified in the bipolar reasoner request.
-   *
-   * @return The solver specified
-   */
-  public String getSolver() {
+    }
+
+    /**
+    * Gets the solver specified in the bipolar reasoner post.
+    *
+    * @return The solver specified
+    */
+    public String getSolver() {
       return this.solver;
-  }
-
-  /**
-   * Sets the solver in the bipolar reasoner request.
-   *
-   * @param solver The solver to be set
-   */
-  public void setSolver(String solver) {
+    }
+
+    /**
+    * Sets the solver in the bipolar reasoner post.
+    *
+    * @param solver The solver to be set
+    */
+    public void setSolver(String solver) {
       this.solver = solver;
-  }
-
-  /**
-   * Gets the timeout value (in seconds) specified in the bipolar reasoner request.
-   *
-   * @return The timeout value
-   */
-  public int getTimeout() {
+    }
+
+    /**
+    * Gets the timeout value (in seconds) specified in the bipolar reasoner post.
+    *
+    * @return The timeout value
+    */
+    public int getTimeout() {
       return this.timeout;
-  }
-
-  /**
-   * Sets the timeout value (in seconds) in the bipolar reasoner request.
-   *
-   * @param timeout The timeout value to be set
-   */
-  public void setTimeout(int timeout) {
+    }
+
+    /**
+    * Sets the timeout value (in seconds) in the bipolar reasoner post.
+    *
+    * @param timeout The timeout value to be set
+    */
+    public void setTimeout(int timeout) {
       this.timeout = timeout;
-  }
+    }
 }
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarReasonerResponse.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarReasonerResponse.java
index 40abcd30b..99ece213d 100644
--- a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarReasonerResponse.java
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarReasonerResponse.java
@@ -44,6 +44,9 @@ public class BipolarReasonerResponse extends Response {
     /** The supports information in the bipolar reasoner response */
     private List<List<Integer>> supports;
 
+    /** The support type in the bipolar reasoner response */
+    private String support_type;
+
     /** The semantics specified in the bipolar reasoner response */
     private String semantics;
 
@@ -71,23 +74,25 @@ public BipolarReasonerResponse() {
     /**
      * Creates a bipolar reasoner response.
      *
-     * @param reply the reply message
-     * @param email the email associated with the response
-     * @param nr_of_arguments the number of arguments
-     * @param attacks the attacks information
-     * @param supports the supports information
-     * @param semantics the semantics specified
-     * @param solver the solver specified
-     * @param answer the answer provided
-     * @param time the time taken for the operation
-     * @param unit_time the unit time specified
-     * @param status the status of the response
+     * @param reply           The reply message
+     * @param email           The email associated with the response
+     * @param nr_of_arguments The number of arguments
+     * @param attacks         The attacks information
+     * @param supports        The supports information
+     * @param support_type    The support type information
+     * @param semantics       The semantics specified
+     * @param solver          The solver specified
+     * @param answer          The answer provided
+     * @param time            The time taken for the operation
+     * @param unit_time       The unit time specified
+     * @param status          The status of the response
      */
     public BipolarReasonerResponse(String reply,
                                    String email,
                                    int nr_of_arguments,
                                    List<List<Integer>> attacks,
                                    List<List<Integer>> supports,
+                                   String support_type,
                                    String semantics,
                                    String solver,
                                    String answer,
@@ -99,6 +104,7 @@ public BipolarReasonerResponse(String reply,
         this.nr_of_arguments = nr_of_arguments;
         this.attacks = attacks;
         this.supports = supports;
+        this.support_type = support_type;
         this.semantics = semantics;
         this.solver = solver;
         this.answer = answer;
@@ -197,6 +203,24 @@ public void setSupports(List<List<Integer>> supports) {
         this.supports = supports;
     }
 
+    /**
+     * Gets the support_type specified in the bipolar reasoner post.
+     *
+     * @return The support_type specified
+     */
+    public String getSupport_type() {
+        return this.support_type;
+    }
+
+    /**
+     * Sets the support_type in the bipolar reasoner post.
+     *
+     * @param support_type The support_type to be set
+     */
+    public void setSupport_type(String support_type) {
+        this.support_type = support_type;
+    }
+
     /**
      * Gets the semantics specified in the bipolar reasoner response.
      *
@@ -349,6 +373,28 @@ public BipolarReasonerResponse attacks(List<List<Integer>> attacks) {
         return this;
     }
 
+    /**
+     * Sets the supports information in the bipolar reasoner response.
+     *
+     * @param supports The supports information in the bipolar reasoner response.
+     * @return The current instance of BipolarReasonerResponse.
+     */
+    public BipolarReasonerResponse supports(List<List<Integer>> supports) {
+        setSupports(supports);
+        return this;
+    }
+
+    /**
+     * Sets the support_type specified in the bipolar reasoner response.
+     *
+     * @param support_type The support_type specified in the bipolar reasoner response.
+     * @return The current instance of BipolarReasonerResponse.
+     */
+    public BipolarReasonerResponse support_type(String support_type) {
+        setSupport_type(support_type);
+        return this;
+    }
+
     /**
      * Sets the semantics specified in the bipolar reasoner response.
      *
@@ -411,6 +457,8 @@ public String toString() {
                 ", email='" + getEmail() + "'" +
                 ", nr_of_arguments='" + getNr_of_arguments() + "'" +
                 ", attacks='" + getAttacks() + "'" +
+                ", supports='" + getSupports() + "'" +
+                ", support_type='" + getSupport_type() + "'" +
                 ", semantics='" + getSemantics() + "'" +
                 ", solver='" + getSolver() + "'" +
                 ", answer='" + getAnswer() + "'" +
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarSemantics.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarSemantics.java
deleted file mode 100644
index 9820b81c3..000000000
--- a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarSemantics.java
+++ /dev/null
@@ -1,108 +0,0 @@
-/*
- *  This file is part of "TweetyProject", a collection of Java libraries for
- *  logical aspects of artificial intelligence and knowledge representation.
- *
- *  TweetyProject is free software: you can redistribute it and/or modify
- *  it under the terms of the GNU Lesser General Public License version 3 as
- *  published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with this program. If not, see <http://www.gnu.org/licenses/>.
- *
- *  Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
- */
-package org.tweetyproject.web.services.bipolar;
-
-import org.tweetyproject.arg.bipolar.syntax.Support;
-
-import java.util.NoSuchElementException;
-
-
-/**
- * An enumeration of all available semantics through the web service.
- *
- * @author Oleksandr Dzhychko
- */
-public enum BipolarSemantics {
-
-    /** bipolar conflict-free semantics */
-    BCF("b-cf", "Conflict-Free", Support.Type.DEFAULT),
-    /** bipolar coherent semantics */
-    BCOH("b-coh", "Coherent", Support.Type.DEFAULT),
-    /** bipolar coherent admissible semantics */
-    BAD("b-ad", "Coherent Admissible", Support.Type.DEFAULT),
-    /** coalition-admissible semantics */
-    CAD("b-coal-ad", "Coalition-Admissible", Support.Type.DEFAULT),
-    /** coalition-complete semantics */
-    CCO("b-coal-co", "Coalition-Complete", Support.Type.DEFAULT),
-    /** coalition-grounded semantics */
-    CGR("b-coal-gr", "Coalition-Grounded", Support.Type.DEFAULT),
-    /** coalition-preferred semantics */
-    CPR("b-coal-pr", "Coalition-Preferred", Support.Type.DEFAULT),
-    /** coalition-stable semantics */
-    CST("b-coal-st", "Coalition-Stable", Support.Type.DEFAULT),
-    /** deductive-admissible semantics */
-    DAD("d-ad", "Admissible", Support.Type.DEDUCTIVE),
-    /** deductive-complete semantics */
-    DCO("d-co", "Complete", Support.Type.DEDUCTIVE),
-    /** deductive-grounded semantics */
-    DGR("d-gr", "Grounded", Support.Type.DEDUCTIVE),
-    /** deductive-preferred semantics */
-    DPR("d-pr", "Preferred", Support.Type.DEDUCTIVE),
-    /** deductive-stable semantics */
-    DST("d-st", "Stable", Support.Type.DEDUCTIVE),
-    /** necessary-admissible semantics */
-    NAD("n-ad", "Admissible", Support.Type.NECESSITY),
-    /** necessary-complete semantics */
-    NCO("n-co", "Complete", Support.Type.NECESSITY),
-    /** necessary-grounded semantics */
-    NGR("n-gr", "Grounded", Support.Type.NECESSITY),
-    /** necessary-preferred semantics */
-    NPR("n-pr", "Preferred", Support.Type.NECESSITY),
-    /** necessary-stable semantics */
-    NST("n-st", "Stable", Support.Type.NECESSITY);
-
-    /**
-     * id
-     */
-    public String id;
-    /**
-     * label
-     */
-    public String label;
-    /**
-     * What type of input is expected for this semantic.
-     */
-    public Support.Type type;
-
-    /**
-     * Creates a bipolar semantics entry.
-     *
-     * @param id the string identifier
-     * @param label the human-readable label
-     * @param input the expected support type
-     */
-    BipolarSemantics(String id, String label, Support.Type input) {
-        this.id = id;
-        this.label = label;
-        this.type = input;
-    }
-
-    /**
-     * Looks up a semantics entry by its identifier.
-     *
-     * @param id the string identifier
-     * @return the semantics
-     */
-    public static BipolarSemantics getSemantics(String id) {
-        for (BipolarSemantics m : BipolarSemantics.values())
-            if (m.id.equals(id))
-                return m;
-        throw new NoSuchElementException("semantics does not exist");
-    }
-}
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarServicesInfoResponse.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarServicesInfoResponse.java
index 521fd39ff..d2c0edfd6 100644
--- a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarServicesInfoResponse.java
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/bipolar/BipolarServicesInfoResponse.java
@@ -37,6 +37,9 @@ public class BipolarServicesInfoResponse extends Response {
     /** The backend timeout value specified in the bipolar services info response */
     private int backend_timeout;
 
+    /** The list of supported support types in the bipolar services info response */
+    private List<String> support_type;
+
     /** The list of supported semantics in the bipolar services info response */
     private List<String> semantics;
 
@@ -55,13 +58,15 @@ public BipolarServicesInfoResponse() {
      * @param reply           The reply message
      * @param email           The email associated with the response
      * @param backend_timeout The backend timeout value
+     * @param support_type    The list of supported support types
      * @param semantics       The list of supported semantics
      * @param commands        The list of supported commands
      */
-    public BipolarServicesInfoResponse(String reply, String email, int backend_timeout, List<String> semantics, List<String> commands) {
+    public BipolarServicesInfoResponse(String reply, String email, int backend_timeout, List<String> support_type, List<String> semantics, List<String> commands) {
         this.reply = reply;
         this.email = email;
         this.backend_timeout = backend_timeout;
+        this.support_type = support_type;
         this.semantics = semantics;
         this.commands = commands;
     }
@@ -120,6 +125,24 @@ public void setBackend_timeout(int backend_timeout) {
         this.backend_timeout = backend_timeout;
     }
 
+    /**
+     * Gets the list of support_type elements associated with the service.
+     *
+     * @return A list of support_types as strings.
+     */
+    public List<String> getSupport_type() {
+        return this.support_type;
+    }
+
+    /**
+     * Sets the list of support_type elements for the service.
+     *
+     * @param support_type A list of support_type strings to be used or defined by the service.
+     */
+    public void setSupport_type(List<String> support_type) {
+        this.support_type = support_type;
+    }
+
     /**
      * Gets the list of semantic elements associated with the service.
      *
@@ -191,6 +214,17 @@ public BipolarServicesInfoResponse backend_timeout(int backend_timeout) {
         return this;
     }
 
+    /**
+     * Sets the support_type and returns this instance for method chaining.
+     *
+     * @param support_type A list of semantic strings to set.
+     * @return This instance to facilitate further modifications.
+     */
+    public BipolarServicesInfoResponse support_type(List<String> support_type) {
+        setSupport_type(support_type);
+        return this;
+    }
+
     /**
      * Sets the semantics and returns this instance for method chaining.
      *
@@ -216,11 +250,12 @@ public BipolarServicesInfoResponse commands(List<String> commands) {
     @Override
     public String toString() {
         return "{" +
-            " reply='" + getReply() + "'" +
-            ", email='" + getEmail() + "'" +
-            ", backend_timeout='" + getBackend_timeout() + "'" +
-            ", semantics='" + getSemantics() + "'" +
-            ", commands='" + getCommands() + "'" +
+                " reply='" + getReply() + "'" +
+                ", email='" + getEmail() + "'" +
+                ", backend_timeout='" + getBackend_timeout() + "'" +
+                ", support_type='" + getSupport_type() + "'" +
+                ", semantics='" + getSemantics() + "'" +
+                ", commands='" + getCommands() + "'" +
             "}";
     }
 }
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/causal/CausalController.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/causal/CausalController.java
new file mode 100644
index 000000000..cf7241599
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/causal/CausalController.java
@@ -0,0 +1,186 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2016 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.causal;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.lang.Nullable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.server.ResponseStatusException;
+import org.tweetyproject.causal.parser.CausalParser;
+import org.tweetyproject.causal.syntax.CausalKnowledgeBase;
+import org.tweetyproject.commons.ParserException;
+import org.tweetyproject.logics.pl.syntax.PlFormula;
+import org.tweetyproject.logics.pl.syntax.Proposition;
+import org.tweetyproject.web.services.LoggerUtil;
+import org.tweetyproject.web.services.Utils;
+
+import javafx.util.Pair;
+
+import javax.validation.Valid;
+
+import static org.tweetyproject.web.services.causal.CausalReasonerResponse.Status.SUCCESS;
+import static org.tweetyproject.web.services.causal.CausalReasonerResponse.Status.TIMEOUT;
+
+/**
+ * Handles HTTP POST requests for the {@code /causal} endpoint.
+ */
+@RestController
+public class CausalController {
+
+	private static final int TIMEOUT_SECONDS = 300;
+
+	private final ObjectMapper objectMapper;
+	private final CausalReasonerService causalReasonerService;
+
+	@Autowired
+	public CausalController(ObjectMapper objectMapper, CausalReasonerService causalReasonerService) {
+		this.objectMapper = objectMapper;
+		this.causalReasonerService = causalReasonerService;
+	}
+
+	@PostMapping(value = "/causal", produces = "application/json")
+	@ResponseBody
+	public CausalReasonerResponse handleRequest(@Valid @RequestBody CausalReasonerPost request) {
+		LoggerUtil.logger.info(String.format("Run causal reasoner command \"%s\" for user \"%s\" with timeout: %s %s",
+				request.getCmd(), request.getEmail(), request.getTimeout(), request.getUnit_timeout()));
+
+		TimeUnit timeoutUnit = Utils.getTimeoutUnit(request.getUnit_timeout());
+		int timeout = Utils.checkUserTimeout(request.getTimeout(), TIMEOUT_SECONDS, timeoutUnit);
+		ExecutorService executor = Executors.newSingleThreadExecutor();
+		Pair<String, Long> resultAndTime;
+		try {
+			var future = executor.submit(() -> processCommand(request));
+			resultAndTime = Utils.runServicesWithTimeout(future, timeout, timeoutUnit);
+		} catch (TimeoutException e) {
+			LoggerUtil.logger.info("Timeout while running causal reasoner.");
+			return new CausalReasonerResponse(null, request.getEmail(), timeout, request.getUnit_timeout(), TIMEOUT);
+		} catch (ExecutionException e) {
+			LoggerUtil.logger.warning(() -> "Error while running causal reasoner: " + e.getMessage());
+			e.printStackTrace();
+			throw new RuntimeException(e);
+		} catch (InterruptedException e) {
+			LoggerUtil.logger.warning(() -> "Interrupt while running causal reasoner: " + e.getMessage());
+			e.printStackTrace();
+			Thread.currentThread().interrupt();
+			throw new RuntimeException("Thread was interrupted.");
+		} finally {
+			executor.shutdownNow();
+		}
+		return new CausalReasonerResponse(resultAndTime.getKey(), request.getEmail(),
+				resultAndTime.getValue(), request.getUnit_timeout(), SUCCESS);
+	}
+
+	private String processCommand(CausalReasonerPost post) {
+		return switch (post.getCmd()) {
+			case GET_CONCLUSIONS -> processConclusionsCommand(post);
+			case GET_SIGNIFICANT_ATOMS -> processSignificantAtomsCommand(post);
+			case GET_ARGUMENTATION_FRAMEWORK -> processArgumentationFramework(post);
+			case GET_SEQUENCE_EXPLANATIONS -> processSequenceExplanations(post);
+		};
+	}
+
+	private String processConclusionsCommand(CausalReasonerPost post) {
+		CausalKnowledgeBase kb = parseKnowledgeBase(post);
+		Collection<PlFormula> observations = parseObservations(post);
+		return causalReasonerService.queryConclusions(kb, observations, parseConclusionFilter(post)).toString();
+	}
+
+	private String processSignificantAtomsCommand(CausalReasonerPost post) {
+		CausalKnowledgeBase kb = parseKnowledgeBase(post);
+		Collection<PlFormula> observations = parseObservations(post);
+		var perAtomSignificantAtoms = causalReasonerService.queryPerAtomSignificantAtoms(kb, observations, parseConclusionFilter(post));
+		Map<String, Collection<String>> jsonData = new HashMap<>();
+		for (Map.Entry<Proposition, Collection<Proposition>> entry : perAtomSignificantAtoms.entrySet()) {
+			List<String> list = new ArrayList<>();
+			for (Proposition p : entry.getValue())
+				list.add(p.toString());
+			jsonData.put(entry.getKey().toString(), list);
+		}
+		try {
+			return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(jsonData);
+		} catch (JsonProcessingException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private String processSequenceExplanations(CausalReasonerPost post) {
+		CausalKnowledgeBase kb = parseKnowledgeBase(post);
+		Collection<PlFormula> observations = parseObservations(post);
+		var reply = SequenceExplanationReply.from(causalReasonerService.querySequenceExplanations(kb, observations, parseConclusionFilter(post)));
+		try {
+			return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(reply);
+		} catch (JsonProcessingException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private String processArgumentationFramework(CausalReasonerPost post) {
+		CausalKnowledgeBase kb = parseKnowledgeBase(post);
+		Collection<PlFormula> observations = parseObservations(post);
+		var reply = ArgumentationFrameworkReply.from(causalReasonerService.queryArgumentationFramework(kb, observations));
+		try {
+			return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(reply);
+		} catch (JsonProcessingException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private static Collection<PlFormula> parseObservations(CausalReasonerPost post) {
+		try {
+			return new CausalParser().parseListOfFormulae(post.getObservations(), ",");
+		} catch (ParserException e) {
+			throw new ResponseStatusException(HttpStatus.BAD_REQUEST, null, e);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private static @Nullable Set<Proposition> parseConclusionFilter(CausalReasonerPost post) {
+		return ConclusionsFilterSerialization.parse(post.getConclusionsFilter());
+	}
+
+	private static CausalKnowledgeBase parseKnowledgeBase(CausalReasonerPost post) {
+		try {
+			return new CausalParser().parseBeliefBase(post.getKb());
+		} catch (ParserException e) {
+			throw new ResponseStatusException(HttpStatus.BAD_REQUEST, null, e);
+		} catch (IOException e) {
+			throw new RuntimeException(e);
+		}
+	}
+}
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/dung/AbstractExtensionReasonerFactory.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/dung/AbstractExtensionReasonerFactory.java
index 52b94d3e0..df2921205 100644
--- a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/dung/AbstractExtensionReasonerFactory.java
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/dung/AbstractExtensionReasonerFactory.java
@@ -20,14 +20,18 @@
 
 import org.tweetyproject.arg.dung.reasoner.*;
 import org.tweetyproject.arg.dung.semantics.Semantics;
+import org.tweetyproject.arg.dung.serialisability.syntax.SelectionFunction;
+import org.tweetyproject.arg.dung.serialisability.syntax.TerminationFunction;
 import org.tweetyproject.arg.dung.syntax.Argument;
 import org.tweetyproject.arg.dung.syntax.DungTheory;
 import org.tweetyproject.graphs.DefaultGraph;
 import org.tweetyproject.graphs.DirectedEdge;
 import org.tweetyproject.graphs.Graph;
+import org.tweetyproject.web.services.serialisation.SerialisationFactory;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Abstract factory for retrieving Dung extension reasoners.
@@ -62,6 +66,50 @@ public static AbstractExtensionReasoner getReasoner(Semantics sem) {
 		return AbstractExtensionReasoner.getSimpleReasonerForSemantics(sem);
 	}
 
+	/**
+	 * Creates a reasoner for the given semantics identifier, initialized with the given
+	 * parameters. In addition to the semantics handled by {@link #getReasoner(Semantics)},
+	 * this supports the meta-reasoners "QLD" (qualified), "SQLD" (semi-qualified), "VR"
+	 * (vacuous reduct) and "SER" (serialised), whose base (and, for "VR", reduct;
+	 * for "SER", selection/termination function) parameters are read from {@code args}.
+	 * Parameters missing from {@code args} fall back to documented defaults.
+	 *
+	 * @param semantics identifier of a semantics or meta-reasoner
+	 * @param args      map of constructor parameters for meta-reasoners, keyed by parameter name
+	 * @return the requested reasoner
+	 */
+	public static AbstractExtensionReasoner getReasoner(String semantics, Map<String, Object> args) {
+		switch (semantics) {
+			case "QLD" -> {
+				return new QualifiedReasoner(getSemantics(args, "baseSemantics", Semantics.CO));
+			} case "SQLD" -> {
+				return new SemiQualifiedReasoner(getSemantics(args, "baseSemantics", Semantics.CO));
+			} case "VR" -> {
+				AbstractExtensionReasoner base = getReasoner(getSemantics(args, "baseSemantics", Semantics.CF));
+				AbstractExtensionReasoner reduct = getReasoner(getSemantics(args, "reductSemantics", Semantics.ADM));
+				return new VacuousReductReasoner(base, reduct);
+			} case "SER" -> {
+				SelectionFunction selection = SerialisationFactory.getSelectionFunction(getString(args, "selectionFunction", "ADM"));
+				TerminationFunction termination = SerialisationFactory.getTerminationFunction(getString(args, "terminationFunction", "PR"));
+				return new SerialisedExtensionReasoner(selection, termination);
+			} default -> {
+				return getReasoner(Semantics.getSemantics(semantics));
+			}
+		}
+	}
+
+	private static Semantics getSemantics(Map<String, Object> args, String key, Semantics defaultValue) {
+		if (args == null) return defaultValue;
+		Object value = args.get(key);
+		return value instanceof String ? Semantics.getSemantics((String) value) : defaultValue;
+	}
+
+	private static String getString(Map<String, Object> args, String key, String defaultValue) {
+		if (args == null) return defaultValue;
+		Object value = args.get(key);
+		return value instanceof String ? (String) value : defaultValue;
+	}
+
     /**
      * Creates a DungTheory from the given number of arguments and attack relations.
      *
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/dung/DungReasonerPost.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/dung/DungReasonerPost.java
index 5bcf3ac1a..62dc0e7df 100644
--- a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/dung/DungReasonerPost.java
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/dung/DungReasonerPost.java
@@ -19,6 +19,7 @@
 package org.tweetyproject.web.services.dung;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * Request payload for Dung reasoner web service calls.
@@ -49,6 +50,9 @@ public DungReasonerPost() {
   /** The solver specified in the Dung reasoner request */
   private String solver;
 
+  /** Additional constructor parameters for the reasoner, keyed by parameter name */
+  private Map<String, Object> args;
+
   /** The timeout value (in seconds) specified in the Dung reasoner request */
   private int timeout;
 
@@ -181,6 +185,24 @@ public void setSolver(String solver) {
       this.solver = solver;
   }
 
+  /**
+   * Gets the additional constructor parameters for the reasoner.
+   *
+   * @return The reasoner parameters, keyed by parameter name
+   */
+  public Map<String, Object> getArgs() {
+      return this.args;
+  }
+
+  /**
+   * Sets the additional constructor parameters for the reasoner.
+   *
+   * @param args The reasoner parameters to be set, keyed by parameter name
+   */
+  public void setArgs(Map<String, Object> args) {
+      this.args = args;
+  }
+
   /**
    * Gets the timeout value (in seconds) specified in the Dung reasoner request.
    *
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/rankings/AbstractRankingReasonerFactory.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/rankings/AbstractRankingReasonerFactory.java
index e034e150a..2889c09fa 100644
--- a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/rankings/AbstractRankingReasonerFactory.java
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/rankings/AbstractRankingReasonerFactory.java
@@ -18,8 +18,18 @@
  */
 package org.tweetyproject.web.services.rankings;
 
+import java.util.Map;
+
+import org.tweetyproject.arg.dung.semantics.Semantics;
 import org.tweetyproject.arg.rankings.reasoner.AbstractRankingReasoner;
+import org.tweetyproject.arg.rankings.reasoner.CategorizerRankingReasoner;
+import org.tweetyproject.arg.rankings.reasoner.CountingRankingReasoner;
+import org.tweetyproject.arg.rankings.reasoner.ProbabilisticRankingReasoner;
+import org.tweetyproject.arg.rankings.reasoner.PropagationRankingReasoner;
+import org.tweetyproject.arg.rankings.reasoner.SAFRankingReasoner;
 import org.tweetyproject.arg.rankings.semantics.RankingSemantics;
+import org.tweetyproject.commons.InferenceMode;
+import org.tweetyproject.math.probability.Probability;
 
 /**
  * Abstract factory for creating ranking reasoners.
@@ -38,11 +48,11 @@ private AbstractRankingReasonerFactory() {
      * @return the list o all ranking semantics
      */
     public static RankingSemantics[] getSemantics() {
-        return new RankingSemantics[]{RankingSemantics.CAT,RankingSemantics.SER,RankingSemantics.BB,RankingSemantics.CO,RankingSemantics.DB,RankingSemantics.IGD,RankingSemantics.SAF,RankingSemantics.SB,RankingSemantics.TU};
+        return new RankingSemantics[]{RankingSemantics.CAT,RankingSemantics.SER,RankingSemantics.BB,RankingSemantics.CO,RankingSemantics.DB,RankingSemantics.IGD,RankingSemantics.SAF,RankingSemantics.SB,RankingSemantics.TU,RankingSemantics.PR,RankingSemantics.PROB};
     }
 
     /**
-     * returns a simple reasoner for the given semantics
+     * returns a simple reasoner for the given semantics, using default parameters
      * @param semantics some ranking semantics
      * @return simple reasoner for the given semantics
      */
@@ -50,6 +60,53 @@ public static AbstractRankingReasoner<?> getReasoner(RankingSemantics semantics)
         return AbstractRankingReasoner.getRankingReasonerForSemantics(semantics);
     }
 
+    /**
+     * returns a reasoner for the given semantics, initialized with the given parameters.
+     * Parameters that are missing from {@code args} fall back to the reasoner's own defaults.
+     * @param semantics some ranking semantics
+     * @param args map of constructor parameters for the reasoner, keyed by parameter name
+     * @return reasoner for the given semantics, configured with the given parameters
+     */
+    public static AbstractRankingReasoner<?> getReasoner(RankingSemantics semantics, Map<String, Object> args) {
+        if (args == null || args.isEmpty())
+            return getReasoner(semantics);
+        switch (semantics) {
+            case CAT -> {
+                return new CategorizerRankingReasoner(getDouble(args, "epsilon", 0.001));
+            } case CO -> {
+                return new CountingRankingReasoner(getDouble(args, "dampingFactor", 0.9), getDouble(args, "epsilon", 0.001));
+            } case SAF -> {
+                return new SAFRankingReasoner(getDouble(args, "epsilon", 0.1), getDouble(args, "precision", 0.0001), getDouble(args, "tolerance", 0.0001));
+            } case PR -> {
+                PropagationRankingReasoner.PropagationSemantics propagationSemantics = PropagationRankingReasoner.PropagationSemantics.valueOf(
+                        getString(args, "propagationSemantics", "PROPAGATION1"));
+                return new PropagationRankingReasoner(getDouble(args, "attackedArgumentsInfluence", 0.75), getBoolean(args, "useMultiset", true), propagationSemantics);
+            } case PROB -> {
+                Semantics classicalSemantics = Semantics.getSemantics(getString(args, "classicalSemantics", "GR"));
+                Probability probability = new Probability(getDouble(args, "probability", 0.5));
+                InferenceMode mode = InferenceMode.valueOf(getString(args, "inferenceMode", "SKEPTICAL"));
+                return new ProbabilisticRankingReasoner(classicalSemantics, probability, getBoolean(args, "exactInference", true), mode);
+            } default -> {
+                return getReasoner(semantics);
+            }
+        }
+    }
+
+    private static double getDouble(Map<String, Object> args, String key, double defaultValue) {
+        Object value = args.get(key);
+        return value instanceof Number ? ((Number) value).doubleValue() : defaultValue;
+    }
+
+    private static boolean getBoolean(Map<String, Object> args, String key, boolean defaultValue) {
+        Object value = args.get(key);
+        return value instanceof Boolean ? (Boolean) value : defaultValue;
+    }
+
+    private static String getString(Map<String, Object> args, String key, String defaultValue) {
+        Object value = args.get(key);
+        return value instanceof String ? (String) value : defaultValue;
+    }
+
     /**
      * Determine what type of ranking the semantics computes
      * @param semantics some ranking semantics as a string
@@ -58,9 +115,9 @@ public static AbstractRankingReasoner<?> getReasoner(RankingSemantics semantics)
     public static String getRankingType(String semantics) {
         RankingSemantics sem = RankingSemantics.getSemantics(semantics);
         switch (sem) {
-            case CAT,CO,SAF,SB -> {
+            case CAT,CO,SAF,SB,PROB -> {
                 return "numerical";
-            } case BB, SER, DB, IGD, TU -> {
+            } case BB, SER, DB, IGD, TU, PR -> {
                 return "lattice";
             } default -> throw new IllegalArgumentException("unsupported semantics");
         }
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/rankings/RankingReasonerPost.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/rankings/RankingReasonerPost.java
index 2ab948c9d..d8cea17ed 100644
--- a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/rankings/RankingReasonerPost.java
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/rankings/RankingReasonerPost.java
@@ -19,6 +19,7 @@
 package org.tweetyproject.web.services.rankings;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * The RankingReasonerPost class represents a data structure for holding information
@@ -48,6 +49,9 @@ public RankingReasonerPost() {
     /** The solver specified in the Ranking reasoner request */
     private String solver;
 
+    /** Additional constructor parameters for the reasoner, keyed by parameter name */
+    private Map<String, Object> args;
+
     /** The timeout value (in seconds) specified in the Ranking reasoner request */
     private int timeout;
 
@@ -180,6 +184,24 @@ public void setSolver(String solver) {
         this.solver = solver;
     }
 
+    /**
+     * Gets the additional constructor parameters for the reasoner.
+     *
+     * @return The reasoner parameters, keyed by parameter name
+     */
+    public Map<String, Object> getArgs() {
+        return this.args;
+    }
+
+    /**
+     * Sets the additional constructor parameters for the reasoner.
+     *
+     * @param args The reasoner parameters to be set, keyed by parameter name
+     */
+    public void setArgs(Map<String, Object> args) {
+        this.args = args;
+    }
+
     /**
      * Gets the timeout value (in seconds) specified in the Ranking reasoner request.
      *
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationCalleeFactory.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationCalleeFactory.java
new file mode 100644
index 000000000..2fde191f0
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationCalleeFactory.java
@@ -0,0 +1,115 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.serialisation;
+
+import org.tweetyproject.arg.dung.semantics.Extension;
+import org.tweetyproject.arg.dung.serialisability.syntax.SelectionFunction;
+import org.tweetyproject.arg.dung.serialisability.syntax.TerminationFunction;
+import org.tweetyproject.arg.dung.syntax.DungTheory;
+import org.tweetyproject.web.services.Callee;
+
+/**
+ * The SerialisationCalleeFactory class is responsible for creating instances of Callee
+ * based on the specified Command, DungTheory, Extension, Selection and termination function parameters.
+ * It also defines an enumeration of commands with associated IDs and labels.
+ */
+public class SerialisationCalleeFactory {
+    /**
+     * Enumeration of commands supported by the factory, each with a unique ID and label.
+     */
+    public enum Command {
+
+        /** get reduct */
+        GET_REDUCT("get_reduct", "Get Reduct for the given state"),
+        /** is the state terminal */
+        IS_TERMINAL("is_terminal", "Determine whether the given state is terminal"),
+        /** get selection of initial sets */
+        GET_SELECTION("get_selection", "Get the selectable initial sets of the state"),
+        /** get models */
+        GET_MODELS("get_models", "Get the extensions for the given functions"),
+        /** get sequences */
+        GET_SEQUENCES("get_sequences", "Get all serialisation sequences for the given functions");
+
+        /** ID of the command */
+        public final String id;
+        /** Label of the command */
+        public final String label;
+
+        /**
+         * Constructor for Command enum.
+         *
+         * @param id    ID of the command
+         * @param label Label of the command
+         */
+        Command(String id, String label) {
+            this.id = id;
+            this.label = label;
+        }
+
+        /**
+         * Retrieves the Command enum based on the provided ID.
+         *
+         * @param id ID of the command
+         * @return The corresponding Command enum, or null if not found
+         */
+        public static Command getCommand(String id) {
+            for (Command m : Command.values())
+                if (m.id.equals(id))
+                    return m;
+            return null;
+        }
+    }
+
+    /**
+     * Retrieves an array of all available Command enums.
+     *
+     * @return An array of Command enums
+     */
+    public static Command[] getCommands() {
+        return Command.values();
+    }
+
+    /**
+     * Creates and returns a Callee instance based on the provided Command, AbstractExtensionReasoner,
+     * and DungTheory parameters.
+     *
+     * @param cmd       The command to be executed
+     * @param alpha     The selection function
+     * @param beta      The termination function
+     * @param bbase     The DungTheory to be processed
+     * @param extension The extension to be processed
+     * @return A Callee instance corresponding to the specified command
+     * @throws RuntimeException If the specified command is not found
+     */
+    public static Callee getCallee(Command cmd, SelectionFunction alpha, TerminationFunction beta, DungTheory bbase, Extension<DungTheory> extension) {
+        switch (cmd) {
+            case GET_REDUCT -> {
+                return new SerialisationGetReductCallee(bbase, extension);
+            } case IS_TERMINAL -> {
+                return new SerialisationIsTerminalCallee(bbase, extension, beta);
+            } case GET_SELECTION -> {
+                return new SerialisationGetSelectionCallee(bbase, alpha);
+            } case GET_MODELS -> {
+                return new SerialisationGetModelsCallee(bbase, alpha, beta);
+            } case GET_SEQUENCES -> {
+                return new SerialisationGetSequencesCallee(bbase, alpha, beta);
+            } default -> throw new RuntimeException("Command not found: " + cmd);
+        }
+    }
+}
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationFactory.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationFactory.java
new file mode 100644
index 000000000..a0a7d4720
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationFactory.java
@@ -0,0 +1,104 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.serialisation;
+
+import org.tweetyproject.arg.dung.semantics.Extension;
+import org.tweetyproject.arg.dung.serialisability.syntax.SelectionFunction;
+import org.tweetyproject.arg.dung.serialisability.syntax.TerminationFunction;
+import org.tweetyproject.arg.dung.syntax.Argument;
+import org.tweetyproject.arg.dung.syntax.DungTheory;
+
+import java.util.List;
+
+/**
+ * Main factory for retrieving serialisation related things
+ *
+ * @author Lars Bengel
+ */
+public class SerialisationFactory {
+    /**
+     * parses an extension from a list of integers
+     * @param extension extension as a list on integers
+     * @return the parsed extension
+     */
+    public static Extension<DungTheory> getExtension(List<Integer> extension) {
+        if (extension==null) return null;
+        Extension<DungTheory> result = new Extension<>();
+        for (Integer i : extension) {
+            result.add(new Argument(Integer.toString(i)));
+        }
+        return result;
+    }
+
+    /**
+     * determine the selection function
+     * @param selectionFunction string id of selection functions
+     * @return the selection function
+     */
+    public static SelectionFunction getSelectionFunction(String selectionFunction) {
+        if (selectionFunction==null) return null;
+        switch (selectionFunction) {
+            case "ADM" -> {
+                return SelectionFunction.ADMISSIBLE;
+            } case "UC" -> {
+                return SelectionFunction.UNCHALLENGED;
+            } case "GR" -> {
+                return SelectionFunction.GROUNDED;
+            } default -> throw new IllegalArgumentException("unknown selection function " + selectionFunction);
+        }
+    }
+
+    /**
+     * get all available selection functions
+     * @return the selection functions
+     */
+    public static List<String> getSelectionFunctions() {
+        return List.of("ADM", "UC", "GR");
+    }
+
+    /**
+     * determine the termination function
+     * @param terminationFunction string idf of termination function
+     * @return the termination function
+     */
+    public static TerminationFunction getTerminationFunction(String terminationFunction) {
+        if (terminationFunction==null) return null;
+        switch (terminationFunction) {
+            case "ADM" -> {
+                return TerminationFunction.ADMISSIBLE;
+            } case "UC" -> {
+                return TerminationFunction.UNCHALLENGED;
+            } case "CO" -> {
+                return TerminationFunction.COMPLETE;
+            } case "PR" -> {
+                return TerminationFunction.PREFERRED;
+            } case "ST" -> {
+                return TerminationFunction.STABLE;
+            } default -> throw new IllegalArgumentException("unknown selection function " + terminationFunction);
+        }
+    }
+
+    /**
+     * get all available termination functions
+     * @return the termination functions
+     */
+    public static List<String> getTerminationFunction() {
+        return List.of("ADM", "CO", "UC", "PR", "ST");
+    }
+}
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationGetModelsCallee.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationGetModelsCallee.java
new file mode 100644
index 000000000..5505fb4c6
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationGetModelsCallee.java
@@ -0,0 +1,49 @@
+package org.tweetyproject.web.services.serialisation;
+
+import org.tweetyproject.arg.dung.reasoner.SerialisedExtensionReasoner;
+import org.tweetyproject.arg.dung.semantics.Extension;
+import org.tweetyproject.arg.dung.serialisability.syntax.SelectionFunction;
+import org.tweetyproject.arg.dung.serialisability.syntax.TerminationFunction;
+import org.tweetyproject.arg.dung.syntax.DungTheory;
+import org.tweetyproject.web.services.Callee;
+
+import java.util.Collection;
+
+/**
+ * Callee for the getModels operation of the SerialisedExtensionReasoner for the given selection and termination functions
+ */
+public class SerialisationGetModelsCallee extends Callee {
+    /** The DungTheory on which the evaluation is performed */
+    private final DungTheory bbase;
+
+    /** The selection function to use */
+    private final SelectionFunction selectionFunction;
+
+    /** The termination function to use */
+    private final TerminationFunction terminationFunction;
+
+    /**
+     * Constructs a new SerialisationGetModelsCallee with the specified DungTheory and functions.
+     *
+     * @param bbase     The base DungTheory on which the serialisation is performed
+     * @param alpha     The selection function to be used
+     * @param beta      The termination function to be used
+     */
+    public SerialisationGetModelsCallee(DungTheory bbase, SelectionFunction alpha, TerminationFunction beta) {
+        this.bbase = bbase;
+        this.selectionFunction = alpha;
+        this.terminationFunction = beta;
+    }
+
+    /**
+     * Executes the getModels operation using the specified DungTheory the fitting serialised reasoner.
+     *
+     * @return the set of models
+     * @throws Exception If an error occurs during the getModels operation
+     */
+    @Override
+    public Collection<Extension<DungTheory>> call() throws Exception {
+        SerialisedExtensionReasoner reasoner = new SerialisedExtensionReasoner(this.selectionFunction, this.terminationFunction);
+        return reasoner.getModels(this.bbase);
+    }
+}
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationGetReductCallee.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationGetReductCallee.java
new file mode 100644
index 000000000..aff4f6357
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationGetReductCallee.java
@@ -0,0 +1,53 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.serialisation;
+
+import org.tweetyproject.arg.dung.semantics.Extension;
+import org.tweetyproject.arg.dung.syntax.DungTheory;
+import org.tweetyproject.web.services.Callee;
+
+public class SerialisationGetReductCallee extends Callee {
+    /** The Extension used for obtaining the reduct */
+    private final Extension<DungTheory> extension;
+
+    /** The DungTheory on which the getReduct operation is performed */
+    private final DungTheory bbase;
+
+    /**
+     * Constructs a new SerialisationGetReductCallee with the specified DungTheory and Extension.
+     *
+     * @param bbase     The base DungTheory on which the getReduct operation is performed
+     * @param extension The extension by which the getReduct operation is performed
+     */
+    public SerialisationGetReductCallee(DungTheory bbase, Extension<DungTheory> extension) {
+        this.extension = extension;
+        this.bbase = bbase;
+    }
+
+    /**
+     * Executes the getReduct operation using the specified extension and base DungTheory.
+     *
+     * @return The Reduct
+     * @throws Exception If an error occurs during the getReduct operation
+     */
+    @Override
+    public DungTheory call() throws Exception {
+        return this.bbase.getReduct(this.extension);
+    }
+}
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationGetSelectionCallee.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationGetSelectionCallee.java
new file mode 100644
index 000000000..7f2ce26b9
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationGetSelectionCallee.java
@@ -0,0 +1,64 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.serialisation;
+
+import org.tweetyproject.arg.dung.reasoner.SimpleInitialReasoner;
+import org.tweetyproject.arg.dung.semantics.Extension;
+import org.tweetyproject.arg.dung.serialisability.syntax.SelectionFunction;
+import org.tweetyproject.arg.dung.syntax.DungTheory;
+import org.tweetyproject.web.services.Callee;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+
+import static org.tweetyproject.arg.dung.reasoner.SimpleInitialReasoner.Initial.*;
+
+public class SerialisationGetSelectionCallee extends Callee {
+    /** The DungTheory on which the selection function is performed */
+    private final DungTheory bbase;
+
+    /** The selection function to use */
+    private final SelectionFunction selectionFunction;
+
+    /**
+     * Constructs a new SerialisationGetSelectionCallee with the specified DungTheory and Selection function.
+     *
+     * @param bbase     The base DungTheory on which the termination status is checked
+     * @param alpha     The selection function to be used
+     */
+    public SerialisationGetSelectionCallee(DungTheory bbase, SelectionFunction alpha) {
+        this.bbase = bbase;
+        this.selectionFunction = alpha;
+    }
+
+    /**
+     * Executes the getSelection operation using the specified DungTheory and selection function.
+     *
+     * @return the set of selectable initial sets
+     * @throws Exception If an error occurs during the getSelection operation
+     */
+    @Override
+    public Collection<Extension<DungTheory>> call() throws Exception {
+        Map<SimpleInitialReasoner.Initial, Collection<Extension<DungTheory>>> initialSets = SimpleInitialReasoner
+                .partitionInitialSets(this.bbase);
+        return this.selectionFunction.execute(new HashSet<>(initialSets.get(UA)), new HashSet<>(initialSets.get(UC)),
+                new HashSet<>(initialSets.get(C)));
+    }
+}
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationGetSequencesCallee.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationGetSequencesCallee.java
new file mode 100644
index 000000000..09a989181
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationGetSequencesCallee.java
@@ -0,0 +1,56 @@
+package org.tweetyproject.web.services.serialisation;
+
+import org.tweetyproject.arg.dung.reasoner.SerialisedExtensionReasoner;
+import org.tweetyproject.arg.dung.semantics.Extension;
+import org.tweetyproject.arg.dung.serialisability.semantics.SerialisationSequence;
+import org.tweetyproject.arg.dung.serialisability.syntax.SelectionFunction;
+import org.tweetyproject.arg.dung.serialisability.syntax.TerminationFunction;
+import org.tweetyproject.arg.dung.syntax.DungTheory;
+import org.tweetyproject.web.services.Callee;
+
+import java.util.Collection;
+
+/**
+ * Callee for the getSequences operation of the SerialisedExtensionReasoner for the given selection and termination functions
+ */
+public class SerialisationGetSequencesCallee extends Callee {
+    /**
+     * The DungTheory on which the evaluation is performed
+     */
+    private final DungTheory bbase;
+
+    /**
+     * The selection function to use
+     */
+    private final SelectionFunction selectionFunction;
+
+    /**
+     * The termination function to use
+     */
+    private final TerminationFunction terminationFunction;
+
+    /**
+     * Constructs a new SerialisationGetSequencesCallee with the specified DungTheory and functions.
+     *
+     * @param bbase The base DungTheory on which the serialisation is performed
+     * @param alpha The selection function to be used
+     * @param beta  The termination function to be used
+     */
+    public SerialisationGetSequencesCallee(DungTheory bbase, SelectionFunction alpha, TerminationFunction beta) {
+        this.bbase = bbase;
+        this.selectionFunction = alpha;
+        this.terminationFunction = beta;
+    }
+
+    /**
+     * Executes the getSequences operation using the specified DungTheory the fitting serialised reasoner.
+     *
+     * @return the set of sequences
+     * @throws Exception If an error occurs during the getSequences operation
+     */
+    @Override
+    public Collection<SerialisationSequence> call() throws Exception {
+        SerialisedExtensionReasoner reasoner = new SerialisedExtensionReasoner(this.selectionFunction, this.terminationFunction);
+        return reasoner.getSequences(this.bbase);
+    }
+}
\ No newline at end of file
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationInfoResponse.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationInfoResponse.java
new file mode 100644
index 000000000..46a8ea542
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationInfoResponse.java
@@ -0,0 +1,279 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.serialisation;
+
+import java.util.List;
+import java.util.Objects;
+
+import org.tweetyproject.web.services.Response;
+
+
+/**
+ * The SerialisationInfoResponse class extends the Response class and represents
+ * a response containing information about Dung argumentation services.
+ */
+public class SerialisationInfoResponse extends Response {
+
+    /** The reply message in the Serialisation info response */
+    private String reply;
+
+    /** The email associated with the Serialisation info response */
+    private String email;
+
+    /** The backend timeout value specified in the Serialisation info response */
+    private int backend_timeout;
+
+    /** The list of supported selection functions in the Serialisation info response */
+    private List<String> selectionFunctions;
+
+    /** The list of supported termination functions in the Serialisation info response */
+    private List<String> terminationFunctions;
+
+    /** The list of supported commands in the Serialisation info response */
+    private List<String> commands;
+
+    /**
+     * Default constructor for SerialisationInfoResponse.
+     */
+    public SerialisationInfoResponse() {
+    }
+
+    /**
+     * Parameterized constructor for SerialisationInfoResponse.
+     *
+     * @param reply                 The reply message
+     * @param email                 The email associated with the response
+     * @param backend_timeout       The backend timeout value
+     * @param selectionFunctions    The list of supported selection functions
+     * @param terminationFunctions  The list of supported termination functions
+     * @param commands              The list of supported commands
+     */
+    public SerialisationInfoResponse(String reply, String email, int backend_timeout, List<String> selectionFunctions, List<String> terminationFunctions, List<String> commands) {
+        this.reply = reply;
+        this.email = email;
+        this.backend_timeout = backend_timeout;
+        this.selectionFunctions = selectionFunctions;
+        this.terminationFunctions = terminationFunctions;
+        this.commands = commands;
+    }
+
+    /**
+     * Gets the reply message associated with this response.
+     *
+     * @return The current reply message as a string.
+     */
+    public String getReply() {
+        return this.reply;
+    }
+
+    /**
+     * Sets the reply message for this response.
+     *
+     * @param reply The reply message to set.
+     */
+    public void setReply(String reply) {
+        this.reply = reply;
+    }
+
+    /**
+     * Gets the email address associated with this response.
+     *
+     * @return The email address as a string.
+     */
+    public String getEmail() {
+        return this.email;
+    }
+
+    /**
+     * Sets the email address for this response.
+     *
+     * @param email The email address to set.
+     */
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    /**
+     * Gets the backend timeout setting for the service.
+     *
+     * @return The backend timeout in integer form.
+     */
+    public int getBackend_timeout() {
+        return this.backend_timeout;
+    }
+
+    /**
+     * Sets the backend timeout for the service.
+     *
+     * @param backend_timeout The backend timeout value in seconds.
+     */
+    public void setBackend_timeout(int backend_timeout) {
+        this.backend_timeout = backend_timeout;
+    }
+
+    /**
+     * Gets the list of selection functions associated with the service.
+     *
+     * @return A list of selection functions as strings.
+     */
+    public List<String> getSelectionFunctions() {
+        return this.selectionFunctions;
+    }
+
+    /**
+     * Gets the list of termination functions associated with the service.
+     *
+     * @return A list of termination functions as strings.
+     */
+    public List<String> getTerminationFunctions() {
+        return this.terminationFunctions;
+    }
+
+    /**
+     * Gets the list of commands associated with the service.
+     *
+     * @return A list of commands as strings.
+     */
+    public List<String> getCommands() {
+        return this.commands;
+    }
+
+    /**
+     * Sets the list of commands for the service.
+     *
+     * @param commands A list of command strings to be utilized by the service.
+     */
+    public void setCommands(List<String> commands) {
+        this.commands = commands;
+    }
+
+    /**
+     * Sets the list of selectionFunctions for the service.
+     *
+     * @param selectionFunctions A list of command strings to be utilized by the service.
+     */
+    public void setSelectionFunctions(List<String> selectionFunctions) {
+        this.selectionFunctions = selectionFunctions;
+    }
+
+    /**
+     * Sets the list of terminationFunctions for the service.
+     *
+     * @param terminationFunctions A list of command strings to be utilized by the service.
+     */
+    public void setTerminationFunctions(List<String> terminationFunctions) {
+        this.terminationFunctions = terminationFunctions;
+    }
+
+    // Fluent setters
+
+    /**
+     * Sets the reply message and returns this instance for method chaining.
+     *
+     * @param reply The reply message to set.
+     * @return This instance to facilitate further modifications.
+     */
+    public SerialisationInfoResponse reply(String reply) {
+        setReply(reply);
+        return this;
+    }
+
+    /**
+     * Sets the email address and returns this instance for method chaining.
+     *
+     * @param email The email address to set.
+     * @return This instance to facilitate further modifications.
+     */
+    public SerialisationInfoResponse email(String email) {
+        setEmail(email);
+        return this;
+    }
+
+    /**
+     * Sets the backend timeout and returns this instance for method chaining.
+     *
+     * @param backend_timeout The backend timeout in seconds to set.
+     * @return This instance to facilitate further modifications.
+     */
+    public SerialisationInfoResponse backend_timeout(int backend_timeout) {
+        setBackend_timeout(backend_timeout);
+        return this;
+    }
+
+    /**
+     * Sets the selectionFunctions and returns this instance for method chaining.
+     *
+     * @param selectionFunctions A list of selectionFunctions strings to set.
+     * @return This instance to facilitate further modifications.
+     */
+    public SerialisationInfoResponse selectionFunctions(List<String> selectionFunctions) {
+        setSelectionFunctions(selectionFunctions);
+        return this;
+    }
+
+    /**
+     * Sets the terminationFunctions and returns this instance for method chaining.
+     *
+     * @param terminationFunctions A list of terminationFunctions strings to set.
+     * @return This instance to facilitate further modifications.
+     */
+    public SerialisationInfoResponse terminationFunctions(List<String> terminationFunctions) {
+        setTerminationFunctions(terminationFunctions);
+        return this;
+    }
+
+    /**
+     * Sets the commands and returns this instance for method chaining.
+     *
+     * @param commands A list of command strings to set.
+     * @return This instance to facilitate further modifications.
+     */
+    public SerialisationInfoResponse commands(List<String> commands) {
+        setCommands(commands);
+        return this;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof SerialisationInfoResponse)) {
+            return false;
+        }
+        SerialisationInfoResponse infoResponse = (SerialisationInfoResponse) o;
+        return Objects.equals(reply, infoResponse.reply) && Objects.equals(email, infoResponse.email) && backend_timeout == infoResponse.backend_timeout && Objects.equals(selectionFunctions, infoResponse.selectionFunctions) && Objects.equals(terminationFunctions, infoResponse.terminationFunctions) && Objects.equals(commands, infoResponse.commands);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(reply, email, backend_timeout, selectionFunctions, terminationFunctions, commands);
+    }
+
+    @Override
+    public String toString() {
+        return "{" +
+                " reply='" + getReply() + "'" +
+                ", email='" + getEmail() + "'" +
+                ", backend_timeout='" + getBackend_timeout() + "'" +
+                ", selectionFunctions='" + getSelectionFunctions() + "'" +
+                ", terminationFunctions='" + getTerminationFunctions() + "'" +
+                ", commands='" + getCommands() + "'" +
+                "}";
+    }
+}
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationIsTerminalCallee.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationIsTerminalCallee.java
new file mode 100644
index 000000000..b34d24bae
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationIsTerminalCallee.java
@@ -0,0 +1,60 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.serialisation;
+
+import org.tweetyproject.arg.dung.semantics.Extension;
+import org.tweetyproject.arg.dung.serialisability.syntax.TerminationFunction;
+import org.tweetyproject.arg.dung.syntax.DungTheory;
+import org.tweetyproject.web.services.Callee;
+
+public class SerialisationIsTerminalCallee extends Callee {
+
+    /** The Extension used for obtaining the termination status */
+    private final Extension<DungTheory> extension;
+
+    /** The DungTheory on which the termination function is performed */
+    private final DungTheory bbase;
+
+    /** The termination function to use */
+    private final TerminationFunction terminationFunction;
+
+    /**
+     * Constructs a new SerialisationIsTerminalCallee with the specified DungTheory, Extension and Termination function.
+     *
+     * @param bbase     The base DungTheory on which the termination status is checked
+     * @param extension The extension by which the termination function is tested
+     * @param beta      The termination function to be used
+     */
+    public SerialisationIsTerminalCallee(DungTheory bbase, Extension<DungTheory> extension, TerminationFunction beta) {
+        this.bbase = bbase;
+        this.extension = extension;
+        this.terminationFunction = beta;
+    }
+
+    /**
+     * Executes the isTerminal operation using the specified extension and DungTheory by the termination function.
+     *
+     * @return "true" if the given state is terminal
+     * @throws Exception If an error occurs during the isTerminal operation
+     */
+    @Override
+    public Boolean call() throws Exception {
+        return this.terminationFunction.execute(this.bbase, this.extension);
+    }
+}
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationPost.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationPost.java
new file mode 100644
index 000000000..d622b1591
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationPost.java
@@ -0,0 +1,217 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.serialisation;
+
+import java.util.List;
+
+/**
+ * The SerialisationPost class represents a data structure for holding information
+ * related to a serialisation request sent via HTTP POST.
+ */
+public class SerialisationPost {
+
+    /** The command type for the serialisation request */
+    private String cmd;
+
+    /** The email associated with the serialisation request */
+    private String email;
+
+    /** The number of arguments in the serialisation request */
+    private int nr_of_arguments;
+
+    /** The attacks information in the serialisation request */
+    private List<List<Integer>> attacks;
+
+    /** The extension in the serialisation request */
+    private List<Integer> extension;
+
+    /** The selection function specified in the serialisation request */
+    private String selectionFunction;
+
+    /** The termination function specified in the serialisation request */
+    private String terminationFunction;
+
+    /** The timeout value (in seconds) specified in the serialisation request */
+    private int timeout;
+
+    /** The unit timeout value specified in the serialisation request */
+    private String unit_timeout;
+
+    /**
+     * Gets the unit timeout value specified in the serialisation request.
+     *
+     * @return The unit timeout value
+     */
+    public String getUnit_timeout() {
+        return unit_timeout;
+    }
+
+    /**
+     * Sets the unit timeout value in the serialisation request.
+     *
+     * @param unit_timeout The unit timeout value to be set
+     */
+    public void setUnit_timeout(String unit_timeout) {
+        this.unit_timeout = unit_timeout;
+    }
+
+    /**
+     * Gets the command type in the serialisation request.
+     *
+     * @return The command type
+     */
+    public String getCmd() {
+        return this.cmd;
+    }
+
+    /**
+     * Sets the command type in the serialisation request.
+     *
+     * @param cmd The command type to be set
+     */
+    public void setCmd(String cmd) {
+        this.cmd = cmd;
+    }
+
+    /**
+     * Gets the email associated with the serialisation request.
+     *
+     * @return The email associated with the request
+     */
+    public String getEmail() {
+        return this.email;
+    }
+
+    /**
+     * Sets the email associated with the serialisation request.
+     *
+     * @param email The email to be set
+     */
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    /**
+     * Gets the number of arguments in the serialisation request.
+     *
+     * @return The number of arguments
+     */
+    public int getNr_of_arguments() {
+        return this.nr_of_arguments;
+    }
+
+    /**
+     * Sets the number of arguments in the serialisation request.
+     *
+     * @param nr_of_arguments The number of arguments to be set
+     */
+    public void setNr_of_arguments(int nr_of_arguments) {
+        this.nr_of_arguments = nr_of_arguments;
+    }
+
+    /**
+     * Gets the attacks information in the serialisation request.
+     *
+     * @return The attacks information
+     */
+    public List<List<Integer>> getAttacks() {
+        return this.attacks;
+    }
+
+    /**
+     * Sets the attacks information in the serialisation request.
+     *
+     * @param attacks The attacks information to be set
+     */
+    public void setAttacks(List<List<Integer>> attacks) {
+        this.attacks = attacks;
+    }
+
+    /**
+     * Gets the extension in the serialisation request.
+     *
+     * @return The extension
+     */
+    public List<Integer> getExtension() {
+        return this.extension;
+    }
+
+    /**
+     * Sets the extension in the serialisation request.
+     *
+     * @param extension The extension to be set
+     */
+    public void setExtension(List<Integer> extension) {
+        this.extension = extension;
+    }
+
+    /**
+     * Gets the selection function specified in the serialisation request.
+     *
+     * @return The selection function specified
+     */
+    public String getSelectionFunction() {
+        return this.selectionFunction;
+    }
+
+    /**
+     * Sets the selection function in the serialisation request.
+     *
+     * @param selectionFunction The selection function to be set
+     */
+    public void setSelectionFunction(String selectionFunction) {
+        this.selectionFunction = selectionFunction;
+    }
+
+    /**
+     * Gets the termination function specified in the serialisation request.
+     *
+     * @return The termination function specified
+     */
+    public String getTerminationFunction() {
+        return this.terminationFunction;
+    }
+
+    /**
+     * Sets the termination function in the serialisation request.
+     *
+     * @param terminationFunction The termination function to be set
+     */
+    public void setTerminationFunction(String terminationFunction) {
+        this.terminationFunction = terminationFunction;
+    }
+
+    /**
+     * Gets the timeout value (in seconds) specified in the serialisation request.
+     *
+     * @return The timeout value
+     */
+    public int getTimeout() {
+        return this.timeout;
+    }
+
+    /**
+     * Sets the timeout value (in seconds) in the serialisation request.
+     *
+     * @param timeout The timeout value to be set
+     */
+    public void setTimeout(int timeout) {
+        this.timeout = timeout;
+    }
+}
\ No newline at end of file
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationResponse.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationResponse.java
new file mode 100644
index 000000000..6784913c3
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/serialisation/SerialisationResponse.java
@@ -0,0 +1,446 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.serialisation;
+
+import java.util.List;
+import java.util.Objects;
+
+import org.tweetyproject.web.services.Response;
+
+/**
+ * The SerialisationResponse class extends the Response class and represents
+ * a response containing information related to a serialisation
+ * result.
+ */
+public class SerialisationResponse extends Response {
+
+    /** The reply message in the serialisation response */
+    private String reply;
+
+    /** The email associated with the serialisation response */
+    private String email;
+
+    /** The number of arguments in the serialisation response */
+    private int nr_of_arguments;
+
+    /** The attacks information in the serialisation response */
+    private List<List<Integer>> attacks;
+
+    /** The extension in the serialisation response */
+    private List<Integer> extension;
+
+    /** The selection function specified in the serialisation response */
+    private String selectionFunction;
+
+    /** The termination function specified in the serialisation response */
+    private String terminationFunction;
+
+    /** The answer provided by the serialisation response */
+    private String answer;
+
+    /** The time taken for the serialisation operation (in seconds) */
+    private double time;
+
+    /** The unit time specified in the serialisation response */
+    private String unit_time;
+
+    /** The status of the serialisation response */
+    private String status;
+
+    /**
+     * Default constructor for SerialisationResponse.
+     */
+    public SerialisationResponse() {
+    }
+
+    /**
+     * Parameterized constructor for SerialisationResponse.
+     *
+     * @param reply           The reply message
+     * @param email           The email associated with the response
+     * @param nr_of_arguments The number of arguments
+     * @param attacks         The attacks information
+     * @param extension       The extension
+     * @param selectionFunction       The semantics specified
+     * @param terminationFunction          The solver specified
+     * @param answer          The answer provided
+     * @param time            The time taken for the operation
+     * @param unit_time       The unit time specified
+     * @param status          The status of the response
+     */
+    public SerialisationResponse(String reply, String email, int nr_of_arguments, List<List<Integer>> attacks, List<Integer> extension,
+                                 String selectionFunction, String terminationFunction, String answer, double time, String unit_time, String status) {
+        this.reply = reply;
+        this.email = email;
+        this.nr_of_arguments = nr_of_arguments;
+        this.attacks = attacks;
+        this.extension = extension;
+        this.selectionFunction = selectionFunction;
+        this.terminationFunction = terminationFunction;
+        this.answer = answer;
+        this.time = time;
+        this.unit_time = unit_time;
+        this.status = status;
+    }
+
+    /**
+     * Gets the reply message in the serialisation response.
+     *
+     * @return The reply message in the serialisation response.
+     */
+    public String getReply() {
+        return reply;
+    }
+
+    /**
+     * Sets the reply message in the serialisation response.
+     *
+     * @param reply The reply message in the serialisation response.
+     */
+    public void setReply(String reply) {
+        this.reply = reply;
+    }
+
+    /**
+     * Gets the email associated with the serialisation response.
+     *
+     * @return The email associated with the serialisation response.
+     */
+    public String getEmail() {
+        return email;
+    }
+
+    /**
+     * Sets the email associated with the serialisation response.
+     *
+     * @param email The email associated with the serialisation response.
+     */
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    /**
+     * Gets the number of arguments in the serialisation response.
+     *
+     * @return The number of arguments in the serialisation response.
+     */
+    public int getNr_of_arguments() {
+        return nr_of_arguments;
+    }
+
+    /**
+     * Sets the number of arguments in the serialisation response.
+     *
+     * @param nr_of_arguments The number of arguments in the serialisation response.
+     */
+    public void setNr_of_arguments(int nr_of_arguments) {
+        this.nr_of_arguments = nr_of_arguments;
+    }
+
+    /**
+     * Gets the attacks information in the serialisation response.
+     *
+     * @return The attacks information in the serialisation response.
+     */
+    public List<List<Integer>> getAttacks() {
+        return attacks;
+    }
+
+    /**
+     * Sets the attacks information in the serialisation response.
+     *
+     * @param attacks The attacks information in the serialisation response.
+     */
+    public void setAttacks(List<List<Integer>> attacks) {
+        this.attacks = attacks;
+    }
+
+    /**
+     * Gets the extension in the serialisation response.
+     *
+     * @return The extension in the serialisation response.
+     */
+    public List<Integer> getExtension() {
+        return extension;
+    }
+
+    /**
+     * Sets the extension in the serialisation response.
+     *
+     * @param extension The extension in the serialisation response.
+     */
+    public void setExtension(List<Integer> extension) {
+        this.extension = extension;
+    }
+
+    /**
+     * Gets the selection function specified in the serialisation response.
+     *
+     * @return The selection function specified in the serialisation response.
+     */
+    public String getSelectionFunction() {
+        return selectionFunction;
+    }
+
+    /**
+     * Sets the selection function specified in the serialisation response.
+     *
+     * @param selectionFunction The selection function specified in the serialisation response.
+     */
+    public void setSelectionFunction(String selectionFunction) {
+        this.selectionFunction = selectionFunction;
+    }
+
+    /**
+     * Gets the termination function specified in the serialisation response.
+     *
+     * @return The termination function specified in the serialisation response.
+     */
+    public String getTerminationFunction() {
+        return terminationFunction;
+    }
+
+    /**
+     * Sets the termination function specified in the serialisation response.
+     *
+     * @param terminationFunction The termination function specified in the serialisation response.
+     */
+    public void setTerminationFunction(String terminationFunction) {
+        this.terminationFunction = terminationFunction;
+    }
+
+    /**
+     * Gets the answer provided by the serialisation response.
+     *
+     * @return The answer provided by the serialisation response.
+     */
+    public String getAnswer() {
+        return answer;
+    }
+
+    /**
+     * Sets the answer provided by the serialisation response.
+     *
+     * @param answer The answer provided by the serialisation response.
+     */
+    public void setAnswer(String answer) {
+        this.answer = answer;
+    }
+
+    /**
+     * Gets the time taken for the serialisation operation (in seconds).
+     *
+     * @return The time taken for the serialisation operation (in seconds).
+     */
+    public double getTime() {
+        return time;
+    }
+
+    /**
+     * Sets the time taken for the serialisation operation (in seconds).
+     *
+     * @param time The time taken for the serialisation operation (in seconds).
+     */
+    public void setTime(double time) {
+        this.time = time;
+    }
+
+    /**
+     * Gets the unit time specified in the serialisation response.
+     *
+     * @return The unit time specified in the serialisation response.
+     */
+    public String getUnit_time() {
+        return unit_time;
+    }
+
+    /**
+     * Sets the unit time specified in the serialisation response.
+     *
+     * @param unit_time The unit time specified in the serialisation response.
+     */
+    public void setUnit_time(String unit_time) {
+        this.unit_time = unit_time;
+    }
+
+    /**
+     * Gets the status of the serialisation response.
+     *
+     * @return The status of the serialisation response.
+     */
+    public String getStatus() {
+        return status;
+    }
+
+    /**
+     * Sets the status of the serialisation response.
+     *
+     * @param status The status of the serialisation response.
+     */
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    /**
+     * Sets the reply message in the serialisation response.
+     *
+     * @param reply The reply message in the serialisation response.
+     * @return The current instance of SerialisationResponse.
+     */
+    public SerialisationResponse reply(String reply) {
+        setReply(reply);
+        return this;
+    }
+
+    /**
+     * Sets the email associated with the serialisation response.
+     *
+     * @param email The email associated with the serialisation response.
+     * @return The current instance of SerialisationResponse.
+     */
+    public SerialisationResponse email(String email) {
+        setEmail(email);
+        return this;
+    }
+
+    /**
+     * Sets the number of arguments in the serialisation response.
+     *
+     * @param nr_of_arguments The number of arguments in the serialisation response.
+     * @return The current instance of SerialisationResponse.
+     */
+    public SerialisationResponse nr_of_arguments(int nr_of_arguments) {
+        setNr_of_arguments(nr_of_arguments);
+        return this;
+    }
+
+    /**
+     * Sets the attacks information in the serialisation response.
+     *
+     * @param attacks The attacks information in the serialisation response.
+     * @return The current instance of SerialisationResponse.
+     */
+    public SerialisationResponse attacks(List<List<Integer>> attacks) {
+        setAttacks(attacks);
+        return this;
+    }
+
+    /**
+     * Sets the extension in the serialisation response.
+     *
+     * @param extension The extension in the serialisation response.
+     * @return The current instance of SerialisationResponse.
+     */
+    public SerialisationResponse extension(List<Integer> extension) {
+        setExtension(extension);
+        return this;
+    }
+
+    /**
+     * Sets the selection function specified in the serialisation response.
+     *
+     * @param selectionFunction The selection function specified in the serialisation response.
+     * @return The current instance of SerialisationResponse.
+     */
+    public SerialisationResponse selectionFunction(String selectionFunction) {
+        setSelectionFunction(selectionFunction);
+        return this;
+    }
+
+    /**
+     * Sets the termination function specified in the serialisation response.
+     *
+     * @param terminationFunction The termination function specified in the serialisation response.
+     * @return The current instance of SerialisationResponse.
+     */
+    public SerialisationResponse terminationFunction(String terminationFunction) {
+        setTerminationFunction(terminationFunction);
+        return this;
+    }
+
+    /**
+     * Sets the answer provided by the serialisation response.
+     *
+     * @param answer The answer provided by the serialisation response.
+     * @return The current instance of SerialisationResponse.
+     */
+    public SerialisationResponse answer(String answer) {
+        setAnswer(answer);
+        return this;
+    }
+
+    /**
+     * Sets the time taken for the serialisation operation (in seconds).
+     *
+     * @param time The time taken for the serialisation operation (in seconds).
+     * @return The current instance of SerialisationResponse.
+     */
+    public SerialisationResponse time(int time) {
+        setTime(time);
+        return this;
+    }
+
+    /**
+     * Sets the status of the serialisation response.
+     *
+     * @param status The status of the serialisation response.
+     * @return The current instance of SerialisationResponse.
+     */
+    public SerialisationResponse status(String status) {
+        setStatus(status);
+        return this;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof SerialisationResponse)) {
+            return false;
+        }
+        SerialisationResponse tweetyResponse = (SerialisationResponse) o;
+        return Objects.equals(reply, tweetyResponse.reply) && Objects.equals(email, tweetyResponse.email)
+                && nr_of_arguments == tweetyResponse.nr_of_arguments && Objects.equals(attacks, tweetyResponse.attacks) && Objects.equals(extension, tweetyResponse.extension)
+                && Objects.equals(selectionFunction, tweetyResponse.selectionFunction) && Objects.equals(terminationFunction, tweetyResponse.terminationFunction)
+                && Objects.equals(answer, tweetyResponse.answer) && time == tweetyResponse.time
+                && Objects.equals(status, tweetyResponse.status);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(reply, email, nr_of_arguments, attacks, selectionFunction, terminationFunction, answer, time, status);
+    }
+
+    @Override
+    public String toString() {
+        return "{" +
+                " reply='" + getReply() + "'" +
+                ", email='" + getEmail() + "'" +
+                ", nr_of_arguments='" + getNr_of_arguments() + "'" +
+                ", attacks='" + getAttacks() + "'" +
+                ", extension='" + getExtension() + "'" +
+                ", selectionFunction='" + getSelectionFunction() + "'" +
+                ", terminationFunction='" + getTerminationFunction() + "'" +
+                ", answer='" + getAnswer() + "'" +
+                ", time='" + getTime() + "'" +
+                ", status='" + getStatus() + "'" +
+                "}";
+    }
+
+}
\ No newline at end of file
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/AbstractSetAfFactory.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/AbstractSetAfFactory.java
new file mode 100644
index 000000000..33b913207
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/AbstractSetAfFactory.java
@@ -0,0 +1,84 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2024 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.setaf;
+
+import org.tweetyproject.arg.dung.reasoner.AbstractExtensionReasoner;
+import org.tweetyproject.arg.dung.semantics.Semantics;
+import org.tweetyproject.arg.dung.syntax.Argument;
+import org.tweetyproject.arg.setaf.reasoners.AbstractSetAfExtensionReasoner;
+import org.tweetyproject.arg.setaf.reasoners.ReductionBasedSetAfReasoner;
+import org.tweetyproject.arg.setaf.syntax.SetAf;
+
+import java.util.*;
+
+/**
+ * Main factory for retrieving SetAF extension reasoners.
+ * 
+ * @author Lars Bengel
+ */
+public abstract class AbstractSetAfFactory {
+	/**
+	 * Returns an array of all available semantics.
+	 *
+	 * @return An array of all available semantics.
+	 */
+	public static Semantics[] getSemantics() {
+		return Semantics.values();
+	}
+
+	/**
+	 * Creates a new reasoner of the given semantics with default
+	 * settings.
+	 * 
+	 * @param sem some identifier of a semantics.
+	 * @return the requested reasoner.
+	 */
+	public static AbstractSetAfExtensionReasoner getReasoner(Semantics sem) {
+		return new ReductionBasedSetAfReasoner(AbstractExtensionReasoner.getSimpleReasonerForSemantics(sem));
+	}
+
+    /**
+     * Creates a SetAF from the given number of arguments and attack relations.
+     *
+     * @param nr_of_arguments The number of arguments in the SetAF.
+     * @param attacks         The binary attack relations represented as a list of lists of integers.
+     * @return A DungTheory constructed from the given arguments and attacks.
+     */
+    public static SetAf getSetAf(int nr_of_arguments, List<List<Integer>> attacks) {
+        List<Argument> arguments = new ArrayList<Argument>();
+		SetAf theory = new SetAf();
+        for (int i = 1; i <= nr_of_arguments; i++){
+            arguments.add(new Argument(Integer.toString(i)));
+        }
+		theory.addAll(arguments);
+
+		for (List<Integer> list : attacks) {
+			if (list.size() == 2) {
+				theory.addAttack(arguments.get(list.get(0) - 1),arguments.get(list.get(1) - 1));
+			} else {
+				Set<Argument> attackers = new HashSet<>();
+				for (int i = 0; i < list.size() - 1; i++) {
+					attackers.add(arguments.get(list.get(i) - 1));
+				}
+				theory.addSetAttack(attackers, arguments.get(list.get(list.size() - 1) - 1));
+			}
+		}
+        return theory;
+    }
+}
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerCalleeFactory.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerCalleeFactory.java
new file mode 100644
index 000000000..05672472d
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerCalleeFactory.java
@@ -0,0 +1,106 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2016 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.setaf;
+
+import org.tweetyproject.arg.setaf.reasoners.AbstractSetAfExtensionReasoner;
+import org.tweetyproject.arg.setaf.syntax.SetAf;
+import org.tweetyproject.commons.InferenceMode;
+import org.tweetyproject.web.services.Callee;
+
+
+/**
+ * The SetAfReasonerCalleeFactory class is responsible for creating instances of Callee
+ * based on the specified Command, AbstractExtensionReasoner, and SetAF parameters.
+ * It also defines an enumeration of commands with associated IDs and labels.
+ */
+public class SetAfReasonerCalleeFactory {
+
+    /**
+     * Enumeration of commands supported by the factory, each with a unique ID and label.
+     */
+    public enum Command {
+        /** get models */
+        GET_MODELS("get_models", "Get all models"),
+        /** get credulously acceptable arguments */
+        GET_CREDULOUS("get_credulous", "Get credulous arguments"),
+        /** get skeptically acceptable arguments */
+        GET_SKEPTICAL("get_skeptical", "Get skeptical arguments");
+
+        /** ID of the command */
+        public String id;
+        /** Label of the command */
+        public String label;
+
+        /**
+         * Constructor for Command enum.
+         *
+         * @param id    ID of the command
+         * @param label Label of the command
+         */
+        Command(String id, String label) {
+            this.id = id;
+            this.label = label;
+        }
+
+        /**
+         * Retrieves the Command enum based on the provided ID.
+         *
+         * @param id ID of the command
+         * @return The corresponding Command enum, or null if not found
+         */
+        public static Command getCommand(String id) {
+            for (Command m : Command.values())
+                if (m.id.equals(id))
+                    return m;
+            return null;
+        }
+    }
+
+    /**
+     * Retrieves an array of all available Command enums.
+     *
+     * @return An array of Command enums
+     */
+    public static Command[] getCommands() {
+        return Command.values();
+    }
+
+    /**
+     * Creates and returns a Callee instance based on the provided Command, AbstractSetAfExtensionReasoner,
+     * and SetAf parameters.
+     *
+     * @param cmd      The command to be executed
+     * @param reasoner The AbstractSetAfExtensionReasoner to be used
+     * @param bbase    The SetAf to be processed
+     * @return A Callee instance corresponding to the specified command
+     * @throws RuntimeException If the specified command is not found
+     */
+    public static Callee getCallee(Command cmd, AbstractSetAfExtensionReasoner reasoner, SetAf bbase) {
+        switch (cmd) {
+            case GET_MODELS:
+                return new SetAfReasonerGetModelsCallee(reasoner, bbase);
+            case GET_CREDULOUS:
+                return new SetAfReasonerQueryAllCallee(reasoner, bbase, InferenceMode.CREDULOUS);
+            case GET_SKEPTICAL:
+                return new SetAfReasonerQueryAllCallee(reasoner, bbase, InferenceMode.SKEPTICAL);
+            default:
+                throw new RuntimeException("Command not found: " + cmd.toString());
+        }
+    }
+}
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerGetModelsCallee.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerGetModelsCallee.java
new file mode 100644
index 000000000..46b8d292b
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerGetModelsCallee.java
@@ -0,0 +1,65 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2016 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.setaf;
+
+import org.tweetyproject.arg.dung.reasoner.AbstractExtensionReasoner;
+import org.tweetyproject.arg.dung.semantics.Extension;
+import org.tweetyproject.arg.setaf.reasoners.AbstractSetAfExtensionReasoner;
+import org.tweetyproject.arg.setaf.syntax.SetAf;
+import org.tweetyproject.web.services.Callee;
+
+import java.util.Collection;
+
+/**
+ * The SetAfReasonerGetModelsCallee class represents a callee for obtaining multiple models
+ * using a specified AbstractSetAfExtensionReasoner and SetAf.
+ *
+ * This class extends the Callee class and implements the call() method to execute
+ * the getModels operation using the provided reasoner and base SetAf.
+ */
+public class SetAfReasonerGetModelsCallee extends Callee {
+
+    /** The AbstractSetAfExtensionReasoner used for obtaining multiple models */
+    private AbstractSetAfExtensionReasoner reasoner;
+
+    /** The SetAf on which the getModels operation is performed */
+    private SetAf bbase;
+
+    /**
+     * Constructs a new SetAfReasonerGetModelsCallee with the specified reasoner and base SetAf.
+     *
+     * @param reasoner The AbstractSetAfExtensionReasoner to be used for obtaining multiple models
+     * @param bbase    The base SetAf on which the getModels operation is performed
+     */
+    public SetAfReasonerGetModelsCallee(AbstractSetAfExtensionReasoner reasoner, SetAf bbase) {
+        this.reasoner = reasoner;
+        this.bbase = bbase;
+    }
+
+    /**
+     * Executes the getModels operation using the specified reasoner and base SetAf.
+     *
+     * @return A collection of Extensions representing the obtained models
+     * @throws Exception If an error occurs during the getModels operation
+     */
+    @Override
+    public Collection<Extension<SetAf>> call() throws Exception {
+        return this.reasoner.getModels(this.bbase);
+    }
+}
\ No newline at end of file
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerPost.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerPost.java
new file mode 100644
index 000000000..fcc762ad2
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerPost.java
@@ -0,0 +1,196 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2016 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.setaf;
+
+import java.util.List;
+
+/**
+ * The SetAfReasonerPost class represents a data structure for holding information
+ * related to a SetAf argumentation reasoner request sent via HTTP POST.
+ */
+public class SetAfReasonerPost {
+
+  /** The command type for the SetAf reasoner request */
+  private String cmd;
+
+  /** The email associated with the SetAf reasoner request */
+  private String email;
+
+  /** The number of arguments in the SetAf reasoner request */
+  private int nr_of_arguments;
+
+  /** The attacks information in the SetAf reasoner request */
+  private List<List<Integer>> attacks;
+
+  /** The semantics specified in the SetAf reasoner request */
+  private String semantics;
+
+  /** The solver specified in the SetAf reasoner request */
+  private String solver;
+
+  /** The timeout value (in seconds) specified in the SetAf reasoner request */
+  private int timeout;
+
+  /** The unit timeout value specified in the SetAf reasoner request */
+  private String unit_timeout;
+
+  /**
+   * Gets the unit timeout value specified in the SetAf reasoner request.
+   *
+   * @return The unit timeout value
+   */
+  public String getUnit_timeout() {
+      return unit_timeout;
+  }
+
+  /**
+   * Sets the unit timeout value in the SetAf reasoner request.
+   *
+   * @param unit_timeout The unit timeout value to be set
+   */
+  public void setUnit_timeout(String unit_timeout) {
+      this.unit_timeout = unit_timeout;
+  }
+
+  /**
+   * Gets the command type in the SetAf reasoner request.
+   *
+   * @return The command type
+   */
+  public String getCmd() {
+      return this.cmd;
+  }
+
+  /**
+   * Sets the command type in the SetAf reasoner request.
+   *
+   * @param cmd The command type to be set
+   */
+  public void setCmd(String cmd) {
+      this.cmd = cmd;
+  }
+
+  /**
+   * Gets the email associated with the SetAf reasoner request.
+   *
+   * @return The email associated with the request
+   */
+  public String getEmail() {
+      return this.email;
+  }
+
+  /**
+   * Sets the email associated with the SetAf reasoner request.
+   *
+   * @param email The email to be set
+   */
+  public void setEmail(String email) {
+      this.email = email;
+  }
+
+  /**
+   * Gets the number of arguments in the SetAf reasoner request.
+   *
+   * @return The number of arguments
+   */
+  public int getNr_of_arguments() {
+      return this.nr_of_arguments;
+  }
+
+  /**
+   * Sets the number of arguments in the SetAf reasoner request.
+   *
+   * @param nr_of_arguments The number of arguments to be set
+   */
+  public void setNr_of_arguments(int nr_of_arguments) {
+      this.nr_of_arguments = nr_of_arguments;
+  }
+
+  /**
+   * Gets the attacks information in the SetAf reasoner request.
+   *
+   * @return The attacks information
+   */
+  public List<List<Integer>> getAttacks() {
+      return this.attacks;
+  }
+
+  /**
+   * Sets the attacks information in the SetAf reasoner request.
+   *
+   * @param attacks The attacks information to be set
+   */
+  public void setAttacks(List<List<Integer>> attacks) {
+      this.attacks = attacks;
+  }
+
+  /**
+   * Gets the semantics specified in the SetAf reasoner request.
+   *
+   * @return The semantics specified
+   */
+  public String getSemantics() {
+      return this.semantics;
+  }
+
+  /**
+   * Sets the semantics in the SetAf reasoner request.
+   *
+   * @param semantics The semantics to be set
+   */
+  public void setSemantics(String semantics) {
+      this.semantics = semantics;
+  }
+
+  /**
+   * Gets the solver specified in the SetAf reasoner request.
+   *
+   * @return The solver specified
+   */
+  public String getSolver() {
+      return this.solver;
+  }
+
+  /**
+   * Sets the solver in the SetAf reasoner request.
+   *
+   * @param solver The solver to be set
+   */
+  public void setSolver(String solver) {
+      this.solver = solver;
+  }
+
+  /**
+   * Gets the timeout value (in seconds) specified in the SetAf reasoner request.
+   *
+   * @return The timeout value
+   */
+  public int getTimeout() {
+      return this.timeout;
+  }
+
+  /**
+   * Sets the timeout value (in seconds) in the SetAf reasoner request.
+   *
+   * @param timeout The timeout value to be set
+   */
+  public void setTimeout(int timeout) {
+      this.timeout = timeout;
+  }
+}
\ No newline at end of file
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerQueryAllCallee.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerQueryAllCallee.java
new file mode 100644
index 000000000..73db2f6d1
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerQueryAllCallee.java
@@ -0,0 +1,73 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.setaf;
+
+import org.tweetyproject.arg.dung.semantics.Extension;
+import org.tweetyproject.arg.dung.syntax.Argument;
+import org.tweetyproject.arg.setaf.reasoners.AbstractSetAfExtensionReasoner;
+import org.tweetyproject.arg.setaf.syntax.SetAf;
+import org.tweetyproject.commons.InferenceMode;
+import org.tweetyproject.web.services.Callee;
+
+import java.util.Collection;
+
+/**
+ * The SetAfReasonerQueryAllCallee class represents a callee for obtaining the credulous/skeptical arguments
+ * using a specified AbstractSetAfExtensionReasoner and SetAf.
+ *
+ * This class extends the Callee class and implements the call() method to execute
+ * the getModel operation using the provided reasoner and base SetAf.
+ *
+ * @author Lars Bengel
+ */
+public class SetAfReasonerQueryAllCallee extends Callee {
+
+    /** The AbstractSetAfExtensionReasoner used for obtaining the model */
+    private final AbstractSetAfExtensionReasoner reasoner;
+
+    /** The SetAf on which the queryAll operation is performed */
+    private final SetAf bbase;
+
+    /** the inference mode */
+    private final InferenceMode mode;
+
+    /**
+     * Constructs a new SetAfReasonerQueryAllCallee with the specified reasoner and base SetAf.
+     *
+     * @param reasoner The AbstractSetAfExtensionReasoner to be used for obtaining the model
+     * @param bbase    The base SetAf on which the getModel operation is performed
+     * @param mode     The inference mode
+     */
+    public SetAfReasonerQueryAllCallee(AbstractSetAfExtensionReasoner reasoner, SetAf bbase, InferenceMode mode) {
+        this.reasoner = reasoner;
+        this.bbase = bbase;
+        this.mode = mode;
+    }
+
+    /**
+     * Executes the queryAll operation using the specified reasoner and base SetAf.
+     *
+     * @return An Extension representing the obtained model
+     * @throws Exception If an error occurs during the queryAll operation
+     */
+    @Override
+    public Collection<Argument> call() throws Exception {
+        return new Extension<>(this.reasoner.queryAll(bbase, mode));
+    }
+}
\ No newline at end of file
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerResponse.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerResponse.java
new file mode 100644
index 000000000..195d3abbc
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfReasonerResponse.java
@@ -0,0 +1,411 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2016 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.setaf;
+
+import org.tweetyproject.web.services.Response;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * The DungReasonerResponse class extends the Response class and represents
+ * a response containing information related to a Dung argumentation reasoner
+ * result.
+ */
+public class SetAfReasonerResponse extends Response {
+
+    /** The reply message in the Dung reasoner response */
+    private String reply;
+
+    /** The email associated with the Dung reasoner response */
+    private String email;
+
+    /** The number of arguments in the Dung reasoner response */
+    private int nr_of_arguments;
+
+    /** The attacks information in the Dung reasoner response */
+    private List<List<Integer>> attacks;
+
+    /** The semantics specified in the Dung reasoner response */
+    private String semantics;
+
+    /** The solver specified in the Dung reasoner response */
+    private String solver;
+
+    /** The answer provided by the Dung reasoner response */
+    private String answer;
+
+    /** The time taken for the Dung reasoner operation (in seconds) */
+    private double time;
+
+    /** The unit time specified in the Dung reasoner response */
+    private String unit_time;
+
+    /** The status of the Dung reasoner response */
+    private String status;
+
+    /**
+     * Default constructor for DungReasonerResponse.
+     */
+    public SetAfReasonerResponse() {
+    }
+
+    /**
+     * Parameterized constructor for DungReasonerResponse.
+     *
+     * @param reply           The reply message
+     * @param email           The email associated with the response
+     * @param nr_of_arguments The number of arguments
+     * @param attacks         The attacks information
+     * @param semantics       The semantics specified
+     * @param solver          The solver specified
+     * @param answer          The answer provided
+     * @param time            The time taken for the operation
+     * @param unit_time       The unit time specified
+     * @param status          The status of the response
+     */
+    public SetAfReasonerResponse(String reply, String email, int nr_of_arguments, List<List<Integer>> attacks,
+                                 String semantics, String solver, String answer, double time, String unit_time, String status) {
+        this.reply = reply;
+        this.email = email;
+        this.nr_of_arguments = nr_of_arguments;
+        this.attacks = attacks;
+        this.semantics = semantics;
+        this.solver = solver;
+        this.answer = answer;
+        this.time = time;
+        this.unit_time = unit_time;
+        this.status = status;
+    }
+
+    /**
+     * Gets the reply message in the Dung reasoner response.
+     *
+     * @return The reply message in the Dung reasoner response.
+     */
+    public String getReply() {
+        return reply;
+    }
+
+    /**
+     * Sets the reply message in the Dung reasoner response.
+     *
+     * @param reply The reply message in the Dung reasoner response.
+     */
+    public void setReply(String reply) {
+        this.reply = reply;
+    }
+
+    /**
+     * Gets the email associated with the Dung reasoner response.
+     *
+     * @return The email associated with the Dung reasoner response.
+     */
+    public String getEmail() {
+        return email;
+    }
+
+    /**
+     * Sets the email associated with the Dung reasoner response.
+     *
+     * @param email The email associated with the Dung reasoner response.
+     */
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    /**
+     * Gets the number of arguments in the Dung reasoner response.
+     *
+     * @return The number of arguments in the Dung reasoner response.
+     */
+    public int getNr_of_arguments() {
+        return nr_of_arguments;
+    }
+
+    /**
+     * Sets the number of arguments in the Dung reasoner response.
+     *
+     * @param nr_of_arguments The number of arguments in the Dung reasoner response.
+     */
+    public void setNr_of_arguments(int nr_of_arguments) {
+        this.nr_of_arguments = nr_of_arguments;
+    }
+
+    /**
+     * Gets the attacks information in the Dung reasoner response.
+     *
+     * @return The attacks information in the Dung reasoner response.
+     */
+    public List<List<Integer>> getAttacks() {
+        return attacks;
+    }
+
+    /**
+     * Sets the attacks information in the Dung reasoner response.
+     *
+     * @param attacks The attacks information in the Dung reasoner response.
+     */
+    public void setAttacks(List<List<Integer>> attacks) {
+        this.attacks = attacks;
+    }
+
+    /**
+     * Gets the semantics specified in the Dung reasoner response.
+     *
+     * @return The semantics specified in the Dung reasoner response.
+     */
+    public String getSemantics() {
+        return semantics;
+    }
+
+    /**
+     * Sets the semantics specified in the Dung reasoner response.
+     *
+     * @param semantics The semantics specified in the Dung reasoner response.
+     */
+    public void setSemantics(String semantics) {
+        this.semantics = semantics;
+    }
+
+    /**
+     * Gets the solver specified in the Dung reasoner response.
+     *
+     * @return The solver specified in the Dung reasoner response.
+     */
+    public String getSolver() {
+        return solver;
+    }
+
+    /**
+     * Sets the solver specified in the Dung reasoner response.
+     *
+     * @param solver The solver specified in the Dung reasoner response.
+     */
+    public void setSolver(String solver) {
+        this.solver = solver;
+    }
+
+    /**
+     * Gets the answer provided by the Dung reasoner response.
+     *
+     * @return The answer provided by the Dung reasoner response.
+     */
+    public String getAnswer() {
+        return answer;
+    }
+
+    /**
+     * Sets the answer provided by the Dung reasoner response.
+     *
+     * @param answer The answer provided by the Dung reasoner response.
+     */
+    public void setAnswer(String answer) {
+        this.answer = answer;
+    }
+
+    /**
+     * Gets the time taken for the Dung reasoner operation (in seconds).
+     *
+     * @return The time taken for the Dung reasoner operation (in seconds).
+     */
+    public double getTime() {
+        return time;
+    }
+
+    /**
+     * Sets the time taken for the Dung reasoner operation (in seconds).
+     *
+     * @param time The time taken for the Dung reasoner operation (in seconds).
+     */
+    public void setTime(double time) {
+        this.time = time;
+    }
+
+    /**
+     * Gets the unit time specified in the Dung reasoner response.
+     *
+     * @return The unit time specified in the Dung reasoner response.
+     */
+    public String getUnit_time() {
+        return unit_time;
+    }
+
+    /**
+     * Sets the unit time specified in the Dung reasoner response.
+     *
+     * @param unit_time The unit time specified in the Dung reasoner response.
+     */
+    public void setUnit_time(String unit_time) {
+        this.unit_time = unit_time;
+    }
+
+    /**
+     * Gets the status of the Dung reasoner response.
+     *
+     * @return The status of the Dung reasoner response.
+     */
+    public String getStatus() {
+        return status;
+    }
+
+    /**
+     * Sets the status of the Dung reasoner response.
+     *
+     * @param status The status of the Dung reasoner response.
+     */
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    /**
+     * Sets the reply message in the Dung reasoner response.
+     *
+     * @param reply The reply message in the Dung reasoner response.
+     * @return The current instance of DungReasonerResponse.
+     */
+    public SetAfReasonerResponse reply(String reply) {
+        setReply(reply);
+        return this;
+    }
+
+    /**
+     * Sets the email associated with the Dung reasoner response.
+     *
+     * @param email The email associated with the Dung reasoner response.
+     * @return The current instance of DungReasonerResponse.
+     */
+    public SetAfReasonerResponse email(String email) {
+        setEmail(email);
+        return this;
+    }
+
+    /**
+     * Sets the number of arguments in the Dung reasoner response.
+     *
+     * @param nr_of_arguments The number of arguments in the Dung reasoner response.
+     * @return The current instance of DungReasonerResponse.
+     */
+    public SetAfReasonerResponse nr_of_arguments(int nr_of_arguments) {
+        setNr_of_arguments(nr_of_arguments);
+        return this;
+    }
+
+    /**
+     * Sets the attacks information in the Dung reasoner response.
+     *
+     * @param attacks The attacks information in the Dung reasoner response.
+     * @return The current instance of DungReasonerResponse.
+     */
+    public SetAfReasonerResponse attacks(List<List<Integer>> attacks) {
+        setAttacks(attacks);
+        return this;
+    }
+
+    /**
+     * Sets the semantics specified in the Dung reasoner response.
+     *
+     * @param semantics The semantics specified in the Dung reasoner response.
+     * @return The current instance of DungReasonerResponse.
+     */
+    public SetAfReasonerResponse semantics(String semantics) {
+        setSemantics(semantics);
+        return this;
+    }
+
+    /**
+     * Sets the solver specified in the Dung reasoner response.
+     *
+     * @param solver The solver specified in the Dung reasoner response.
+     * @return The current instance of DungReasonerResponse.
+     */
+    public SetAfReasonerResponse solver(String solver) {
+        setSolver(solver);
+        return this;
+    }
+
+    /**
+     * Sets the answer provided by the Dung reasoner response.
+     *
+     * @param answer The answer provided by the Dung reasoner response.
+     * @return The current instance of DungReasonerResponse.
+     */
+    public SetAfReasonerResponse answer(String answer) {
+        setAnswer(answer);
+        return this;
+    }
+
+    /**
+     * Sets the time taken for the Dung reasoner operation (in seconds).
+     *
+     * @param time The time taken for the Dung reasoner operation (in seconds).
+     * @return The current instance of DungReasonerResponse.
+     */
+    public SetAfReasonerResponse time(int time) {
+        setTime(time);
+        return this;
+    }
+
+    /**
+     * Sets the status of the Dung reasoner response.
+     *
+     * @param status The status of the Dung reasoner response.
+     * @return The current instance of DungReasonerResponse.
+     */
+    public SetAfReasonerResponse status(String status) {
+        setStatus(status);
+        return this;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof SetAfReasonerResponse)) {
+            return false;
+        }
+        SetAfReasonerResponse tweetyResponse = (SetAfReasonerResponse) o;
+        return Objects.equals(reply, tweetyResponse.reply) && Objects.equals(email, tweetyResponse.email)
+                && nr_of_arguments == tweetyResponse.nr_of_arguments && Objects.equals(attacks, tweetyResponse.attacks)
+                && Objects.equals(semantics, tweetyResponse.semantics) && Objects.equals(solver, tweetyResponse.solver)
+                && Objects.equals(answer, tweetyResponse.answer) && time == tweetyResponse.time
+                && Objects.equals(status, tweetyResponse.status);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(reply, email, nr_of_arguments, attacks, semantics, solver, answer, time, status);
+    }
+
+    @Override
+    public String toString() {
+        return "{" +
+                " reply='" + getReply() + "'" +
+                ", email='" + getEmail() + "'" +
+                ", nr_of_arguments='" + getNr_of_arguments() + "'" +
+                ", attacks='" + getAttacks() + "'" +
+                ", semantics='" + getSemantics() + "'" +
+                ", solver='" + getSolver() + "'" +
+                ", answer='" + getAnswer() + "'" +
+                ", time='" + getTime() + "'" +
+                ", status='" + getStatus() + "'" +
+                "}";
+    }
+
+}
\ No newline at end of file
diff --git a/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfServicesInfoResponse.java b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfServicesInfoResponse.java
new file mode 100644
index 000000000..239837863
--- /dev/null
+++ b/org-tweetyproject-web/src/main/java/org/tweetyproject/web/services/setaf/SetAfServicesInfoResponse.java
@@ -0,0 +1,244 @@
+/*
+ *  This file is part of "TweetyProject", a collection of Java libraries for
+ *  logical aspects of artificial intelligence and knowledge representation.
+ *
+ *  TweetyProject is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License version 3 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2016 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services.setaf;
+
+import org.tweetyproject.web.services.Response;
+
+import java.util.List;
+import java.util.Objects;
+
+
+/**
+ * The DungServicesInfoResponse class extends the Response class and represents
+ * a response containing information about Dung argumentation services.
+ */
+public class SetAfServicesInfoResponse extends Response {
+
+    /** The reply message in the Dung services info response */
+    private String reply;
+
+    /** The email associated with the Dung services info response */
+    private String email;
+
+    /** The backend timeout value specified in the Dung services info response */
+    private int backend_timeout;
+
+    /** The list of supported semantics in the Dung services info response */
+    private List<String> semantics;
+
+    /** The list of supported commands in the Dung services info response */
+    private List<String> commands;
+
+    /**
+     * Default constructor for DungServicesInfoResponse.
+     */
+    public SetAfServicesInfoResponse() {
+    }
+
+    /**
+     * Parameterized constructor for DungServicesInfoResponse.
+     *
+     * @param reply           The reply message
+     * @param email           The email associated with the response
+     * @param backend_timeout The backend timeout value
+     * @param semantics       The list of supported semantics
+     * @param commands        The list of supported commands
+     */
+    public SetAfServicesInfoResponse(String reply, String email, int backend_timeout, List<String> semantics, List<String> commands) {
+        this.reply = reply;
+        this.email = email;
+        this.backend_timeout = backend_timeout;
+        this.semantics = semantics;
+        this.commands = commands;
+    }
+
+    /** 
+     * Gets the reply message associated with this response.
+     *
+     * @return The current reply message as a string.
+     */
+    public String getReply() {
+        return this.reply;
+    }
+
+    /**
+     * Sets the reply message for this response.
+     *
+     * @param reply The reply message to set.
+     */
+    public void setReply(String reply) {
+        this.reply = reply;
+    }
+
+    /**
+     * Gets the email address associated with this response.
+     *
+     * @return The email address as a string.
+     */
+    public String getEmail() {
+        return this.email;
+    }
+
+    /**
+     * Sets the email address for this response.
+     *
+     * @param email The email address to set.
+     */
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    /**
+     * Gets the backend timeout setting for the service.
+     *
+     * @return The backend timeout in integer form.
+     */
+    public int getBackend_timeout() {
+        return this.backend_timeout;
+    }
+
+    /**
+     * Sets the backend timeout for the service.
+     *
+     * @param backend_timeout The backend timeout value in seconds.
+     */
+    public void setBackend_timeout(int backend_timeout) {
+        this.backend_timeout = backend_timeout;
+    }
+
+    /**
+     * Gets the list of semantic elements associated with the service.
+     *
+     * @return A list of semantics as strings.
+     */
+    public List<String> getSemantics() {
+        return this.semantics;
+    }
+
+    /**
+     * Sets the list of semantic elements for the service.
+     *
+     * @param semantics A list of semantic strings to be used or defined by the service.
+     */
+    public void setSemantics(List<String> semantics) {
+        this.semantics = semantics;
+    }
+
+    /**
+     * Gets the list of commands associated with the service.
+     *
+     * @return A list of commands as strings.
+     */
+    public List<String> getCommands() {
+        return this.commands;
+    }
+
+    /**
+     * Sets the list of commands for the service.
+     *
+     * @param commands A list of command strings to be utilized by the service.
+     */
+    public void setCommands(List<String> commands) {
+        this.commands = commands;
+    }
+
+    // Fluent setters
+
+    /**
+     * Sets the reply message and returns this instance for method chaining.
+     *
+     * @param reply The reply message to set.
+     * @return This instance to facilitate further modifications.
+     */
+    public SetAfServicesInfoResponse reply(String reply) {
+        setReply(reply);
+        return this;
+    }
+
+    /**
+     * Sets the email address and returns this instance for method chaining.
+     *
+     * @param email The email address to set.
+     * @return This instance to facilitate further modifications.
+     */
+    public SetAfServicesInfoResponse email(String email) {
+        setEmail(email);
+        return this;
+    }
+
+    /**
+     * Sets the backend timeout and returns this instance for method chaining.
+     *
+     * @param backend_timeout The backend timeout in seconds to set.
+     * @return This instance to facilitate further modifications.
+     */
+    public SetAfServicesInfoResponse backend_timeout(int backend_timeout) {
+        setBackend_timeout(backend_timeout);
+        return this;
+    }
+
+    /**
+     * Sets the semantics and returns this instance for method chaining.
+     *
+     * @param semantics A list of semantic strings to set.
+     * @return This instance to facilitate further modifications.
+     */
+    public SetAfServicesInfoResponse semantics(List<String> semantics) {
+        setSemantics(semantics);
+        return this;
+    }
+
+    /**
+     * Sets the commands and returns this instance for method chaining.
+     *
+     * @param commands A list of command strings to set.
+     * @return This instance to facilitate further modifications.
+     */
+    public SetAfServicesInfoResponse commands(List<String> commands) {
+        setCommands(commands);
+        return this;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == this)
+            return true;
+        if (!(o instanceof SetAfServicesInfoResponse)) {
+            return false;
+        }
+        SetAfServicesInfoResponse dungServicesInfoRespones = (SetAfServicesInfoResponse) o;
+        return Objects.equals(reply, dungServicesInfoRespones.reply) && Objects.equals(email, dungServicesInfoRespones.email) && backend_timeout == dungServicesInfoRespones.backend_timeout && Objects.equals(semantics, dungServicesInfoRespones.semantics) && Objects.equals(commands, dungServicesInfoRespones.commands);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(reply, email, backend_timeout, semantics, commands);
+    }
+
+    @Override
+    public String toString() {
+        return "{" +
+            " reply='" + getReply() + "'" +
+            ", email='" + getEmail() + "'" +
+            ", backend_timeout='" + getBackend_timeout() + "'" +
+            ", semantics='" + getSemantics() + "'" +
+            ", commands='" + getCommands() + "'" +
+            "}";
+    }
+}
diff --git a/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerBipolarTest.java b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerBipolarTest.java
index 464f7a480..73384a835 100644
--- a/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerBipolarTest.java
+++ b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerBipolarTest.java
@@ -26,7 +26,8 @@
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MockMvc;
-import org.tweetyproject.web.services.bipolar.BipolarSemantics;
+import org.tweetyproject.arg.dung.semantics.Semantics;
+import org.tweetyproject.web.services.aba.GeneralAbaReasonerFactory;
 
 import java.util.stream.Stream;
 
@@ -61,25 +62,32 @@ public void getInfos() throws Exception {
                           "reply": "info",
                           "email": null,
                           "backend_timeout": 600,
+                          "support_type": ["coalition","ded","nec"],
                           "semantics": [
-                            "b-cf",
-                            "b-coh",
-                            "b-ad",
-                            "b-coal-ad",
-                            "b-coal-co",
-                            "b-coal-gr",
-                            "b-coal-pr",
-                            "b-coal-st",
-                            "d-ad",
-                            "d-co",
-                            "d-gr",
-                            "d-pr",
-                            "d-st",
-                            "n-ad",
-                            "n-co",
-                            "n-gr",
-                            "n-pr",
-                            "n-st"
+                            "CF",
+                            "ADM",
+                            "CO",
+                            "GR",
+                            "PR",
+                            "ST",
+                            "STG",
+                            "STG2",
+                            "SST",
+                            "ID",
+                            "EA",
+                            "CF2",
+                            "SCF2",
+                            "NA",
+                            "SAD",
+                            "IS",
+                            "UC",
+                            "UD",
+                            "SUD",
+                            "WAD",
+                            "WCO",
+                            "WPR",
+                            "WGR",
+                            "CG"
                           ],
                           "commands": [
                             "get_models",
@@ -101,7 +109,8 @@ public void getModels() throws Exception {
                            "nr_of_arguments": 3,
                            "attacks": [[1, 2]],
                            "supports": [[2, 3]],
-                           "semantics": "b-ad",
+                           "support_type": "ded",
+                           "semantics": "ADM",
                            "timeout": 10,
                            "unit_timeout": "s"
                         }
@@ -126,13 +135,15 @@ public void getModels() throws Exception {
                               3
                             ]
                           ],
-                          "semantics": "b-ad",
+                          "support_type": "ded",
+                          "semantics": "ADM",
                           "solver": null,
-                          "answer": "[{1}, {}]",
+                          "answer": "[{1}, {3}, {1,3}, {}]",
                           "unit_time": "s",
+                          "time": 0,
                           "status": "SUCCESS"
                         }
-                        """, false));
+                        """, true));
     }
 
     @Test
@@ -145,7 +156,8 @@ public void getModel() throws Exception {
                            "nr_of_arguments": 3,
                            "attacks": [[1, 2]],
                            "supports": [[2, 3]],
-                           "semantics": "b-ad",
+                           "support_type": "coalition",
+                           "semantics": "PR",
                            "timeout": 10,
                            "unit_timeout": "s"
                         }
@@ -170,22 +182,25 @@ public void getModel() throws Exception {
                               3
                             ]
                           ],
-                          "semantics": "b-ad",
+                          "support_type": "coalition",
+                          "semantics": "PR",
                           "solver": null,
                           "answer": "{1}",
                           "unit_time": "s",
+                          "time": 0,
                           "status": "SUCCESS"
                         }
-                        """, false));
+                        """, true));
     }
 
-    private static Stream<BipolarSemantics> availableSemantics() {
-        return Stream.of(BipolarSemantics.values());
+    private static Stream<Semantics> availableSemantics() {
+        return Stream.of(Semantics.values());
     }
 
     @ParameterizedTest(name = "semantics {0}")
     @MethodSource("availableSemantics")
-    public void getModelsForSemantics(BipolarSemantics semantics) throws Exception {
+    public void getModelsForSemantics(Semantics semantics) throws Exception {
+        if (semantics.equals(Semantics.diverse)) return;
         var post = post("/bipolar").contentType(MediaType.APPLICATION_JSON)
                 // language=JSON
                 .content(String.format("""
@@ -194,11 +209,12 @@ public void getModelsForSemantics(BipolarSemantics semantics) throws Exception {
                            "nr_of_arguments": 3,
                            "attacks": [[1, 2]],
                            "supports": [[2, 3]],
+                           "support_type": "ded",
                            "semantics": "%s",
                            "timeout": 10,
                            "unit_timeout": "s"
                         }
-                        """, semantics.id));
+                        """, semantics.abbreviation()));
 
         mvc.perform(post).andExpect(status().isOk())
                 .andExpect(content().json("""
diff --git a/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerDungTest.java b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerDungTest.java
index 1d47c8a76..0d2d8aff9 100644
--- a/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerDungTest.java
+++ b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerDungTest.java
@@ -27,7 +27,6 @@
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MockMvc;
 import org.tweetyproject.arg.dung.semantics.Semantics;
-import org.tweetyproject.web.services.bipolar.BipolarSemantics;
 
 import java.util.stream.Stream;
 
diff --git a/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerIafTest.java b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerIafTest.java
index efca251f5..b3d24b8e5 100644
--- a/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerIafTest.java
+++ b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerIafTest.java
@@ -27,7 +27,6 @@
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MockMvc;
 import org.tweetyproject.arg.dung.semantics.Semantics;
-import org.tweetyproject.web.services.bipolar.BipolarSemantics;
 
 import java.util.stream.Stream;
 
diff --git a/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerPafTest.java b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerPafTest.java
index 605c06562..81056a56c 100644
--- a/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerPafTest.java
+++ b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerPafTest.java
@@ -27,7 +27,6 @@
 import org.springframework.http.MediaType;
 import org.springframework.test.web.servlet.MockMvc;
 import org.tweetyproject.arg.dung.semantics.Semantics;
-import org.tweetyproject.web.services.bipolar.BipolarSemantics;
 
 import java.util.stream.Stream;
 
diff --git a/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerRankingsTest.java b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerRankingsTest.java
index 30eb6b19e..5045fae44 100644
--- a/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerRankingsTest.java
+++ b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerRankingsTest.java
@@ -63,7 +63,7 @@ public void getInfos() throws Exception {
                           "email": null,
                           "backend_timeout": 600,
                           "semantics": [
-                            "CAT","SER","BB","CO","DB","IGD","SAF","SB","TU"
+                            "CAT","SER","BB","CO","DB","IGD","SAF","SB","TU","PR","PROB"
                           ],
                           "commands": [
                             "get_model"
diff --git a/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerSerialisationTest.java b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerSerialisationTest.java
new file mode 100644
index 000000000..321396b25
--- /dev/null
+++ b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerSerialisationTest.java
@@ -0,0 +1,332 @@
+/*
+ * This file is part of "TweetyProject", a collection of Java libraries for
+ * logical aspects of artificial intelligence and knowledge representation.
+ *
+ * TweetyProject is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+
+/**
+ * @author Lars Bengel
+ */
+@SpringBootTest
+@AutoConfigureMockMvc
+class RequestControllerSerialisationTest {
+    @Autowired
+    private MockMvc mvc;
+
+    @Test
+    public void getInfos() throws Exception {
+        var post = post("/serialisation").contentType(MediaType.APPLICATION_JSON)
+                // language=JSON
+                .content("""
+                        {
+                          "cmd": "info"
+                        }
+                        """);
+
+        mvc.perform(post).andExpect(status().isOk())
+                // language=JSON
+                .andExpect(content().json("""
+                        {
+                          "reply": "info",
+                          "email": null,
+                          "backend_timeout": 600,
+                          "selectionFunctions": [
+                            "ADM","UC","GR"
+                          ],
+                          "terminationFunctions": [
+                            "ADM","CO","UC","PR","ST"
+                          ],
+                          "commands": [
+                            "get_reduct",
+                            "is_terminal",
+                            "get_selection",
+                            "get_models",
+                            "get_sequences"
+                          ]
+                        }
+                        """, true));
+    }
+
+    @Test
+    public void getReduct() throws Exception {
+        var post = post("/serialisation").contentType(MediaType.APPLICATION_JSON)
+                // language=JSON
+                .content("""
+                         {
+                           "cmd": "get_reduct",
+                           "nr_of_arguments": 4,
+                           "attacks": [[1, 2],[2,3],[3,4],[4,3]],
+                           "extension": [1],
+                           "timeout": 10,
+                           "unit_timeout": "s"
+                        }
+                        """);
+
+        mvc.perform(post).andExpect(status().isOk())
+                // language=JSON
+                .andExpect(content().json("""
+                        {
+                          "reply": "get_reduct",
+                          "email": null,
+                          "nr_of_arguments": 4,
+                          "attacks": [
+                            [
+                              1,
+                              2
+                            ],
+                            [
+                              2,
+                              3
+                            ],
+                            [
+                              3,
+                              4
+                            ],
+                            [
+                              4,
+                              3
+                            ]
+                          ],
+                          "extension": [1],
+                          "selectionFunction": null,
+                          "terminationFunction": null,
+                          "answer": "<{ 3, 4 },[(3,4), (4,3)]>",
+                          "time": 0,
+                          "unit_time": "s",
+                          "status": "SUCCESS"
+                        }
+                        """, true));
+    }
+
+    @Test
+    public void getSelection() throws Exception {
+        var post = post("/serialisation").contentType(MediaType.APPLICATION_JSON)
+                // language=JSON
+                .content("""
+                         {
+                           "cmd": "get_selection",
+                           "nr_of_arguments": 4,
+                           "attacks": [[1, 2],[2,3],[3,4],[4,3]],
+                           "selectionFunction": "UC",
+                           "timeout": 10,
+                           "unit_timeout": "s"
+                        }
+                        """);
+
+        mvc.perform(post).andExpect(status().isOk())
+                // language=JSON
+                .andExpect(content().json("""
+                        {
+                          "reply": "get_selection",
+                          "email": null,
+                          "nr_of_arguments": 4,
+                          "attacks": [
+                            [
+                              1,
+                              2
+                            ],
+                            [
+                              2,
+                              3
+                            ],
+                            [
+                              3,
+                              4
+                            ],
+                            [
+                              4,
+                              3
+                            ]
+                          ],
+                          "extension": null,
+                          "selectionFunction": "UC",
+                          "terminationFunction": null,
+                          "answer": "[{1}, {4}]",
+                          "time": 0,
+                          "unit_time": "s",
+                          "status": "SUCCESS"
+                        }
+                        """, true));
+    }
+
+    @Test
+    public void isTerminal() throws Exception {
+        var post = post("/serialisation").contentType(MediaType.APPLICATION_JSON)
+                // language=JSON
+                .content("""
+                         {
+                           "cmd": "is_terminal",
+                           "nr_of_arguments": 4,
+                           "attacks": [[1, 2],[2,3],[3,4],[4,3]],
+                           "terminationFunction": "UC",
+                           "timeout": 10,
+                           "unit_timeout": "s"
+                        }
+                        """);
+
+        mvc.perform(post).andExpect(status().isOk())
+                // language=JSON
+                .andExpect(content().json("""
+                        {
+                          "reply": "is_terminal",
+                          "email": null,
+                          "nr_of_arguments": 4,
+                          "attacks": [
+                            [
+                              1,
+                              2
+                            ],
+                            [
+                              2,
+                              3
+                            ],
+                            [
+                              3,
+                              4
+                            ],
+                            [
+                              4,
+                              3
+                            ]
+                          ],
+                          "extension": null,
+                          "selectionFunction": null,
+                          "terminationFunction": "UC",
+                          "answer": "false",
+                          "time": 0,
+                          "unit_time": "s",
+                          "status": "SUCCESS"
+                        }
+                        """, true));
+    }
+
+    @Test
+    public void getModels() throws Exception {
+        var post = post("/serialisation").contentType(MediaType.APPLICATION_JSON)
+                // language=JSON
+                .content("""
+                         {
+                           "cmd": "get_models",
+                           "nr_of_arguments": 4,
+                           "attacks": [[1, 2],[2,3],[3,4],[4,3]],
+                           "selectionFunction": "ADM",
+                           "terminationFunction": "PR",
+                           "timeout": 10,
+                           "unit_timeout": "s"
+                        }
+                        """);
+
+        mvc.perform(post).andExpect(status().isOk())
+                // language=JSON
+                .andExpect(content().json("""
+                        {
+                          "reply": "get_models",
+                          "email": null,
+                          "nr_of_arguments": 4,
+                          "attacks": [
+                            [
+                              1,
+                              2
+                            ],
+                            [
+                              2,
+                              3
+                            ],
+                            [
+                              3,
+                              4
+                            ],
+                            [
+                              4,
+                              3
+                            ]
+                          ],
+                          "extension": null,
+                          "selectionFunction": "ADM",
+                          "terminationFunction": "PR",
+                          "answer": "[{1,3}, {1,4}]",
+                          "time": 0,
+                          "unit_time": "s",
+                          "status": "SUCCESS"
+                        }
+                        """, true));
+    }
+
+    @Test
+    public void getSequences() throws Exception {
+        var post = post("/serialisation").contentType(MediaType.APPLICATION_JSON)
+                // language=JSON
+                .content("""
+                         {
+                           "cmd": "get_sequences",
+                           "nr_of_arguments": 4,
+                           "attacks": [[1, 2],[2,3],[3,4],[4,3]],
+                           "selectionFunction": "UC",
+                           "terminationFunction": "UC",
+                           "timeout": 10,
+                           "unit_timeout": "s"
+                        }
+                        """);
+
+        mvc.perform(post).andExpect(status().isOk())
+                // language=JSON
+                .andExpect(content().json("""
+                        {
+                          "reply": "get_sequences",
+                          "email": null,
+                          "nr_of_arguments": 4,
+                          "attacks": [
+                            [
+                              1,
+                              2
+                            ],
+                            [
+                              2,
+                              3
+                            ],
+                            [
+                              3,
+                              4
+                            ],
+                            [
+                              4,
+                              3
+                            ]
+                          ],
+                          "extension": null,
+                          "selectionFunction": "UC",
+                          "terminationFunction": "UC",
+                          "answer": "[({4},{1}), ({1})]",
+                          "time": 0,
+                          "unit_time": "s",
+                          "status": "SUCCESS"
+                        }
+                        """, true));
+    }
+}
\ No newline at end of file
diff --git a/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerSetAfTest.java b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerSetAfTest.java
new file mode 100644
index 000000000..439f8232c
--- /dev/null
+++ b/org-tweetyproject-web/src/test/java/org/tweetyproject/web/services/RequestControllerSetAfTest.java
@@ -0,0 +1,231 @@
+/*
+ * This file is part of "TweetyProject", a collection of Java libraries for
+ * logical aspects of artificial intelligence and knowledge representation.
+ *
+ * TweetyProject is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright 2026 The TweetyProject Team <http://tweetyproject.org/contact/>
+ */
+package org.tweetyproject.web.services;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+import org.tweetyproject.arg.dung.semantics.Semantics;
+import org.tweetyproject.web.services.setaf.AbstractSetAfFactory;
+
+import java.util.stream.Stream;
+
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+
+/**
+ * @author Lars Bengel
+ */
+@SpringBootTest
+@AutoConfigureMockMvc
+class RequestControllerSetAfTest {
+    @Autowired
+    private MockMvc mvc;
+
+    @Test
+    public void getInfos() throws Exception {
+        var post = post("/setaf").contentType(MediaType.APPLICATION_JSON)
+                // language=JSON
+                .content("""
+                        {
+                          "cmd": "info"
+                        }
+                        """);
+
+        mvc.perform(post).andExpect(status().isOk())
+                // language=JSON
+                .andExpect(content().json("""
+                        {
+                          "reply": "info",
+                          "email": null,
+                          "backend_timeout": 600,
+                          "semantics": [
+                            "CF","ADM","CO","GR","PR","ST","STG","STG2","SST","ID","EA","CF2","SCF2","NA","SAD","IS","UC","UD","SUD","WAD","WCO","WPR","WGR","CG","div"
+                          ],
+                          "commands": [
+                            "get_models",
+                            "get_credulous",
+                            "get_skeptical"
+                          ]
+                        }
+                        """, true));
+    }
+
+    @Test
+    public void getModels() throws Exception {
+        var post = post("/setaf").contentType(MediaType.APPLICATION_JSON)
+                // language=JSON
+                .content("""
+                         {
+                           "cmd": "get_models",
+                           "nr_of_arguments": 4,
+                           "attacks": [[1, 2],[2,3,4]],
+                           "semantics": "ADM",
+                           "timeout": 10,
+                           "unit_timeout": "s"
+                        }
+                        """);
+
+        mvc.perform(post).andExpect(status().isOk())
+                // language=JSON
+                .andExpect(content().json("""
+                        {
+                          "reply": "get_models",
+                          "email": null,
+                          "nr_of_arguments": 4,
+                          "attacks": [
+                            [
+                              1,
+                              2
+                            ],
+                            [
+                              2,
+                              3,
+                              4
+                            ]
+                          ],
+                          "semantics": "ADM",
+                          "solver": null,
+                          "answer": "[{1}, {3}, {1,3}, {1,4}, {1,3,4}, {}]",
+                          "unit_time": "s",
+                          "status": "SUCCESS"
+                        }
+                        """, false));
+    }
+
+    @Test
+    public void getCredulous() throws Exception {
+        var post = post("/setaf").contentType(MediaType.APPLICATION_JSON)
+                // language=JSON
+                .content("""
+                         {
+                           "cmd": "get_credulous",
+                           "nr_of_arguments": 4,
+                           "attacks": [[1, 2],[2,3,4]],
+                           "semantics": "ADM",
+                           "timeout": 10,
+                           "unit_timeout": "s"
+                        }
+                        """);
+
+        mvc.perform(post).andExpect(status().isOk())
+                // language=JSON
+                .andExpect(content().json("""
+                        {
+                          "reply": "get_credulous",
+                          "email": null,
+                          "nr_of_arguments": 4,
+                          "attacks": [
+                            [
+                              1,
+                              2
+                            ],
+                            [
+                              2,
+                              3,
+                              4
+                            ]
+                          ],
+                          "semantics": "ADM",
+                          "solver": null,
+                          "answer": "{1,3,4}",
+                          "unit_time": "s",
+                          "status": "SUCCESS"
+                        }
+                        """, false));
+    }
+
+    @Test
+    public void getSkeptical() throws Exception {
+        var post = post("/setaf").contentType(MediaType.APPLICATION_JSON)
+                // language=JSON
+                .content("""
+                         {
+                           "cmd": "get_skeptical",
+                           "nr_of_arguments": 4,
+                           "attacks": [[1, 2],[2,3,4]],
+                           "semantics": "ADM",
+                           "timeout": 10,
+                           "unit_timeout": "s"
+                        }
+                        """);
+
+        mvc.perform(post).andExpect(status().isOk())
+                // language=JSON
+                .andExpect(content().json("""
+                        {
+                          "reply": "get_skeptical",
+                          "email": null,
+                          "nr_of_arguments": 4,
+                          "attacks": [
+                            [
+                              1,
+                              2
+                            ],
+                            [
+                              2,
+                              3,
+                              4
+                            ]
+                          ],
+                          "semantics": "ADM",
+                          "solver": null,
+                          "answer": "{}",
+                          "unit_time": "s",
+                          "status": "SUCCESS"
+                        }
+                        """, false));
+    }
+
+    private static Stream<Semantics> availableSemantics() {
+        return Stream.of(AbstractSetAfFactory.getSemantics());
+    }
+
+    @ParameterizedTest(name = "semantics {0}")
+    @MethodSource("availableSemantics")
+    public void getModelsForSemantics(Semantics semantics) throws Exception {
+        if (semantics.equals(Semantics.diverse)) return;
+        var post = post("/setaf").contentType(MediaType.APPLICATION_JSON)
+                // language=JSON
+                .content(String.format("""
+                         {
+                           "cmd": "get_models",
+                           "nr_of_arguments": 3,
+                           "attacks": [[1, 2],[2, 3]],
+                           "semantics": "%s",
+                           "timeout": 10,
+                           "unit_timeout": "s"
+                        }
+                        """, semantics.abbreviation()));
+
+        mvc.perform(post).andExpect(status().isOk())
+                .andExpect(content().json("""
+                    {
+                      "status": "SUCCESS"
+                    }
+                    """));
+    }
+}
\ No newline at end of file