diff --git a/backend/src/main/java/ai/giskard/domain/Callable.java b/backend/src/main/java/ai/giskard/domain/Callable.java
index 530ca26944..9ceca7622e 100644
--- a/backend/src/main/java/ai/giskard/domain/Callable.java
+++ b/backend/src/main/java/ai/giskard/domain/Callable.java
@@ -1,10 +1,10 @@
 package ai.giskard.domain;
 
 import ai.giskard.utils.SimpleJSONStringAttributeConverter;
+import jakarta.persistence.*;
 import lombok.Getter;
 import lombok.Setter;
 
-import jakarta.persistence.*;
 import java.io.Serializable;
 import java.util.List;
 import java.util.UUID;
@@ -13,9 +13,6 @@
 @Setter
 @Inheritance(strategy = InheritanceType.SINGLE_TABLE)
 @Entity(name = "callable_functions")
-@Table(uniqueConstraints = {
-    @UniqueConstraint(columnNames = {"name", "module", "version"})
-})
 @DiscriminatorColumn(name = "callable_type", discriminatorType = DiscriminatorType.STRING)
 public class Callable implements Serializable {
     @Id
diff --git a/backend/src/main/java/ai/giskard/domain/ml/CallToActionKind.java b/backend/src/main/java/ai/giskard/domain/ml/CallToActionKind.java
new file mode 100644
index 0000000000..8eb91b7e1d
--- /dev/null
+++ b/backend/src/main/java/ai/giskard/domain/ml/CallToActionKind.java
@@ -0,0 +1,25 @@
+package ai.giskard.domain.ml;
+
+import com.dataiku.j2ts.annotations.UIModel;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+@UIModel
+public enum CallToActionKind {
+    NONE,
+    CREATE_SLICE,
+    CREATE_TEST,
+    CREATE_PERTURBATION,
+    SAVE_PERTURBATION,
+    CREATE_ROBUSTNESS_TEST,
+    CREATE_SLICE_OPEN_DEBUGGER,
+    OPEN_DEBUGGER_BORDERLINE,
+    ADD_TEST_TO_CATALOG,
+    SAVE_EXAMPLE,
+    OPEN_DEBUGGER_OVERCONFIDENCE,
+    CREATE_UNIT_TEST;
+
+    @JsonValue
+    public int toValue() {
+        return ordinal();
+    }
+}
diff --git a/backend/src/main/java/ai/giskard/domain/ml/PushKind.java b/backend/src/main/java/ai/giskard/domain/ml/PushKind.java
new file mode 100644
index 0000000000..b6c8ddc5a8
--- /dev/null
+++ b/backend/src/main/java/ai/giskard/domain/ml/PushKind.java
@@ -0,0 +1,18 @@
+package ai.giskard.domain.ml;
+
+import com.dataiku.j2ts.annotations.UIModel;
+import com.fasterxml.jackson.annotation.JsonValue;
+
+@UIModel
+public enum PushKind {
+    INVALID,
+    PERTURBATION,
+    CONTRIBUTION,
+    OVERCONFIDENCE,
+    BORDERLINE;
+
+    @JsonValue
+    public int toValue() {
+        return ordinal();
+    }
+}
diff --git a/backend/src/main/java/ai/giskard/domain/ml/SuiteTestExecution.java b/backend/src/main/java/ai/giskard/domain/ml/SuiteTestExecution.java
index 3b41666c04..6afb5d53a1 100644
--- a/backend/src/main/java/ai/giskard/domain/ml/SuiteTestExecution.java
+++ b/backend/src/main/java/ai/giskard/domain/ml/SuiteTestExecution.java
@@ -7,11 +7,11 @@
 import ai.giskard.web.dto.ml.TestResultMessageDTO;
 import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import jakarta.persistence.*;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 
-import jakarta.persistence.*;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
diff --git a/backend/src/main/java/ai/giskard/ml/MLWorkerWSAction.java b/backend/src/main/java/ai/giskard/ml/MLWorkerWSAction.java
index 63fc49e819..ee1eb53279 100644
--- a/backend/src/main/java/ai/giskard/ml/MLWorkerWSAction.java
+++ b/backend/src/main/java/ai/giskard/ml/MLWorkerWSAction.java
@@ -13,9 +13,11 @@ public enum MLWorkerWSAction {
     GENERATE_TEST_SUITE("generateTestSuite"),
     STOP_WORKER("stopWorker"),
     GET_CATALOG("getCatalog"),
-    GENERATE_QUERY_BASED_SLICING_FUNCTION("generateQueryBasedSlicingFunction");
+    GENERATE_QUERY_BASED_SLICING_FUNCTION("generateQueryBasedSlicingFunction"),
+    GET_PUSH("getPush");
 
     private final String actionName;
+
     MLWorkerWSAction(String name) {
         actionName = name;
     }
diff --git a/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSGetPushDTO.java b/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSGetPushDTO.java
new file mode 100644
index 0000000000..71c397cbc9
--- /dev/null
+++ b/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSGetPushDTO.java
@@ -0,0 +1,35 @@
+package ai.giskard.ml.dto;
+
+import ai.giskard.domain.ml.CallToActionKind;
+import ai.giskard.domain.ml.PushKind;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.annotation.Nullable;
+import java.util.Map;
+
+@Getter
+@Setter
+@Builder
+public class MLWorkerWSGetPushDTO implements MLWorkerWSBaseDTO {
+    private MLWorkerWSArtifactRefDTO dataset;
+    private MLWorkerWSArtifactRefDTO model;
+    private int rowIdx;
+    private MLWorkerWSDataFrameDTO dataframe;
+
+    private String target;
+
+    @JsonProperty("column_types")
+    private Map<String, String> columnTypes;
+
+    @JsonProperty("column_dtypes")
+    private Map<String, String> columnDtypes;
+    @Nullable
+    @JsonProperty("push_kind")
+    private PushKind pushKind;
+    @Nullable
+    @JsonProperty("cta_kind")
+    private CallToActionKind ctaKind;
+}
diff --git a/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSGetPushResultDTO.java b/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSGetPushResultDTO.java
new file mode 100644
index 0000000000..1fed7e79cf
--- /dev/null
+++ b/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSGetPushResultDTO.java
@@ -0,0 +1,21 @@
+package ai.giskard.ml.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.annotation.Nullable;
+
+@Getter
+@Setter
+public class MLWorkerWSGetPushResultDTO implements MLWorkerWSBaseDTO {
+    @Nullable
+    private MLWorkerWSPushDTO perturbation;
+    @Nullable
+    private MLWorkerWSPushDTO contribution;
+    @Nullable
+    private MLWorkerWSPushDTO borderline;
+    @Nullable
+    private MLWorkerWSPushDTO overconfidence;
+    @Nullable
+    private MLWorkerWSPushActionDTO action;
+}
diff --git a/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSPushActionDTO.java b/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSPushActionDTO.java
new file mode 100644
index 0000000000..0a79ac69fe
--- /dev/null
+++ b/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSPushActionDTO.java
@@ -0,0 +1,17 @@
+package ai.giskard.ml.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.List;
+
+@Getter
+@Setter
+public class MLWorkerWSPushActionDTO implements MLWorkerWSBaseDTO {
+
+    @JsonProperty("object_uuid")
+    private String objectUuid;
+    
+    private List<MLWorkerWSFuncArgumentDTO> arguments;
+}
diff --git a/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSPushDTO.java b/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSPushDTO.java
new file mode 100644
index 0000000000..26cd761cbd
--- /dev/null
+++ b/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSPushDTO.java
@@ -0,0 +1,24 @@
+package ai.giskard.ml.dto;
+
+import ai.giskard.domain.ml.PushKind;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.annotation.Nullable;
+import java.util.List;
+
+@Getter
+@Setter
+public class MLWorkerWSPushDTO implements MLWorkerWSBaseDTO {
+    private PushKind kind;
+    @Nullable
+    private String key;
+    @Nullable
+    private String value;
+    @JsonProperty("push_title")
+    private String pushTitle;
+
+    @JsonProperty("push_details")
+    private List<MLWorkerWSPushDetailsDTO> pushDetails;
+}
diff --git a/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSPushDetailsDTO.java b/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSPushDetailsDTO.java
new file mode 100644
index 0000000000..bd39367299
--- /dev/null
+++ b/backend/src/main/java/ai/giskard/ml/dto/MLWorkerWSPushDetailsDTO.java
@@ -0,0 +1,14 @@
+package ai.giskard.ml.dto;
+
+import ai.giskard.domain.ml.CallToActionKind;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+public class MLWorkerWSPushDetailsDTO implements MLWorkerWSBaseDTO {
+    private String action;
+    private String explanation;
+    private String button;
+    private CallToActionKind cta;
+}
diff --git a/backend/src/main/java/ai/giskard/repository/ml/CallableRepository.java b/backend/src/main/java/ai/giskard/repository/ml/CallableRepository.java
index 5dc682037d..965a3e344e 100644
--- a/backend/src/main/java/ai/giskard/repository/ml/CallableRepository.java
+++ b/backend/src/main/java/ai/giskard/repository/ml/CallableRepository.java
@@ -9,6 +9,6 @@
 @NoRepositoryBean
 public interface CallableRepository<E extends Callable> extends MappableJpaRepository<E, UUID> {
 
-    int countByNameAndModule(String name, String module);
+    int countByDisplayName(String displayName);
 
 }
diff --git a/backend/src/main/java/ai/giskard/service/SlicingFunctionService.java b/backend/src/main/java/ai/giskard/service/SlicingFunctionService.java
index 458e93f42b..9a52583f42 100644
--- a/backend/src/main/java/ai/giskard/service/SlicingFunctionService.java
+++ b/backend/src/main/java/ai/giskard/service/SlicingFunctionService.java
@@ -9,6 +9,7 @@
 import ai.giskard.web.dto.SlicingFunctionDTO;
 import ai.giskard.web.dto.mapper.GiskardMapper;
 import com.fasterxml.jackson.core.JsonProcessingException;
+import org.apache.logging.log4j.util.Strings;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -42,10 +43,16 @@ public SlicingFunctionDTO save(SlicingFunctionDTO slicingFunction) {
     protected SlicingFunction create(SlicingFunctionDTO dto) {
         SlicingFunction function = giskardMapper.fromDTO(dto);
         function.setProjectKey(dto.getProjectKey());
+
         if (function.getArgs() != null) {
             function.getArgs().forEach(arg -> arg.setFunction(function));
         }
-        function.setVersion(slicingFunctionRepository.countByNameAndModule(function.getName(), function.getModule()) + 1);
+
+        if (Strings.isBlank(function.getDisplayName())) {
+            function.setDisplayName(function.getModule() + "." + function.getName());
+        }
+
+        function.setVersion(slicingFunctionRepository.countByDisplayName(function.getDisplayName()) + 1);
         return function;
     }
 
@@ -82,7 +89,7 @@ public SlicingFunctionDTO generate(List<ComparisonClauseDTO> comparisonClauses)
         slicingFunction.setModuleDoc("");
         slicingFunction.setName(name);
         slicingFunction.setTags(List.of("pickle", "ui"));
-        slicingFunction.setVersion(slicingFunctionRepository.countByNameAndModule(slicingFunction.getName(), slicingFunction.getModule()) + 1);
+        slicingFunction.setVersion(slicingFunctionRepository.countByDisplayName(name) + 1);
         slicingFunction.setCellLevel(false);
         slicingFunction.setColumnType("");
         slicingFunction.setProcessType(DatasetProcessFunctionType.CLAUSES);
diff --git a/backend/src/main/java/ai/giskard/service/TestFunctionService.java b/backend/src/main/java/ai/giskard/service/TestFunctionService.java
index 89ac61dd9f..fea39b9637 100644
--- a/backend/src/main/java/ai/giskard/service/TestFunctionService.java
+++ b/backend/src/main/java/ai/giskard/service/TestFunctionService.java
@@ -4,6 +4,7 @@
 import ai.giskard.repository.ml.TestFunctionRepository;
 import ai.giskard.web.dto.TestFunctionDTO;
 import ai.giskard.web.dto.mapper.GiskardMapper;
+import org.apache.logging.log4j.util.Strings;
 import org.springframework.stereotype.Service;
 
 @Service
@@ -29,7 +30,13 @@ protected TestFunction create(TestFunctionDTO dto) {
         if (function.getArgs() != null) {
             function.getArgs().forEach(arg -> arg.setFunction(function));
         }
-        function.setVersion(testFunctionRepository.countByNameAndModule(function.getName(), function.getModule()) + 1);
+
+        if (Strings.isBlank(function.getDisplayName())) {
+            function.setDisplayName(function.getModule() + "." + function.getName());
+        }
+
+        function.setVersion(testFunctionRepository.countByDisplayName(function.getDisplayName()) + 1);
+
         return function;
     }
 
diff --git a/backend/src/main/java/ai/giskard/service/TransformationFunctionService.java b/backend/src/main/java/ai/giskard/service/TransformationFunctionService.java
index 75d5f9eb03..1ea694723a 100644
--- a/backend/src/main/java/ai/giskard/service/TransformationFunctionService.java
+++ b/backend/src/main/java/ai/giskard/service/TransformationFunctionService.java
@@ -4,6 +4,7 @@
 import ai.giskard.repository.ml.TransformationFunctionRepository;
 import ai.giskard.web.dto.TransformationFunctionDTO;
 import ai.giskard.web.dto.mapper.GiskardMapper;
+import org.apache.logging.log4j.util.Strings;
 import org.springframework.stereotype.Service;
 
 @Service
@@ -29,7 +30,13 @@ protected TransformationFunction create(TransformationFunctionDTO dto) {
         if (function.getArgs() != null) {
             function.getArgs().forEach(arg -> arg.setFunction(function));
         }
-        function.setVersion(transformationFunctionRepository.countByNameAndModule(function.getName(), function.getModule()) + 1);
+
+        if (Strings.isBlank(function.getDisplayName())) {
+            function.setDisplayName(function.getModule() + "." + function.getName());
+        }
+
+        function.setVersion(transformationFunctionRepository.countByDisplayName(function.getDisplayName()) + 1);
+
         return function;
     }
 
diff --git a/backend/src/main/java/ai/giskard/service/ml/MLWorkerWSCommService.java b/backend/src/main/java/ai/giskard/service/ml/MLWorkerWSCommService.java
index c0432da39a..858b6210c9 100644
--- a/backend/src/main/java/ai/giskard/service/ml/MLWorkerWSCommService.java
+++ b/backend/src/main/java/ai/giskard/service/ml/MLWorkerWSCommService.java
@@ -83,6 +83,7 @@ public MLWorkerWSBaseDTO performAction(MLWorkerID workerID, MLWorkerWSAction act
                 case ECHO -> parseReplyDTO(result, MLWorkerWSEchoMsgDTO.class);
                 case GENERATE_TEST_SUITE -> parseReplyDTO(result, MLWorkerWSGenerateTestSuiteDTO.class);
                 case GET_CATALOG -> parseReplyDTO(result, MLWorkerWSCatalogDTO.class);
+                case GET_PUSH -> parseReplyDTO(result, MLWorkerWSGetPushResultDTO.class);
             };
         } catch (JsonProcessingException e) {
             return parseReplyErrorDTO(result);
diff --git a/backend/src/main/java/ai/giskard/web/dto/ApplyPushDTO.java b/backend/src/main/java/ai/giskard/web/dto/ApplyPushDTO.java
new file mode 100644
index 0000000000..28d6e094ff
--- /dev/null
+++ b/backend/src/main/java/ai/giskard/web/dto/ApplyPushDTO.java
@@ -0,0 +1,24 @@
+package ai.giskard.web.dto;
+
+import ai.giskard.domain.ml.CallToActionKind;
+import ai.giskard.domain.ml.PushKind;
+import com.dataiku.j2ts.annotations.UIModel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Map;
+import java.util.UUID;
+
+@Getter
+@Setter
+@UIModel
+@NoArgsConstructor
+public class ApplyPushDTO {
+    private UUID modelId;
+    private UUID datasetId;
+    private int rowIdx;
+    private PushKind pushKind;
+    private CallToActionKind ctaKind;
+    private Map<String, String> features;
+}
diff --git a/backend/src/main/java/ai/giskard/web/dto/PushActionDTO.java b/backend/src/main/java/ai/giskard/web/dto/PushActionDTO.java
new file mode 100644
index 0000000000..de9e294de0
--- /dev/null
+++ b/backend/src/main/java/ai/giskard/web/dto/PushActionDTO.java
@@ -0,0 +1,17 @@
+package ai.giskard.web.dto;
+
+import com.dataiku.j2ts.annotations.UIModel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+import java.util.Map;
+
+@Getter
+@Setter
+@UIModel
+@NoArgsConstructor
+public class PushActionDTO {
+    private String objectUuid;
+    private Map<String, String> parameters;
+}
diff --git a/backend/src/main/java/ai/giskard/web/rest/controllers/PushController.java b/backend/src/main/java/ai/giskard/web/rest/controllers/PushController.java
new file mode 100644
index 0000000000..d9dcbd3c98
--- /dev/null
+++ b/backend/src/main/java/ai/giskard/web/rest/controllers/PushController.java
@@ -0,0 +1,175 @@
+package ai.giskard.web.rest.controllers;
+
+import ai.giskard.domain.ColumnType;
+import ai.giskard.domain.ml.Dataset;
+import ai.giskard.domain.ml.ProjectModel;
+import ai.giskard.exception.MLWorkerIllegalReplyException;
+import ai.giskard.exception.MLWorkerNotConnectedException;
+import ai.giskard.ml.MLWorkerID;
+import ai.giskard.ml.MLWorkerWSAction;
+import ai.giskard.ml.dto.*;
+import ai.giskard.repository.ml.DatasetRepository;
+import ai.giskard.repository.ml.ModelRepository;
+import ai.giskard.security.PermissionEvaluator;
+import ai.giskard.service.ml.MLWorkerWSCommService;
+import ai.giskard.service.ml.MLWorkerWSService;
+import ai.giskard.web.dto.ApplyPushDTO;
+import ai.giskard.web.dto.PredictionInputDTO;
+import com.google.common.collect.Maps;
+import jakarta.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.apache.logging.log4j.util.Strings;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/v2/")
+public class PushController {
+    private final ModelRepository modelRepository;
+    private final PermissionEvaluator permissionEvaluator;
+    private final DatasetRepository datasetRepository;
+
+    private final MLWorkerWSCommService mlWorkerWSCommService;
+    private final MLWorkerWSService mlWorkerWSService;
+
+
+    @PostMapping("/pushes/{modelId}/{datasetId}/{idx}")
+    public MLWorkerWSGetPushResultDTO getPushes(@PathVariable @NotNull UUID modelId,
+                                                @PathVariable @NotNull UUID datasetId,
+                                                @PathVariable @NotNull int idx,
+                                                @RequestBody @NotNull PredictionInputDTO data) {
+        ProjectModel model = modelRepository.getMandatoryById(modelId);
+        Dataset dataset = datasetRepository.getMandatoryById(datasetId);
+        permissionEvaluator.validateCanReadProject(model.getProject().getId());
+        Map<String, String> features = data.getFeatures();
+
+        MLWorkerWSArtifactRefDTO datasetRef = MLWorkerWSArtifactRefDTO.fromDataset(dataset);
+        MLWorkerWSArtifactRefDTO modelRef = MLWorkerWSArtifactRefDTO.fromModel(model);
+
+        MLWorkerWSGetPushDTO.MLWorkerWSGetPushDTOBuilder paramBuilder = MLWorkerWSGetPushDTO.builder()
+            .dataset(datasetRef)
+            .model(modelRef)
+            .rowIdx(idx);
+
+        if (features != null) {
+            MLWorkerWSDataFrameDTO dataframe = MLWorkerWSDataFrameDTO.builder()
+                .rows(
+                    List.of(
+                        MLWorkerWSDataRowDTO.builder().columns(
+                            features.entrySet().stream()
+                                .filter(entry -> !shouldDrop(
+                                    dataset.getColumnDtypes().get(entry.getKey()),
+                                    entry.getValue()
+                                )).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))
+                        ).build()
+                    )
+                ).build();
+
+            paramBuilder.dataframe(dataframe);
+        }
+
+        if (dataset.getTarget() != null) {
+            paramBuilder.target(dataset.getTarget());
+        }
+        if (dataset.getColumnTypes() != null) {
+            paramBuilder.columnTypes(Maps.transformValues(dataset.getColumnTypes(), ColumnType::getName));
+        }
+        if (dataset.getColumnDtypes() != null) {
+            paramBuilder.columnDtypes(dataset.getColumnDtypes());
+        }
+
+        if (mlWorkerWSService.isWorkerConnected(MLWorkerID.EXTERNAL)) {
+            MLWorkerWSBaseDTO result = mlWorkerWSCommService.performAction(
+                MLWorkerID.EXTERNAL,
+                MLWorkerWSAction.GET_PUSH,
+                paramBuilder.build()
+            );
+
+            if (result instanceof MLWorkerWSGetPushResultDTO response) {
+                return response;
+            } else if (result instanceof MLWorkerWSErrorDTO error) {
+                throw new MLWorkerIllegalReplyException(error);
+            }
+            throw new MLWorkerIllegalReplyException("Cannot get ML Worker GetPushResult reply");
+        }
+
+        throw new MLWorkerNotConnectedException(MLWorkerID.EXTERNAL);
+    }
+
+    @PostMapping("/push/apply")
+    public MLWorkerWSGetPushResultDTO applyPushSuggestion(@RequestBody ApplyPushDTO applyPushDTO) {
+        ProjectModel model = modelRepository.getMandatoryById(applyPushDTO.getModelId());
+        Dataset dataset = datasetRepository.getMandatoryById(applyPushDTO.getDatasetId());
+        permissionEvaluator.validateCanReadProject(model.getProject().getId());
+        Map<String, String> features = applyPushDTO.getFeatures();
+
+        MLWorkerWSArtifactRefDTO datasetRef = MLWorkerWSArtifactRefDTO.fromDataset(dataset);
+        MLWorkerWSArtifactRefDTO modelRef = MLWorkerWSArtifactRefDTO.fromModel(model);
+
+        MLWorkerWSGetPushDTO.MLWorkerWSGetPushDTOBuilder paramBuilder = MLWorkerWSGetPushDTO.builder()
+            .dataset(datasetRef)
+            .model(modelRef)
+            .rowIdx(applyPushDTO.getRowIdx())
+            .pushKind(applyPushDTO.getPushKind())
+            .ctaKind(applyPushDTO.getCtaKind());
+
+        if (features != null) {
+            MLWorkerWSDataFrameDTO dataframe = MLWorkerWSDataFrameDTO.builder()
+                .rows(
+                    List.of(
+                        MLWorkerWSDataRowDTO.builder().columns(
+                            features.entrySet().stream()
+                                .filter(entry -> !shouldDrop(
+                                    dataset.getColumnDtypes().get(entry.getKey()),
+                                    entry.getValue()
+                                )).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))
+                        ).build()
+                    )
+                ).build();
+
+            paramBuilder.dataframe(dataframe);
+        }
+
+        if (dataset.getTarget() != null) {
+            paramBuilder.target(dataset.getTarget());
+        }
+        if (dataset.getColumnTypes() != null) {
+            paramBuilder.columnTypes(Maps.transformValues(dataset.getColumnTypes(), ColumnType::getName));
+        }
+        if (dataset.getColumnDtypes() != null) {
+            paramBuilder.columnDtypes(dataset.getColumnDtypes());
+        }
+
+        paramBuilder.pushKind(applyPushDTO.getPushKind());
+        paramBuilder.ctaKind(applyPushDTO.getCtaKind());
+
+        if (mlWorkerWSService.isWorkerConnected(MLWorkerID.EXTERNAL)) {
+            MLWorkerWSBaseDTO result = mlWorkerWSCommService.performAction(
+                MLWorkerID.EXTERNAL,
+                MLWorkerWSAction.GET_PUSH,
+                paramBuilder.build()
+            );
+
+            if (result instanceof MLWorkerWSGetPushResultDTO response) {
+                return response;
+            } else if (result instanceof MLWorkerWSErrorDTO error) {
+                throw new MLWorkerIllegalReplyException(error);
+            }
+            throw new MLWorkerIllegalReplyException("Cannot get ML Worker GetPushResult reply");
+        }
+
+        throw new MLWorkerNotConnectedException(MLWorkerID.EXTERNAL);
+    }
+
+    // Probably move this to a util class.
+    public boolean shouldDrop(String columnDtype, String value) {
+        return Objects.isNull(columnDtype) || Objects.isNull(value) ||
+            ((columnDtype.startsWith("int") || columnDtype.startsWith("float")) && Strings.isBlank(value));
+    }
+}
diff --git a/backend/src/main/resources/config/liquibase/changelog/20230829180047_changelog.xml b/backend/src/main/resources/config/liquibase/changelog/20230829180047_changelog.xml
new file mode 100644
index 0000000000..455c74f14c
--- /dev/null
+++ b/backend/src/main/resources/config/liquibase/changelog/20230829180047_changelog.xml
@@ -0,0 +1,8 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd">
+    <changeSet author="kevinmessiaen (generated)" id="1693306851961-1">
+        <dropUniqueConstraint constraintName="UKQ8FR55CKPMID2KUR3XP21NXUQ" tableName="CALLABLE_FUNCTIONS"/>
+    </changeSet>
+</databaseChangeLog>
diff --git a/backend/src/main/resources/config/liquibase/master.xml b/backend/src/main/resources/config/liquibase/master.xml
index 6cd6552a50..62af303942 100644
--- a/backend/src/main/resources/config/liquibase/master.xml
+++ b/backend/src/main/resources/config/liquibase/master.xml
@@ -34,4 +34,6 @@
     <include file="config/liquibase/changelog/20230822143427_changelog.xml" relativeToChangelogFile="false"/>
     <include file="config/liquibase/changelog/20230823101750_changelog.xml" relativeToChangelogFile="false"/>
     <include file="config/liquibase/changelog/20230828200520_changelog.xml" relativeToChangelogFile="false"/>
+    <include file="config/liquibase/changelog/20230829180047_changelog.xml" relativeToChangelogFile="false"/>
+
 </databaseChangeLog>
diff --git a/common/proto/ml-worker.proto b/common/proto/ml-worker.proto
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/frontend/src/api.ts b/frontend/src/api.ts
index 17dab94795..9c4c842c6a 100644
--- a/frontend/src/api.ts
+++ b/frontend/src/api.ts
@@ -7,6 +7,8 @@ import {
     AdminUserDTO,
     ApiKeyDTO,
     AppConfigDTO,
+    ApplyPushDTO,
+    CallToActionKind,
     CatalogDTO,
     ComparisonClauseDTO,
     CreateFeedbackDTO,
@@ -39,6 +41,7 @@ import {
     PrepareImportProjectDTO,
     ProjectDTO,
     ProjectPostDTO,
+    PushKind,
     RoleDTO,
     RowFilterDTO,
     SetupDTO,
@@ -204,7 +207,7 @@ function downloadURL(urlString) {
 
 export const api = {
     async getHuggingFaceSpacesToken(spaceId: string) {
-      return await huggingface.get<unknown, any>(`https://huggingface.co/api/spaces/${spaceId}/jwt`);
+        return await huggingface.get<unknown, any>(`https://huggingface.co/api/spaces/${spaceId}/jwt`);
     },
     async logInGetToken(username: string, password: string) {
         return apiV2.post<unknown, JWTToken>(`/authenticate`, {username, password});
@@ -259,7 +262,7 @@ export const api = {
         return apiV2.delete<unknown, void>(`/admin/users/${login}`);
     },
     async disableUser(login: string) {
-      return apiV2.patch<unknown, void>(`/admin/users/${login}/disable`);
+        return apiV2.patch<unknown, void>(`/admin/users/${login}/disable`);
     },
     async enableUser(login: string) {
         return apiV2.patch<unknown, void>(`/admin/users/${login}/enable`);
@@ -441,82 +444,97 @@ export const api = {
         return apiV2.post<unknown, PredictionDTO>(`/models/${modelId}/predict`, data, {signal: controller.signal});
     },
 
-  async prepareInspection(payload: InspectionCreateDTO) {
-    return apiV2.post<unknown, InspectionDTO>(`/inspection`, payload);
-  },
-  async explain(modelId: string, datasetId: string, inputData: object, controller: AbortController) {
-    return apiV2.post<unknown, ExplainResponseDTO>(
-      `/models/${modelId}/explain/${datasetId}`,
-      { features: inputData },
-      { signal: controller.signal }
-    );
-  },
-  async explainText(modelId: string, datasetId: string, inputData: object, featureName: string) {
-    return apiV2.post<unknown, ExplainTextResponseDTO>(
-      `/models/explain-text/${featureName}`,
-      {
-        features: inputData,
-      },
-      { params: { modelId, datasetId } }
-    );
-  },
-  // feedbacks
-  async submitFeedback(payload: CreateFeedbackDTO, projectId: number) {
-    return apiV2.post<unknown, void>(`/feedbacks/${projectId}`, payload);
-  },
-  async getProjectFeedbacks(projectId: number) {
-    return apiV2.get<unknown, FeedbackMinimalDTO[]>(`/feedbacks/all/${projectId}`);
-  },
-  async getFeedback(id: number) {
-    return apiV2.get<unknown, FeedbackDTO>(`/feedbacks/${id}`);
-  },
-  async replyToFeedback(feedbackId: number, content: string, replyToId: number | null = null) {
-    return apiV2.post<unknown, void>(`/feedbacks/${feedbackId}/reply`, <CreateFeedbackReplyDTO>{
-      content,
-      replyToReply: replyToId
-    });
-  },
-  async deleteFeedback(id: number) {
-    return apiV2.delete<unknown, void>(`/feedbacks/${id}`);
-  },
-  async deleteFeedbackReply(feedbackId: number, replyId: number) {
-    return apiV2.delete<unknown, void>(`/feedbacks/${feedbackId}/replies/${replyId}`);
-  },
-  async runAdHocTest(projectId: number, testUuid: string, inputs: Array<FunctionInputDTO>, sample: boolean, debug: boolean = false) {
-    return apiV2.post<unknown, TestTemplateExecutionResultDTO>(`/testing/tests/run-test?sample=${sample}`, {
-      projectId,
-      testUuid,
-      inputs,
-      debug
-    });
-  },
-  async getCatalog(projectId: number) {
-    return apiV2.get<unknown, CatalogDTO>(`/catalog`, {
-      params: {
-        projectId
-      }
-    });
-  },
-  async createSlicingFunction(comparisonClauses: Array<ComparisonClauseDTO>) {
-    return apiV2.post<unknown, SlicingFunctionDTO>(`/slices/no-code`, comparisonClauses);
-  },
-  async uploadLicense(form: FormData) {
-    return apiV2.post<unknown, unknown>(`/ee/license`, form, {
-      headers: {
-        'Content-Type': 'multipart/form-data',
-      },
-    });
-  },
-  async finalizeSetup(allowAnalytics: boolean, license: string) {
-    return apiV2.post<SetupDTO, unknown>(`/setup`, {
-      allowAnalytics: allowAnalytics,
-      license: license,
-    });
-  },
-  async datasetProcessing(projectId: number, datasetUuid: string, functions: Array<ParameterizedCallableDTO>, sample: boolean = true) {
-    return apiV2.post<unknown, DatasetProcessingResultDTO>(
-      `/project/${projectId}/datasets/${encodeURIComponent(datasetUuid)}/process?sample=${sample}`,
-      functions
-    );
-  },
+    async prepareInspection(payload: InspectionCreateDTO) {
+        return apiV2.post<unknown, InspectionDTO>(`/inspection`, payload);
+    },
+    async explain(modelId: string, datasetId: string, inputData: object, controller: AbortController) {
+        return apiV2.post<unknown, ExplainResponseDTO>(
+            `/models/${modelId}/explain/${datasetId}`,
+            {features: inputData},
+            {signal: controller.signal}
+        );
+    },
+    async explainText(modelId: string, datasetId: string, inputData: object, featureName: string) {
+        return apiV2.post<unknown, ExplainTextResponseDTO>(
+            `/models/explain-text/${featureName}`,
+            {
+                features: inputData,
+            },
+            {params: {modelId, datasetId}}
+        );
+    },
+    // feedbacks
+    async submitFeedback(payload: CreateFeedbackDTO, projectId: number) {
+        return apiV2.post<unknown, void>(`/feedbacks/${projectId}`, payload);
+    },
+    async getProjectFeedbacks(projectId: number) {
+        return apiV2.get<unknown, FeedbackMinimalDTO[]>(`/feedbacks/all/${projectId}`);
+    },
+    async getFeedback(id: number) {
+        return apiV2.get<unknown, FeedbackDTO>(`/feedbacks/${id}`);
+    },
+    async replyToFeedback(feedbackId: number, content: string, replyToId: number | null = null) {
+        return apiV2.post<unknown, void>(`/feedbacks/${feedbackId}/reply`, <CreateFeedbackReplyDTO>{
+            content,
+            replyToReply: replyToId
+        });
+    },
+    async deleteFeedback(id: number) {
+        return apiV2.delete<unknown, void>(`/feedbacks/${id}`);
+    },
+    async deleteFeedbackReply(feedbackId: number, replyId: number) {
+        return apiV2.delete<unknown, void>(`/feedbacks/${feedbackId}/replies/${replyId}`);
+    },
+    async runAdHocTest(projectId: number, testUuid: string, inputs: Array<FunctionInputDTO>, sample: boolean, debug: boolean = false) {
+        return apiV2.post<unknown, TestTemplateExecutionResultDTO>(`/testing/tests/run-test?sample=${sample}`, {
+            projectId,
+            testUuid,
+            inputs,
+            debug
+        });
+    },
+    async getCatalog(projectId: number) {
+        return apiV2.get<unknown, CatalogDTO>(`/catalog`, {
+            params: {
+                projectId
+            }
+        });
+    },
+    async createSlicingFunction(comparisonClauses: Array<ComparisonClauseDTO>) {
+        return apiV2.post<unknown, SlicingFunctionDTO>(`/slices/no-code`, comparisonClauses);
+    },
+    async uploadLicense(form: FormData) {
+        return apiV2.post<unknown, unknown>(`/ee/license`, form, {
+            headers: {
+                'Content-Type': 'multipart/form-data',
+            },
+        });
+    },
+    async finalizeSetup(allowAnalytics: boolean, license: string) {
+        return apiV2.post<SetupDTO, unknown>(`/setup`, {
+            allowAnalytics: allowAnalytics,
+            license: license,
+        });
+    },
+    async datasetProcessing(projectId: number, datasetUuid: string, functions: Array<ParameterizedCallableDTO>, sample: boolean = true) {
+        return apiV2.post<unknown, DatasetProcessingResultDTO>(
+            `/project/${projectId}/datasets/${encodeURIComponent(datasetUuid)}/process?sample=${sample}`,
+            functions
+        );
+    },
+    async getPushes(modelId: string, datasetId: string, idx: number, features: any) {
+        return apiV2.post<unknown, unknown>(`/pushes/${modelId}/${datasetId}/${idx}`, {
+            features: features
+        });
+    },
+    async applyPush(modelId: string, datasetId: string, idx: number, pushKind: PushKind, ctaKind: CallToActionKind, features: any) {
+        return apiV2.post<ApplyPushDTO, void>(`/push/apply`, {
+            modelId,
+            datasetId,
+            rowIdx: idx,
+            pushKind: pushKind,
+            ctaKind: ctaKind,
+            features: features
+        });
+    },
 };
diff --git a/frontend/src/components/PushPopover.vue b/frontend/src/components/PushPopover.vue
new file mode 100644
index 0000000000..85c3f08d18
--- /dev/null
+++ b/frontend/src/components/PushPopover.vue
@@ -0,0 +1,254 @@
+<template>
+  <v-menu offset-x bottom :close-on-content-click="false" v-model="opened" v-if="show">
+    <template v-slot:activator="{ on: onMenu }">
+      <v-tooltip right>
+        <template v-slot:activator='{ on: onTooltip }'>
+          <v-btn small icon outlined color="warning" class="ml-1 ripple"
+                 v-on="{ ...onMenu, ...onTooltip }" v-if="show">
+            <div class="rim1"></div>
+            <v-icon size="18" color="warning">mdi-alert-outline</v-icon>
+          </v-btn>
+        </template>
+        <span>{{ push.push_title }}. Click for more details.</span>
+      </v-tooltip>
+    </template>
+
+
+    <v-card dark color="primary" class="push-card">
+      <v-card-title>
+        {{ push.push_title }}
+      </v-card-title>
+      <v-card-text>
+        <v-list light two-line>
+          <template v-for="detail in push.push_details">
+            <v-list-item>
+              <v-list-item-content>
+                <v-list-item-title>
+                  {{ detail.action }}
+                </v-list-item-title>
+                <v-list-item-subtitle>
+                  {{ detail.explanation }}
+                </v-list-item-subtitle>
+              </v-list-item-content>
+              <v-list-item-action>
+                <v-btn small text color="primary" :loading="detail.cta === loading" @click="applyCta(detail.cta)">
+                  {{ detail.button }}
+                </v-btn>
+              </v-list-item-action>
+            </v-list-item>
+            <v-divider/>
+          </template>
+        </v-list>
+      </v-card-text>
+    </v-card>
+
+  </v-menu>
+</template>
+
+<script setup lang="ts">
+import {computed, ref, watch} from 'vue';
+import {usePushStore} from "@/stores/push";
+import {useMainStore} from "@/stores/main";
+import {useCatalogStore} from "@/stores/catalog";
+import {storeToRefs} from "pinia";
+import {useProjectStore} from "@/stores/project";
+import {useDebuggingSessionsStore} from "@/stores/debugging-sessions";
+import {$vfm} from "vue-final-modal";
+import AddTestToSuite from "@/views/main/project/modals/AddTestToSuite.vue";
+import {chain} from "lodash";
+import {TYPE} from "vue-toastification";
+import {CallToActionKind, PushActionDTO, PushKind, RowFilterType} from "@/generated-sources";
+import mixpanel from "mixpanel-browser";
+
+const pushStore = usePushStore();
+const mainStore = useMainStore();
+const {slicingFunctionsByUuid, testFunctionsByUuid} = storeToRefs(useCatalogStore())
+const catalogStore = useCatalogStore();
+const projectStore = useProjectStore();
+const debuggingStore = useDebuggingSessionsStore();
+
+interface Props {
+  type: string;
+  column?: string;
+}
+
+const props = defineProps<Props>();
+
+const opened = ref<boolean>(false);
+const loading = ref<CallToActionKind>(CallToActionKind.None);
+const value = computed(() => {
+  return pushStore.current;
+});
+
+const show = computed(() => {
+  if (value.value == undefined) return false;
+
+  switch (props.type) {
+    case "contribution":
+      return value.value.contribution?.kind !== PushKind.Invalid && value.value.contribution?.key == props.column;
+    case "perturbation":
+      return value.value.perturbation?.kind !== PushKind.Invalid && value.value.perturbation?.key == props.column;
+    case "overconfidence":
+      return value.value.overconfidence?.kind !== PushKind.Invalid && value.value.overconfidence.push_title !== "";
+    case "borderline":
+      return value.value.borderline?.kind !== PushKind.Invalid && value.value.borderline.push_title !== "";
+    default:
+      return false;
+  }
+})
+
+const push = computed(() => {
+  return value.value?.hasOwnProperty(props.type) ? value.value[props.type] : undefined;
+})
+
+const icon = computed(() => {
+  switch (props.type) {
+    case "contribution":
+      return "mdi-chart-bar";
+    case "perturbation":
+      return "mdi-waveform";
+    case "overconfidence":
+      return "mdi-chevron-triple-up";
+    case "borderline":
+      return "mdi-approximately-equal";
+    default:
+      return "mdi-bug";
+  }
+});
+
+async function applyCta(kind: CallToActionKind) {
+  mixpanel.track("push:call_to_action", {kind: kind});
+  loading.value = kind;
+  let action: PushActionDTO = (await pushStore.applyPush(push.value!.kind, kind)).action;
+  switch (kind) {
+    case CallToActionKind.CreateSlice:
+      mainStore.addSimpleNotification("Successfully saved");
+      break;
+    case CallToActionKind.CreateSliceOpenDebugger:
+      await catalogStore.loadCatalog(projectStore.currentProjectId ?? 0);
+      const slice = slicingFunctionsByUuid.value[action.object_uuid];
+      if (slice !== undefined) {
+        debuggingStore.setCurrentSlicingFunctionUuid(action.object_uuid);
+        mainStore.addSimpleNotification("Slice applied");
+      } else {
+        mainStore.addNotification({content: 'Could not load slice', color: TYPE.ERROR});
+      }
+      break;
+    case CallToActionKind.CreateTest:
+    case CallToActionKind.AddTestToCatalog:
+      await catalogStore.loadCatalog(projectStore.currentProjectId ?? 0);
+      const test = testFunctionsByUuid.value[action.object_uuid];
+      if (test !== undefined) {
+        addToTestSuite(test, action.arguments);
+      } else {
+        mainStore.addNotification({content: 'Could not load test', color: TYPE.ERROR});
+      }
+      break;
+    case CallToActionKind.SavePerturbation:
+      mainStore.addSimpleNotification("Perturbation saved");
+      break;
+    case CallToActionKind.OpenDebuggerBorderline:
+      debuggingStore.setSelectedFilter({value: RowFilterType.BORDERLINE, label: 'Underconfidence', disabled: false});
+      break;
+    case CallToActionKind.OpenDebuggerOverconfidence:
+      // Programmatically apply Overconfidence filter
+      break;
+    case CallToActionKind.SaveExample:
+      mainStore.addSimpleNotification("This feature is not yet implemented.");
+      break;
+    default:
+      break;
+  }
+  loading.value = CallToActionKind.None;
+  opened.value = false;
+}
+
+function addToTestSuite(test, parameters) {
+  $vfm.show({
+    component: AddTestToSuite,
+    bind: {
+      projectId: projectStore.currentProjectId ?? 0,
+      test: test,
+      suiteId: null,
+      hideFixedInputs: true,
+      testArguments: chain(test.args)
+          .keyBy('name')
+          .mapValues(arg => {
+            let json = parameters[arg.name];
+            let value = arg.optional ? arg.defaultValue : null;
+
+            if (json != undefined) {
+              let object = JSON.parse(json);
+              if (object.hasOwnProperty('value')) {
+                value = object.value;
+              }
+            }
+
+            return {
+              name: arg.name,
+              isAlias: false,
+              type: arg.type,
+              value: value,
+            };
+          })
+          .value()
+    }
+  });
+}
+
+watch(() => opened, (newValue, oldValue) => {
+  if (newValue) {
+    mixpanel.track("push:open", {type: props.type});
+  }
+})
+
+</script>
+
+<style scoped>
+.v-tooltip__content,
+.push-card {
+  width: 40vw;
+}
+
+.rim1 {
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  border-radius: 50%;
+  width: 0em;
+  height: 0em;
+  border: white .5em solid;
+  background: orange;
+  z-index: 0;
+  animation: expand 2s ease-out infinite;
+}
+
+@keyframes expand {
+  0% {
+    top: calc(50% - .5em);
+    left: calc(50% - .5em);
+    width: 1em;
+    height: 1em;
+    border: white .25em solid;
+    opacity: 0.5;
+  }
+  100% {
+    top: calc(50% - 2em);
+    left: calc(50% - 2em);
+    width: 4em;
+    height: 4em;
+    border: white .5em solid;
+    opacity: 0;
+  }
+}
+
+.v-card__title {
+  font-size: 1.125rem;
+  line-height: 1.25rem;
+}
+
+.v-list-item__title,
+.v-list-item__subtitle {
+  white-space: normal;
+}
+</style>
\ No newline at end of file
diff --git a/frontend/src/components/TransformationPopover.vue b/frontend/src/components/TransformationPopover.vue
index 13b8c59672..bd79ac9696 100644
--- a/frontend/src/components/TransformationPopover.vue
+++ b/frontend/src/components/TransformationPopover.vue
@@ -1,32 +1,37 @@
 <template>
-    <v-menu offset-x :close-on-content-click='false' v-model='opened'>
-
-      <template v-slot:activator='{ on: onMenu }'>
-
-        <v-tooltip right>
-          <template v-slot:activator='{ on: onTooltip }'>
-            <v-btn small icon :color="hasTransformation ? 'primary' : 'grey'" v-on='{ ...onMenu, ...onTooltip }'>
-              <v-icon size='18'>mdi-swap-horizontal</v-icon>
-            </v-btn>
-          </template>
-          <span>Apply a transformation</span>
-        </v-tooltip>
-      </template>
-
-      <v-card dark color='primary'>
-        <v-card-title>
-          <p>Transformation for '{{ column }}'</p>
-        </v-card-title>
-        <v-card-text>
-          <TransformationFunctionSelector label='Transformation to apply' :column-type='columnType'
-                                          :column-name='column' :value.sync='transformation.uuid'
-                                          :args.sync='transformation.params' @onChanged='handleOnChanged'
-                                          :attach='false' />
-        </v-card-text>
-        <v-card-actions>
-        </v-card-actions>
-      </v-card>
-    </v-menu>
+  <v-menu offset-x :close-on-content-click='false' v-model='opened'>
+
+    <template v-slot:activator='{ on: onMenu }'>
+
+      <v-tooltip right>
+        <template v-slot:activator='{ on: onTooltip }'>
+          <v-btn small icon
+                 :color="hasTransformation ? 'primary' : 'grey'"
+                 v-on='{ ...onMenu, ...onTooltip }'>
+            <v-icon size='18'>mdi-swap-horizontal</v-icon>
+          </v-btn>
+        </template>
+        <span>Apply a transformation</span>
+      </v-tooltip>
+    </template>
+
+    <v-card dark color='primary'>
+      <v-card-title>
+        <p>Transformation for '{{ column }}'</p>
+      </v-card-title>
+      <v-card-text>
+        <TransformationFunctionSelector label='Transformation to apply'
+                                        :column-type='columnType'
+                                        :column-name='column'
+                                        :value.sync='transformation.uuid'
+                                        :args.sync='transformation.params'
+                                        @onChanged='handleOnChanged'
+                                          :attach='false'/>
+      </v-card-text>
+      <v-card-actions>
+      </v-card-actions>
+    </v-card>
+  </v-menu>
 </template>
 
 <script setup lang="ts">
@@ -55,7 +60,7 @@ const { transformationFunctions } = storeToRefs(inspectionStore)
 const hasTransformation = computed(() => transformationFunctions.hasOwnProperty(props.column));
 
 function handleOnChanged() {
-    inspectionStore.setTransformation(props.column, transformation.value);
+  inspectionStore.setTransformation(props.column, transformation.value);
 }
 
 </script>
@@ -63,40 +68,40 @@ function handleOnChanged() {
 <style scoped lang="scss">
 div.v-card {
 
-    opacity: 0.98;
-    max-width: 500px;
+  opacity: 0.98;
+  max-width: 500px;
 
-    &>*:nth-child(-n + 2) {
+  &>*:nth-child(-n + 2) {
         // for the first two children: the title and the content
-        padding-bottom: 0px;
-    }
-
-    .v-card__title {
-        font-size: 1rem;
-        padding-top: 8px;
-        word-break: normal;
-        line-height: 22px;
-    }
-
-    .v-input {
-        margin-top: 4px;
-        margin-bottom: 6px;
-    }
-
-    .v-card__actions {
-        display: flex;
-        justify-content: flex-end;
-        align-items: center;
-        font-size: 13px;
-        color: white;
-
-        * {
-            margin: 0 3px
-        }
+    padding-bottom: 0px;
+  }
+
+  .v-card__title {
+    font-size: 1rem;
+    padding-top: 8px;
+    word-break: normal;
+    line-height: 22px;
+  }
+
+  .v-input {
+    margin-top: 4px;
+    margin-bottom: 6px;
+  }
+
+  .v-card__actions {
+    display: flex;
+    justify-content: flex-end;
+    align-items: center;
+    font-size: 13px;
+    color: white;
+
+    * {
+      margin: 0 3px
     }
+  }
 }
 
 .v-chip {
-    padding: 8px
+  padding: 8px
 }
 </style>
diff --git a/frontend/src/generated-sources/ai/giskard/domain/ml/call-to-action-kind.ts b/frontend/src/generated-sources/ai/giskard/domain/ml/call-to-action-kind.ts
new file mode 100644
index 0000000000..a201bea138
--- /dev/null
+++ b/frontend/src/generated-sources/ai/giskard/domain/ml/call-to-action-kind.ts
@@ -0,0 +1,17 @@
+/**
+ * Generated from ai.giskard.domain.ml.CallToActionKind
+ */
+export enum CallToActionKind {
+    None = 0,
+    CreateSlice = 1,
+    CreateTest = 2,
+    CreatePerturbation = 3,
+    SavePerturbation = 4,
+    CreateRobustnessTest = 5,
+    CreateSliceOpenDebugger = 6,
+    OpenDebuggerBorderline = 7,
+    AddTestToCatalog = 8,
+    SaveExample = 9,
+    OpenDebuggerOverconfidence = 10,
+    CreateUnitTest = 11
+}
\ No newline at end of file
diff --git a/frontend/src/generated-sources/ai/giskard/domain/ml/push-kind.ts b/frontend/src/generated-sources/ai/giskard/domain/ml/push-kind.ts
new file mode 100644
index 0000000000..92e5aa60c1
--- /dev/null
+++ b/frontend/src/generated-sources/ai/giskard/domain/ml/push-kind.ts
@@ -0,0 +1,10 @@
+/**
+ * Generated from ai.giskard.domain.ml.PushKind
+ */
+export enum PushKind {
+    Invalid = 'Invalid',
+    Perturbation = 'Perturbation',
+    Contribution = 'Contribution',
+    Overconfidence = 'Overconfidence',
+    Borderline = 'Borderline'
+}
\ No newline at end of file
diff --git a/frontend/src/generated-sources/ai/giskard/web/dto/apply-push-dto.ts b/frontend/src/generated-sources/ai/giskard/web/dto/apply-push-dto.ts
new file mode 100644
index 0000000000..f0470663b2
--- /dev/null
+++ b/frontend/src/generated-sources/ai/giskard/web/dto/apply-push-dto.ts
@@ -0,0 +1,14 @@
+import type {CallToActionKind} from './../../domain/ml/call-to-action-kind';
+import type {PushKind} from './../../domain/ml/push-kind';
+
+/**
+ * Generated from ai.giskard.web.dto.ApplyPushDTO
+ */
+export interface ApplyPushDTO {
+    ctaKind: CallToActionKind;
+    datasetId: string;
+    features: {[key: string]: string};
+    modelId: string;
+    pushKind: PushKind;
+    rowIdx: number;
+}
\ No newline at end of file
diff --git a/frontend/src/generated-sources/ai/giskard/web/dto/push-action-dto.ts b/frontend/src/generated-sources/ai/giskard/web/dto/push-action-dto.ts
new file mode 100644
index 0000000000..89e2f6c447
--- /dev/null
+++ b/frontend/src/generated-sources/ai/giskard/web/dto/push-action-dto.ts
@@ -0,0 +1,7 @@
+/**
+ * Generated from ai.giskard.web.dto.PushActionDTO
+ */
+export interface PushActionDTO {
+    object_uuid: string;
+    arguments: { [key: string]: string };
+}
\ No newline at end of file
diff --git a/frontend/src/generated-sources/ai/giskard/web/dto/push-details-dto.ts b/frontend/src/generated-sources/ai/giskard/web/dto/push-details-dto.ts
new file mode 100644
index 0000000000..3e5f50e1e3
--- /dev/null
+++ b/frontend/src/generated-sources/ai/giskard/web/dto/push-details-dto.ts
@@ -0,0 +1,8 @@
+/**
+ * Generated from ai.giskard.web.dto.PushDetailsDTO
+ */
+export interface PushDetailsDTO {
+    action: string;
+    button: string;
+    explanation: string;
+}
\ No newline at end of file
diff --git a/frontend/src/generated-sources/ai/giskard/web/dto/push-dto.ts b/frontend/src/generated-sources/ai/giskard/web/dto/push-dto.ts
new file mode 100644
index 0000000000..0fd5741c9c
--- /dev/null
+++ b/frontend/src/generated-sources/ai/giskard/web/dto/push-dto.ts
@@ -0,0 +1,14 @@
+import type {PushDetailsDTO} from './push-details-dto';
+import {PushKind} from "@/generated-sources";
+
+/**
+ * Generated from ai.giskard.web.dto.PushDTO
+ */
+export interface PushDTO {
+    details: PushDetailsDTO[];
+    key: string;
+    perturbationValue: string;
+    push_title: string;
+    value: string;
+    kind: PushKind;
+}
\ No newline at end of file
diff --git a/frontend/src/generated-sources/index.ts b/frontend/src/generated-sources/index.ts
index 3534c90829..a8795150b4 100644
--- a/frontend/src/generated-sources/index.ts
+++ b/frontend/src/generated-sources/index.ts
@@ -1,9 +1,11 @@
 export const GENERATED_MAPPING = {
     'ai.giskard.domain.ColumnType' : 'ColumnType',
     'ai.giskard.domain.GeneralSettings' : 'GeneralSettings',
+    'ai.giskard.domain.ml.CallToActionKind' : 'CallToActionKind',
     'ai.giskard.domain.ml.CodeLanguage' : 'CodeLanguage',
     'ai.giskard.domain.ml.ModelLanguage' : 'ModelLanguage',
     'ai.giskard.domain.ml.ModelType' : 'ModelType',
+    'ai.giskard.domain.ml.PushKind' : 'PushKind',
     'ai.giskard.domain.ml.table.Filter' : 'Filter',
     'ai.giskard.domain.ml.table.RegressionUnit' : 'RegressionUnit',
     'ai.giskard.domain.ml.table.RowFilterType' : 'RowFilterType',
@@ -14,6 +16,7 @@ export const GENERATED_MAPPING = {
     'ai.giskard.ml.dto.MLWorkerWSTestMessageType' : 'MLWorkerWSTestMessageType',
     'ai.giskard.service.ee.FeatureFlag' : 'FeatureFlag',
     'ai.giskard.web.dto.ApiKeyDTO' : 'ApiKeyDTO',
+    'ai.giskard.web.dto.ApplyPushDTO' : 'ApplyPushDTO',
     'ai.giskard.web.dto.CallableDTO' : 'CallableDTO',
     'ai.giskard.web.dto.CatalogDTO' : 'CatalogDTO',
     'ai.giskard.web.dto.ComparisonClauseDTO' : 'ComparisonClauseDTO',
@@ -73,6 +76,9 @@ export const GENERATED_MAPPING = {
     'ai.giskard.web.dto.PrepareDeleteDTO$LightFeedback' : 'PrepareDeleteDTO.LightFeedback',
     'ai.giskard.web.dto.PrepareDeleteDTO' : 'PrepareDeleteDTO',
     'ai.giskard.web.dto.PrepareImportProjectDTO' : 'PrepareImportProjectDTO',
+    'ai.giskard.web.dto.PushActionDTO' : 'PushActionDTO',
+    'ai.giskard.web.dto.PushDetailsDTO' : 'PushDetailsDTO',
+    'ai.giskard.web.dto.PushDTO' : 'PushDTO',
     'ai.giskard.web.dto.RequiredInputDTO' : 'RequiredInputDTO',
     'ai.giskard.web.dto.RowFilterDTO' : 'RowFilterDTO',
     'ai.giskard.web.dto.RunAdhocTestRequest' : 'RunAdhocTestRequest',
@@ -98,9 +104,11 @@ export const GENERATED_MAPPING = {
 };
 export * from './ai/giskard/domain/column-type';
 export * from './ai/giskard/domain/general-settings';
+export * from './ai/giskard/domain/ml/call-to-action-kind';
 export * from './ai/giskard/domain/ml/code-language';
 export * from './ai/giskard/domain/ml/model-language';
 export * from './ai/giskard/domain/ml/model-type';
+export * from './ai/giskard/domain/ml/push-kind';
 export * from './ai/giskard/domain/ml/table/filter';
 export * from './ai/giskard/domain/ml/table/regression-unit';
 export * from './ai/giskard/domain/ml/table/row-filter-type';
@@ -111,6 +119,7 @@ export * from './ai/giskard/jobs/job-type';
 export * from './ai/giskard/ml/dto/mlworker-wstest-message-type';
 export * from './ai/giskard/service/ee/feature-flag';
 export * from './ai/giskard/web/dto/api-key-dto';
+export * from './ai/giskard/web/dto/apply-push-dto';
 export * from './ai/giskard/web/dto/callable-dto';
 export * from './ai/giskard/web/dto/catalog-dto';
 export * from './ai/giskard/web/dto/comparison-clause-dto';
@@ -166,6 +175,9 @@ export * from './ai/giskard/web/dto/prediction-dto';
 export * from './ai/giskard/web/dto/prediction-input-dto';
 export * from './ai/giskard/web/dto/prepare-delete-dto';
 export * from './ai/giskard/web/dto/prepare-import-project-dto';
+export * from './ai/giskard/web/dto/push-action-dto';
+export * from './ai/giskard/web/dto/push-details-dto';
+export * from './ai/giskard/web/dto/push-dto';
 export * from './ai/giskard/web/dto/required-input-dto';
 export * from './ai/giskard/web/dto/row-filter-dto';
 export * from './ai/giskard/web/dto/run-adhoc-test-request';
diff --git a/frontend/src/generated-sources/j2ts-generated-metadata.json b/frontend/src/generated-sources/j2ts-generated-metadata.json
index a79e31d94f..660dac7aee 100644
--- a/frontend/src/generated-sources/j2ts-generated-metadata.json
+++ b/frontend/src/generated-sources/j2ts-generated-metadata.json
@@ -6,70 +6,42 @@
     "ai.giskard.domain.ml.table.RowFilterType": "RowFilterType",
     "ai.giskard.jobs.JobType": "JobType",
     "ai.giskard.web.dto.GenerateTestSuiteInputDTO": "GenerateTestSuiteInputDTO",
-    "ai.giskard.web.dto.ml.TestTemplateExecutionResultDTO": "TestTemplateExecutionResultDTO",
     "ai.giskard.web.dto.user.PasswordChangeDTO": "PasswordChangeDTO",
     "ai.giskard.web.dto.FeedbackReplyDTO": "FeedbackReplyDTO",
-    "ai.giskard.web.dto.ml.write.FilePostDTO": "FilePostDTO",
-    "ai.giskard.domain.ColumnType": "ColumnType",
     "ai.giskard.web.dto.ml.ExecuteTestSuiteRequest": "ExecuteTestSuiteRequest",
-    "ai.giskard.web.dto.ml.SuiteTestExecutionDTO": "SuiteTestExecutionDTO",
-    "ai.giskard.web.dto.TransformationResultMessageDTO": "TransformationResultMessageDTO",
-    "ai.giskard.web.rest.vm.TokenAndPasswordVM": "TokenAndPasswordVM",
-    "ai.giskard.web.dto.PrepareDeleteDTO": "PrepareDeleteDTO",
-    "ai.giskard.web.dto.ml.ProjectDTO": "ProjectDTO",
-    "ai.giskard.web.dto.CreateFeedbackReplyDTO": "CreateFeedbackReplyDTO",
     "ai.giskard.web.dto.PasswordResetRequest": "PasswordResetRequest",
     "ai.giskard.web.dto.user.UserMinimalDTO": "UserMinimalDTO",
-    "ai.giskard.web.dto.ApiKeyDTO": "ApiKeyDTO",
     "ai.giskard.web.dto.ml.ModelDTO": "ModelDTO",
     "ai.giskard.web.dto.ml.SingleTestResultDTO": "SingleTestResultDTO",
     "ai.giskard.web.dto.config.AppConfigDTO$AppInfoDTO": "AppConfigDTO.AppInfoDTO",
     "ai.giskard.domain.ml.table.Filter": "Filter",
     "ai.giskard.web.dto.TestFunctionDTO": "TestFunctionDTO",
-    "ai.giskard.web.dto.user.UpdateMeDTO": "UpdateMeDTO",
     "ai.giskard.web.dto.user.AdminUserDTO": "AdminUserDTO",
-    "ai.giskard.web.dto.config.MLWorkerInfoDTO": "MLWorkerInfoDTO",
-    "ai.giskard.web.dto.PostImportProjectDTO": "PostImportProjectDTO",
     "ai.giskard.web.dto.DatasetMetadataDTO": "DatasetMetadataDTO",
     "ai.giskard.web.dto.ml.CodeBasedTestPresetDTO": "CodeBasedTestPresetDTO",
-    "ai.giskard.web.dto.TestSuiteCompleteDTO": "TestSuiteCompleteDTO",
     "ai.giskard.web.dto.SuiteTestDTO": "SuiteTestDTO",
     "ai.giskard.web.dto.DatasetProcessFunctionType": "DatasetProcessFunctionType",
     "ai.giskard.jobs.JobState": "JobState",
-    "ai.giskard.web.dto.SlicingFunctionDTO": "SlicingFunctionDTO",
+    "ai.giskard.domain.ml.PushKind": "PushKind",
     "ai.giskard.web.dto.GenerateTestSuiteDTO": "GenerateTestSuiteDTO",
     "ai.giskard.web.dto.ml.TestExecutionStatusDTO": "TestExecutionStatusDTO",
-    "ai.giskard.web.dto.ExplainTextResponseDTO": "ExplainTextResponseDTO",
-    "ai.giskard.web.dto.JWTToken": "JWTToken",
-    "ai.giskard.web.dto.ModelUploadParamsDTO": "ModelUploadParamsDTO",
     "ai.giskard.web.dto.RequiredInputDTO": "RequiredInputDTO",
+    "ai.giskard.web.dto.ApplyPushDTO": "ApplyPushDTO",
     "ai.giskard.web.dto.CreateFeedbackDTO": "CreateFeedbackDTO",
-    "ai.giskard.web.dto.TransformationFunctionDTO": "TransformationFunctionDTO",
-    "ai.giskard.web.dto.ml.write.ModelPostDTO": "ModelPostDTO",
     "ai.giskard.web.rest.vm.ManagedUserVM": "ManagedUserVM",
-    "ai.giskard.web.dto.CatalogDTO": "CatalogDTO",
     "ai.giskard.web.dto.PrepareDeleteDTO$LightTestSuite": "PrepareDeleteDTO.LightTestSuite",
-    "ai.giskard.web.dto.ml.NamedSingleTestResultDTO": "NamedSingleTestResultDTO",
     "ai.giskard.web.dto.user.RoleDTO": "RoleDTO",
     "ai.giskard.web.dto.FunctionInputDTO": "FunctionInputDTO",
     "ai.giskard.web.dto.config.LicenseDTO": "LicenseDTO",
     "ai.giskard.web.dto.ComparisonType": "ComparisonType",
     "ai.giskard.web.dto.FeedbackMinimalDTO": "FeedbackMinimalDTO",
-    "ai.giskard.web.dto.ml.DatasetDTO": "DatasetDTO",
     "ai.giskard.web.dto.PrepareDeleteDTO$LightFeedback": "PrepareDeleteDTO.LightFeedback",
-    "ai.giskard.web.dto.PredictionDTO": "PredictionDTO",
-    "ai.giskard.web.dto.user.AdminUserDTO$AdminUserDTOWithPassword": "AdminUserDTO.AdminUserDTOWithPassword",
-    "ai.giskard.web.dto.PrepareImportProjectDTO": "PrepareImportProjectDTO",
     "ai.giskard.web.dto.TestSuiteDTO": "TestSuiteDTO",
-    "ai.giskard.web.dto.FilterDatasetDTO": "FilterDatasetDTO",
-    "ai.giskard.web.dto.ml.TestResultMessageDTO": "TestResultMessageDTO",
-    "ai.giskard.web.dto.DataUploadParamsDTO": "DataUploadParamsDTO",
     "ai.giskard.web.dto.ml.write.TestSuitePostDTO": "TestSuitePostDTO",
     "ai.giskard.domain.ml.ModelLanguage": "ModelLanguage",
     "ai.giskard.web.dto.ml.TestSuiteExecutionDTO": "TestSuiteExecutionDTO",
     "ai.giskard.web.dto.FeedbackDTO": "FeedbackDTO",
     "ai.giskard.web.dto.JobDTO": "JobDTO",
-    "ai.giskard.web.dto.RowFilterDTO": "RowFilterDTO",
     "ai.giskard.domain.ml.ModelType": "ModelType",
     "ai.giskard.web.dto.ml.ProjectPostDTO": "ProjectPostDTO",
     "ai.giskard.web.dto.config.MLWorkerInfoDTO$PlatformInfoDTO": "MLWorkerInfoDTO.PlatformInfoDTO",
@@ -77,24 +49,58 @@
     "ai.giskard.web.dto.SetupDTO": "SetupDTO",
     "ai.giskard.domain.ml.CodeLanguage": "CodeLanguage",
     "ai.giskard.web.dto.DatasetPageDTO": "DatasetPageDTO",
-    "ai.giskard.web.dto.ExplainResponseDTO": "ExplainResponseDTO",
-    "ai.giskard.web.dto.ModelMetadataDTO": "ModelMetadataDTO",
+    "ai.giskard.web.dto.PushDTO": "PushDTO",
     "ai.giskard.web.dto.DatasetProcessingResultDTO": "DatasetProcessingResultDTO",
-    "ai.giskard.web.dto.MessageDTO": "MessageDTO",
     "ai.giskard.domain.MLWorkerType": "MLWorkerType",
     "ai.giskard.web.dto.PredictionInputDTO": "PredictionInputDTO",
     "ai.giskard.web.dto.TestFunctionArgumentDTO": "TestFunctionArgumentDTO",
     "ai.giskard.web.dto.config.AppConfigDTO": "AppConfigDTO",
-    "ai.giskard.web.dto.ml.InspectionDTO": "InspectionDTO",
-    "ai.giskard.ml.dto.MLWorkerWSTestMessageType": "MLWorkerWSTestMessageType",
-    "ai.giskard.domain.GeneralSettings": "GeneralSettings",
     "ai.giskard.web.dto.ParameterizedCallableDTO": "ParameterizedCallableDTO",
     "ai.giskard.domain.ml.table.RegressionUnit": "RegressionUnit",
     "ai.giskard.web.dto.ComparisonClauseDTO": "ComparisonClauseDTO",
     "ai.giskard.web.dto.ml.TestEditorConfigDTO": "TestEditorConfigDTO",
-    "ai.giskard.web.dto.CallableDTO": "CallableDTO",
     "ai.giskard.service.ee.FeatureFlag": "FeatureFlag",
     "ai.giskard.domain.ml.TestResult": "TestResult",
-    "ai.giskard.web.dto.user.UserDTO": "UserDTO"
+    "ai.giskard.web.dto.user.UserDTO": "UserDTO",
+    "ai.giskard.web.dto.ml.TestTemplateExecutionResultDTO": "TestTemplateExecutionResultDTO",
+    "ai.giskard.web.dto.ml.write.FilePostDTO": "FilePostDTO",
+    "ai.giskard.domain.ColumnType": "ColumnType",
+    "ai.giskard.web.dto.ml.SuiteTestExecutionDTO": "SuiteTestExecutionDTO",
+    "ai.giskard.web.dto.TransformationResultMessageDTO": "TransformationResultMessageDTO",
+    "ai.giskard.web.rest.vm.TokenAndPasswordVM": "TokenAndPasswordVM",
+    "ai.giskard.web.dto.PrepareDeleteDTO": "PrepareDeleteDTO",
+    "ai.giskard.web.dto.ml.ProjectDTO": "ProjectDTO",
+    "ai.giskard.web.dto.CreateFeedbackReplyDTO": "CreateFeedbackReplyDTO",
+    "ai.giskard.web.dto.ApiKeyDTO": "ApiKeyDTO",
+    "ai.giskard.web.dto.user.UpdateMeDTO": "UpdateMeDTO",
+    "ai.giskard.web.dto.config.MLWorkerInfoDTO": "MLWorkerInfoDTO",
+    "ai.giskard.web.dto.PostImportProjectDTO": "PostImportProjectDTO",
+    "ai.giskard.web.dto.TestSuiteCompleteDTO": "TestSuiteCompleteDTO",
+    "ai.giskard.web.dto.SlicingFunctionDTO": "SlicingFunctionDTO",
+    "ai.giskard.domain.ml.CallToActionKind": "CallToActionKind",
+    "ai.giskard.web.dto.ExplainTextResponseDTO": "ExplainTextResponseDTO",
+    "ai.giskard.web.dto.JWTToken": "JWTToken",
+    "ai.giskard.web.dto.ModelUploadParamsDTO": "ModelUploadParamsDTO",
+    "ai.giskard.web.dto.TransformationFunctionDTO": "TransformationFunctionDTO",
+    "ai.giskard.web.dto.ml.write.ModelPostDTO": "ModelPostDTO",
+    "ai.giskard.web.dto.CatalogDTO": "CatalogDTO",
+    "ai.giskard.web.dto.ml.NamedSingleTestResultDTO": "NamedSingleTestResultDTO",
+    "ai.giskard.web.dto.PushActionDTO": "PushActionDTO",
+    "ai.giskard.web.dto.ml.DatasetDTO": "DatasetDTO",
+    "ai.giskard.web.dto.PredictionDTO": "PredictionDTO",
+    "ai.giskard.web.dto.user.AdminUserDTO$AdminUserDTOWithPassword": "AdminUserDTO.AdminUserDTOWithPassword",
+    "ai.giskard.web.dto.PrepareImportProjectDTO": "PrepareImportProjectDTO",
+    "ai.giskard.web.dto.FilterDatasetDTO": "FilterDatasetDTO",
+    "ai.giskard.web.dto.ml.TestResultMessageDTO": "TestResultMessageDTO",
+    "ai.giskard.web.dto.DataUploadParamsDTO": "DataUploadParamsDTO",
+    "ai.giskard.web.dto.RowFilterDTO": "RowFilterDTO",
+    "ai.giskard.web.dto.ExplainResponseDTO": "ExplainResponseDTO",
+    "ai.giskard.web.dto.ModelMetadataDTO": "ModelMetadataDTO",
+    "ai.giskard.web.dto.MessageDTO": "MessageDTO",
+    "ai.giskard.web.dto.PushDetailsDTO": "PushDetailsDTO",
+    "ai.giskard.web.dto.ml.InspectionDTO": "InspectionDTO",
+    "ai.giskard.ml.dto.MLWorkerWSTestMessageType": "MLWorkerWSTestMessageType",
+    "ai.giskard.domain.GeneralSettings": "GeneralSettings",
+    "ai.giskard.web.dto.CallableDTO": "CallableDTO"
   }
 }
\ No newline at end of file
diff --git a/frontend/src/stores/catalog.ts b/frontend/src/stores/catalog.ts
index 5fd0ed3aec..73eccaa801 100644
--- a/frontend/src/stores/catalog.ts
+++ b/frontend/src/stores/catalog.ts
@@ -6,10 +6,10 @@ import {
     DatasetDTO,
     DatasetProcessFunctionDTO
 } from '@/generated-sources';
-import {defineStore} from 'pinia';
-import {api} from '@/api';
-import {chain} from "lodash";
-import {getColumnType} from "@/utils/column-type-utils";
+import { defineStore } from 'pinia';
+import { api } from '@/api';
+import { chain } from 'lodash';
+import { getColumnType } from '@/utils/column-type-utils';
 
 interface State {
     catalog: CatalogDTO | null
@@ -18,7 +18,7 @@ interface State {
 
 function latestVersions<E extends CallableDTO>(data?: Array<E>): Array<E> {
     return chain(data ?? [])
-        .groupBy(func => `${func.module}.${func.name}`)
+      .groupBy(func => func.module ?? `${func.module}.${func.name}`)
         .mapValues(functions => chain(functions)
             .maxBy(func => func.version ?? 1)
             .value())
diff --git a/frontend/src/stores/debugging-sessions.ts b/frontend/src/stores/debugging-sessions.ts
index f8d8554280..25510e3419 100644
--- a/frontend/src/stores/debugging-sessions.ts
+++ b/frontend/src/stores/debugging-sessions.ts
@@ -1,51 +1,84 @@
-import { InspectionDTO, InspectionCreateDTO } from '@/generated-sources';
-import { defineStore } from 'pinia';
-import { api } from '@/api';
+import {InspectionCreateDTO, InspectionDTO, ParameterizedCallableDTO, RowFilterType} from '@/generated-sources';
+import {defineStore} from 'pinia';
+import {api} from '@/api';
+
+interface FilterType {
+    label: string;
+    value: RowFilterType;
+    disabled?: boolean;
+    description?: string;
+}
 
 interface State {
-  projectId: number | null;
-  debuggingSessions: Array<InspectionDTO>;
-  currentDebuggingSessionId: number | null;
+    projectId: number | null;
+    debuggingSessions: Array<InspectionDTO>;
+    currentDebuggingSessionId: number | null;
+    selectedSlicingFunction: Partial<ParameterizedCallableDTO>;
+    selectedFilter: FilterType | null
 }
 
 export const useDebuggingSessionsStore = defineStore('debuggingSessions', {
-  state: (): State => ({
-    projectId: null,
-    debuggingSessions: [],
-    currentDebuggingSessionId: null,
-  }),
-  getters: {},
-  actions: {
-    async reload() {
-      if (this.projectId !== null) {
-        await this.loadDebuggingSessions(this.projectId);
-      }
-    },
-    async loadDebuggingSessions(projectId: number) {
-      if (this.projectId !== projectId) {
-        this.projectId = projectId;
-        this.currentDebuggingSessionId = null;
-      }
-      this.debuggingSessions = await api.getProjectInspections(this.projectId);
-    },
-    async createDebuggingSession(inspection: InspectionCreateDTO) {
-      const newDebuggingSession = await api.prepareInspection(inspection);
-      await this.reload();
-      return newDebuggingSession;
-    },
-    async deleteDebuggingSession(inspectionId: number) {
-      await api.deleteInspection(inspectionId);
-      if (this.currentDebuggingSessionId === inspectionId) {
-        this.currentDebuggingSessionId = null;
-      }
-      await this.reload();
-    },
-    async updateDebuggingSessionName(inspectionId: number, inspection: InspectionCreateDTO) {
-      await api.updateInspectionName(inspectionId, inspection);
-      await this.reload();
-    },
-    setCurrentDebuggingSessionId(inspectionId: number | null) {
-      this.currentDebuggingSessionId = inspectionId;
+    state: (): State => ({
+        projectId: null,
+        debuggingSessions: [],
+        currentDebuggingSessionId: null,
+        selectedSlicingFunction: {
+            uuid: undefined,
+            params: [],
+            type: 'SLICING'
+        },
+        selectedFilter: null
+    }),
+    getters: {},
+    actions: {
+        async reload() {
+            if (this.projectId !== null) {
+                await this.loadDebuggingSessions(this.projectId);
+            }
+        },
+        clear() {
+            this.selectedSlicingFunction = {
+                uuid: undefined,
+                params: [],
+                type: 'SLICING'
+            }
+        },
+        async loadDebuggingSessions(projectId: number) {
+            if (this.projectId !== projectId) {
+                this.projectId = projectId;
+                this.currentDebuggingSessionId = null;
+            }
+            this.debuggingSessions = await api.getProjectInspections(this.projectId);
+        },
+        async createDebuggingSession(inspection: InspectionCreateDTO) {
+            const newDebuggingSession = await api.prepareInspection(inspection);
+            await this.reload();
+            return newDebuggingSession;
+        },
+        async deleteDebuggingSession(inspectionId: number) {
+            await api.deleteInspection(inspectionId);
+            if (this.currentDebuggingSessionId === inspectionId) {
+                this.currentDebuggingSessionId = null;
+            }
+            await this.reload();
+        },
+        async updateDebuggingSessionName(inspectionId: number, inspection: InspectionCreateDTO) {
+            await api.updateInspectionName(inspectionId, inspection);
+            await this.reload();
+        },
+        setCurrentDebuggingSessionId(inspectionId: number | null) {
+            this.currentDebuggingSessionId = inspectionId;
+            this.clear();
+        },
+        setCurrentSlicingFunctionUuid(uuid: string) {
+            this.selectedSlicingFunction = {
+                uuid: uuid,
+                params: [],
+                type: 'SLICING'
+            };
+        },
+        setSelectedFilter(filter: FilterType | null) {
+            this.selectedFilter = filter;
+        }
     },
-  },
 });
diff --git a/frontend/src/stores/push.ts b/frontend/src/stores/push.ts
new file mode 100644
index 0000000000..07d457eb34
--- /dev/null
+++ b/frontend/src/stores/push.ts
@@ -0,0 +1,61 @@
+import {CallToActionKind, PushDTO, PushKind} from "@/generated-sources";
+import {defineStore} from "pinia";
+import {api} from "@/api";
+
+interface State {
+    pushes: { [key: string]: Pushes };
+    current: Pushes | undefined;
+    identifier: PushIdentifier | undefined;
+}
+
+interface Pushes {
+    perturbation: PushDTO,
+    contribution: PushDTO,
+    borderline: PushDTO,
+    overconfidence: PushDTO
+}
+
+interface PushIdentifier {
+    modelId: string,
+    datasetId: string,
+    rowNb: number,
+    inputData: any,
+    modelFeatures: string[]
+}
+
+export const usePushStore = defineStore('push', {
+    state: (): State => ({
+        pushes: {},
+        current: undefined,
+        identifier: undefined,
+    }),
+    getters: {},
+    actions: {
+        async fetchPushSuggestions(modelId: string, datasetId: string, rowNb: number, inputData: any, modelFeatures: string[]) {
+            this.identifier = {modelId, datasetId, rowNb, inputData, modelFeatures};
+            let identifierString = JSON.stringify({modelId, datasetId, rowNb, inputData, modelFeatures});
+            let previous = this.current;
+            this.current = undefined;
+
+            let result = await api.getPushes(modelId, datasetId, rowNb, inputData);
+
+            if (previous == result) {
+                return;
+            }
+
+            let currentIdentifier = JSON.stringify(this.identifier);
+            if (currentIdentifier === identifierString) {
+                console.log("Setting pushes")
+                // @ts-ignore
+                this.current = result;
+            }
+
+            return this.current;
+        },
+        async applyPush(pushKind: PushKind, ctaKind: CallToActionKind): Promise<any> {
+            let result = await api.applyPush(this.identifier!.modelId, this.identifier!.datasetId, this.identifier!.rowNb, pushKind, ctaKind, this.identifier!.inputData);
+            // @ts-ignore
+            return result;
+        }
+    }
+})
\ No newline at end of file
diff --git a/frontend/src/utils/nametags.utils.ts b/frontend/src/utils/nametags.utils.ts
new file mode 100644
index 0000000000..716b8aea4b
--- /dev/null
+++ b/frontend/src/utils/nametags.utils.ts
@@ -0,0 +1,35 @@
+import {useProjectArtifactsStore} from "@/stores/project-artifacts";
+
+export function $tags(input: string): string {
+    if (input == undefined) {
+        return input;
+    }
+
+    const store = useProjectArtifactsStore();
+
+    // In the input, there will be tags such as: <model:uuid>, <dataset:uuid>
+    // The uuid is like model:b1d7dd0e-400c-421d-8b0e-721f852e77a8
+    // Grab their names from the stored data and replace it!
+    let result = input;
+    const modelRegex = /<model:(.*?)>/g;
+    // Can match: <dataset:uuid>, <*_dataset:uuid>
+    const datasetRegex = /<([a-z_]*_)?dataset:(.*?)>/g;
+    const modelMatches = input.matchAll(modelRegex);
+    const datasetMatches = input.matchAll(datasetRegex);
+
+    for (const match of modelMatches) {
+        const model = store.models.find(model => model.id === match[1]);
+        if (model) {
+            result = result.replace(match[0], $tags(model.name ?? "Unnamed model"));
+        }
+    }
+
+    for (const match of datasetMatches) {
+        const dataset = store.datasets.find(dataset => dataset.id === match[2]);
+        if (dataset) {
+            result = result.replace(match[0], $tags(dataset.name ?? "Unnamed dataset"));
+        }
+    }
+
+    return result;
+}
\ No newline at end of file
diff --git a/frontend/src/views/main/project/Datasets.vue b/frontend/src/views/main/project/Datasets.vue
index 406c0e6807..0f869e424a 100644
--- a/frontend/src/views/main/project/Datasets.vue
+++ b/frontend/src/views/main/project/Datasets.vue
@@ -2,7 +2,8 @@
   <div class="vertical-container">
     <v-row class="mt-2 pl-3">
       <v-col class="d-flex">
-        <v-text-field v-if="projectArtifactsStore.datasets.length" v-model='searchDataset' append-icon='search' label='Search for a dataset' outlined></v-text-field>
+        <v-text-field v-if="projectArtifactsStore.datasets.length" v-model='searchDataset' append-icon='search'
+                      label='Search for a dataset' outlined></v-text-field>
         <v-checkbox v-model="showDebugDatasets" label="Show debug datasets" class="ml-4"/>
       </v-col>
       <v-col>
@@ -32,7 +33,7 @@
             <v-row class="px-2 py-1 align-center">
               <v-col cols="4" class="font-weight-bold"
                      :title="f.name ? f.name : f.id">
-                <InlineEditText :text="f.name ? projectArtifactsStore.translateTags(f.name) : 'Unnamed dataset'"
+                <InlineEditText :text="$tags(f.name)"
                                 :can-edit="isProjectOwnerOrAdmin"
                                 @save="(name) => renameDataset(f.id, name)">
                 </InlineEditText>
@@ -101,18 +102,19 @@
 </template>
 
 <script setup lang="ts">
-import { api } from '@/api';
-import { Role } from '@/enums';
+import {api} from '@/api';
+import {Role} from '@/enums';
 import mixpanel from 'mixpanel-browser';
 import DeleteModal from '@/views/main/project/modals/DeleteModal.vue';
-import { computed, onBeforeMount, ref } from 'vue';
+import {computed, onBeforeMount, ref} from 'vue';
 import InlineEditText from '@/components/InlineEditText.vue';
-import { useUserStore } from '@/stores/user';
-import { useProjectStore } from '@/stores/project';
-import { useProjectArtifactsStore } from '@/stores/project-artifacts';
-import { TYPE } from 'vue-toastification';
+import {useUserStore} from '@/stores/user';
+import {useProjectStore} from '@/stores/project';
+import {useProjectArtifactsStore} from '@/stores/project-artifacts';
+import {TYPE} from 'vue-toastification';
 import LoadingFullscreen from '@/components/LoadingFullscreen.vue';
-import { useMainStore } from '@/stores/main';
+import {useMainStore} from '@/stores/main';
+import {$tags} from "@/utils/nametags.utils";
 
 const userStore = useUserStore();
 const projectStore = useProjectStore();
@@ -152,7 +154,7 @@ async function deleteDataFile(id: string) {
   mixpanel.track('Delete dataset', {id});
 
   let messageDTO = await api.deleteDatasetFile(id);
-  useMainStore().addNotification({ content: messageDTO.message });
+  useMainStore().addNotification({content: messageDTO.message});
   await projectArtifactsStore.loadDatasets();
 }
 
diff --git a/frontend/src/views/main/project/Debugger.vue b/frontend/src/views/main/project/Debugger.vue
index 9245093cd0..7e92b54a2c 100644
--- a/frontend/src/views/main/project/Debugger.vue
+++ b/frontend/src/views/main/project/Debugger.vue
@@ -4,15 +4,19 @@
       <v-container v-if='debuggingSessionsStore.debuggingSessions.length > 0' class='vc' fluid>
         <v-row>
           <v-col cols='4'>
-            <v-text-field v-show='debuggingSessionsStore.currentDebuggingSessionId === null' v-model='searchSession' append-icon='search' label='Search for a debugging session' outlined></v-text-field>
+            <v-text-field v-show='debuggingSessionsStore.currentDebuggingSessionId === null' v-model='searchSession'
+                          append-icon='search' label='Search for a debugging session' outlined></v-text-field>
           </v-col>
           <v-col cols='8'>
             <div class='d-flex justify-end'>
-              <v-btn v-if='debuggingSessionsStore.currentDebuggingSessionId !== null' class='mr-3' text @click='showPastSessions'>
+              <v-btn v-if='debuggingSessionsStore.currentDebuggingSessionId !== null' class='mr-3' text
+                     @click='showPastSessions'>
                 <v-icon class='mr-2'>mdi-arrow-left</v-icon>
                 Back to all sessions
               </v-btn>
-              <AddDebuggingSessionModal v-show='debuggingSessionsStore.currentDebuggingSessionId === null' :projectId='projectId' @createDebuggingSession='createDebuggingSession'></AddDebuggingSessionModal>
+              <AddDebuggingSessionModal v-show='debuggingSessionsStore.currentDebuggingSessionId === null'
+                                        :projectId='projectId'
+                                        @createDebuggingSession='createDebuggingSession'></AddDebuggingSessionModal>
             </div>
           </v-col>
         </v-row>
@@ -26,7 +30,8 @@
             <v-col cols='1'></v-col>
           </v-row>
 
-          <v-expansion-panel v-for='session in filteredSessions' :key='session.id' class='expansion-panel' @click.stop='openDebuggingSession(session.id, projectId)'>
+          <v-expansion-panel v-for='session in filteredSessions' :key='session.id' class='expansion-panel'
+                             @click.stop='openDebuggingSession(session.id, projectId)'>
             <v-expansion-panel-header :disableIconRotate='true' class='grey lighten-5' tile>
               <v-row class='px-2 py-1 align-center'>
                 <v-col :title='`${session.name} (ID: ${session.id})`' class='font-weight-bold' cols='3'>
@@ -41,13 +46,17 @@
                   </span>
                 </v-col>
                 <v-col class='col-container' cols='3'>
-                  <span :title="(session.dataset.name ? session.dataset.name : 'Unnamed dataset') + ` (ID: ${session.dataset.id})`" @click.stop.prevent="copyText(session.dataset.id, 'Copied dataset ID to clipboard')">
-                    {{ session.dataset.name ? session.dataset.name : 'Unnamed dataset' }}
+                  <span
+                      :title="(session.dataset.name ? session.dataset.name : 'Unnamed dataset') + ` (ID: ${session.dataset.id})`"
+                      @click.stop.prevent="copyText(session.dataset.id, 'Copied dataset ID to clipboard')">
+                    {{ $tags(session.dataset.name ? session.dataset.name : 'Unnamed dataset') }}
                   </span>
                 </v-col>
                 <v-col class='col-container' cols='3'>
-                  <span :title='`${session.model.name} (ID: ${session.model.id})`' @click.stop.prevent="copyText(session.model.id, 'Copied model ID to clipboard')">{{ session.model.name ? session.model.name : 'Unnamed model'
-                  }}</span>
+                  <span :title='`${session.model.name} (ID: ${session.model.id})`'
+                        @click.stop.prevent="copyText(session.model.id, 'Copied model ID to clipboard')">{{
+                      $tags(session.model.name ? session.model.name : 'Unnamed model')
+                    }}</span>
                 </v-col>
                 <v-col cols='1'>
                   <v-card-actions>
@@ -61,7 +70,7 @@
           </v-expansion-panel>
         </v-expansion-panels>
         <div v-else>
-          <router-view />
+          <router-view/>
         </div>
       </v-container>
 
@@ -70,9 +79,11 @@
           <p class='headline font-weight-medium grey--text text--darken-2'>You haven't created any debugging session for
             this project. <br>Please create your first session to start debugging your model.</p>
         </v-alert>
-        <AddDebuggingSessionModal :projectId='projectId' v-on:createDebuggingSession='createDebuggingSession'></AddDebuggingSessionModal>
+        <AddDebuggingSessionModal :projectId='projectId'
+                                  v-on:createDebuggingSession='createDebuggingSession'></AddDebuggingSessionModal>
         <div class='d-flex justify-center mb-6'>
-          <img alt='A turtle using a magnifying glass' class='debugger-logo' src='@/assets/logo_debugger.png' title='Debugger tab logo'>
+          <img alt='A turtle using a magnifying glass' class='debugger-logo' src='@/assets/logo_debugger.png'
+               title='Debugger tab logo'>
         </div>
       </v-container>
     </div>
@@ -84,20 +95,21 @@
 </template>
 
 <script lang='ts' setup>
-import { computed, onActivated, ref, watch } from 'vue';
-import { $vfm } from 'vue-final-modal';
-import { api } from '@/api';
-import { useRoute, useRouter } from 'vue-router/composables';
-import { useMainStore } from '@/stores/main';
-import { useDebuggingSessionsStore } from '@/stores/debugging-sessions';
-import { InspectionDTO } from '@/generated-sources';
+import {computed, onActivated, ref, watch} from 'vue';
+import {$vfm} from 'vue-final-modal';
+import {api} from '@/api';
+import {useRoute, useRouter} from 'vue-router/composables';
+import {useMainStore} from '@/stores/main';
+import {useDebuggingSessionsStore} from '@/stores/debugging-sessions';
+import {InspectionDTO} from '@/generated-sources';
 import AddDebuggingSessionModal from '@/components/AddDebuggingSessionModal.vue';
 import InlineEditText from '@/components/InlineEditText.vue';
 import ConfirmModal from './modals/ConfirmModal.vue';
 import StartWorkerInstructions from '@/components/StartWorkerInstructions.vue';
-import { copyText } from '@/utils';
-import { TYPE } from 'vue-toastification';
-import { state } from "@/socket";
+import {copyText} from '@/utils';
+import {TYPE} from 'vue-toastification';
+import {state} from "@/socket";
+import {$tags} from "@/utils/nametags.utils";
 
 const router = useRouter();
 const route = useRoute();
@@ -124,12 +136,12 @@ const filteredSessions = computed(() => {
     const search = searchSession.value.toLowerCase();
 
     return (
-      session.id.toString().includes(search) ||
-      session.name.toLowerCase().includes(search) ||
-      dataset.name.toLowerCase().includes(search) ||
-      dataset.id.toString().includes(search) ||
-      model.name.toLowerCase().includes(search) ||
-      model.id.toString().includes(search)
+        session.id.toString().includes(search) ||
+        session.name.toLowerCase().includes(search) ||
+        dataset.name.toLowerCase().includes(search) ||
+        dataset.id.toString().includes(search) ||
+        model.name.toLowerCase().includes(search) ||
+        model.id.toString().includes(search)
     );
   }));
 });
diff --git a/frontend/src/views/main/project/InspectionFilter.vue b/frontend/src/views/main/project/InspectionFilter.vue
index e32a3e0d55..290c3fce31 100644
--- a/frontend/src/views/main/project/InspectionFilter.vue
+++ b/frontend/src/views/main/project/InspectionFilter.vue
@@ -1,5 +1,7 @@
 <template>
-  <v-menu v-model="menu" :close-on-content-click="false" disable-keys offset-x right :nudge-left="dirtyFilterValue.type === RowFilterType.CUSTOM ? 1000 : 300" :nudge-bottom="28" :max-width="dirtyFilterValue.type === RowFilterType.CUSTOM ? 1000 : 300" min-width="300">
+  <v-menu v-model="menu" :close-on-content-click="false" disable-keys offset-x right
+          :nudge-left="dirtyFilterValue.type === RowFilterType.CUSTOM ? 1000 : 300" :nudge-bottom="28"
+          :max-width="dirtyFilterValue.type === RowFilterType.CUSTOM ? 1000 : 300" min-width="300">
     <template v-slot:activator="{ on, attrs }">
       <v-btn outlined tile small v-bind="attrs" v-on="on" :style="{ 'background-color': backgroundColors[filter.type] }">
         <v-icon left>
@@ -12,12 +14,16 @@
     <v-form @submit.p.prevent="save">
       <v-card>
         <v-row no-gutters>
-          <v-col v-if="dirtyFilterValue.type === RowFilterType.CUSTOM" class="left-column d-flex" @keydown.tab="e => e.stopPropagation()">
-            <CustomInspectionFilter :is-target-available="isTargetAvailable" :labels="labels" :model-type="modelType" v-model="dirtyFilterValue" />
+          <v-col v-if="dirtyFilterValue.type === RowFilterType.CUSTOM" class="left-column d-flex"
+                 @keydown.tab="e => e.stopPropagation()">
+            <CustomInspectionFilter :is-target-available="isTargetAvailable" :labels="labels" :model-type="modelType"
+                                    v-model="dirtyFilterValue"/>
           </v-col>
           <v-col class="right-column">
             <v-list dense class="pa-0">
-              <v-list-item @click="selectFilter(item)" class="tile" :class="{ 'selected': dirtyFilterValue.type === item.value }" v-for="item in filterTypes" :key="item.value" :disabled="item.disabled" link>
+              <v-list-item @click="selectFilter(item)" class="tile"
+                           :class="{ 'selected': dirtyFilterValue.type === item.value }" v-for="item in filterTypes"
+                           :key="item.value" :disabled="item.disabled" link>
                 <v-list-item-title>{{ item.label }}</v-list-item-title>
               </v-list-item>
             </v-list>
@@ -40,13 +46,16 @@
 </template>
 
 <script setup lang="ts">
-import { isClassification } from "@/ml-utils";
-import { Filter, ModelType, RowFilterType } from "@/generated-sources";
+import {isClassification} from "@/ml-utils";
+import {Filter, ModelType, RowFilterType} from "@/generated-sources";
 import CustomInspectionFilter from "./CustomInspectionFilter.vue";
 import _ from "lodash";
 import mixpanel from "mixpanel-browser";
-import { anonymize } from "@/utils";
-import { onMounted, ref, watch, computed } from "vue";
+import {anonymize} from "@/utils";
+import {computed, onMounted, ref, watch} from "vue";
+import {useDebuggingSessionsStore} from "@/stores/debugging-sessions";
+
+const debuggingSessionStore = useDebuggingSessionsStore();
 
 interface FilterType {
   label: string;
@@ -79,23 +88,27 @@ const menu = ref(false);
 const filter = ref<Filter>(initFilter());
 const dirtyFilterValue = ref<Filter>(initFilter());
 
+watch(() => debuggingSessionStore.selectedFilter, (value) => {
+  selectFilter(<FilterType>value);
+})
+
 const filterTypes = computed(() => [
-  { value: RowFilterType.ALL, label: 'All', description: 'Entire dataset' },
+  {value: RowFilterType.ALL, label: 'All', description: 'Entire dataset'},
   {
     value: RowFilterType.CORRECT,
     label: isClassification(props.modelType) ? 'Correct Predictions' : 'Closest predictions (top 15%)',
     disabled: !props.isTargetAvailable,
     description: isClassification(props.modelType) ?
-      'Predicted value is equal to actual value in dataset target column' :
-      'Top 15% of most accurate predictions'
+        'Predicted value is equal to actual value in dataset target column' :
+        'Top 15% of most accurate predictions'
   },
   {
     value: RowFilterType.WRONG,
     label: isClassification(props.modelType) ? 'Incorrect Predictions' : 'Most distant predictions (top 15%)',
     disabled: !props.isTargetAvailable
   },
-  { value: RowFilterType.BORDERLINE, label: 'Borderline', disabled: !props.isTargetAvailable },
-  { value: RowFilterType.CUSTOM, label: 'Custom' }
+  {value: RowFilterType.BORDERLINE, label: 'Underconfidence', disabled: !props.isTargetAvailable},
+  {value: RowFilterType.CUSTOM, label: 'Custom'}
 ]);
 
 const filterTypesByKey = computed(() => {
diff --git a/frontend/src/views/main/project/Inspector.vue b/frontend/src/views/main/project/Inspector.vue
index 37134dfa5f..9ea9912f48 100644
--- a/frontend/src/views/main/project/Inspector.vue
+++ b/frontend/src/views/main/project/Inspector.vue
@@ -56,6 +56,16 @@
                       <div class="d-flex flex-column">
                         <FeedbackPopover v-if="!isMiniMode" :inputLabel="c.name" :inputValue="inputData[c.name]" :originalValue="originalData[c.name]" :inputType="c.type" @submit="emit(changed ? 'submitValueVariationFeedback' : 'submitValueFeedback', $event)" />
                         <TransformationPopover v-if="catalogStore.transformationFunctionsByColumnType.hasOwnProperty(c.type)" :column="c.name" :column-type="c.type" />
+                        <PushPopover
+                            type="contribution"
+                            :column="c.name"
+                            key="a"
+                        />
+                        <PushPopover
+                            type="perturbation"
+                            :column="c.name"
+                            key="b"
+                        />
                       </div>
                     </div>
                     <div class="py-1 d-flex" v-else>
@@ -124,14 +134,15 @@ import PredictionExplanations from './PredictionExplanations.vue';
 import TextExplanation from './TextExplanation.vue';
 import RegressionTextExplanation from '@/views/main/project/RegressionTextExplanation.vue';
 import FeedbackPopover from '@/components/FeedbackPopover.vue';
-import { DatasetDTO, ModelDTO, ModelType } from '@/generated-sources';
-import { isClassification } from '@/ml-utils';
+import {DatasetDTO, ModelDTO, ModelType} from '@/generated-sources';
+import {isClassification} from '@/ml-utils';
 import mixpanel from 'mixpanel-browser';
 import { anonymize } from '@/utils';
 import _ from 'lodash';
 import TransformationPopover from "@/components/TransformationPopover.vue";
-import { useCatalogStore } from "@/stores/catalog";
-import { onMounted, ref, computed, watch } from 'vue';
+import {useCatalogStore} from "@/stores/catalog";
+import {computed, onMounted, ref, watch} from 'vue';
+import PushPopover from "@/components/PushPopover.vue";
 
 const catalogStore = useCatalogStore();
 
diff --git a/frontend/src/views/main/project/InspectorWrapper.vue b/frontend/src/views/main/project/InspectorWrapper.vue
index 79dfe43244..974e717dc5 100644
--- a/frontend/src/views/main/project/InspectorWrapper.vue
+++ b/frontend/src/views/main/project/InspectorWrapper.vue
@@ -10,37 +10,37 @@
             <h3> Debugging session </h3>
             <div class="d-flex">
               <div> Id</div>
-              <v-spacer />
+              <v-spacer/>
               <div> {{ inspection.id }}</div>
             </div>
             <div class="d-flex">
               <div> Name</div>
-              <v-spacer />
+              <v-spacer/>
               <div class="pl-5"> {{ inspection.name || "-" }}</div>
             </div>
-            <br />
+            <br/>
             <h3> Model </h3>
             <div class="d-flex">
               <div> Id</div>
-              <v-spacer />
+              <v-spacer/>
               <div> {{ inspection.model.id }}</div>
             </div>
             <div class="d-flex">
               <div> Name</div>
-              <v-spacer />
+              <v-spacer/>
               <div class="pl-5"> {{ inspection.model.name }}</div>
             </div>
-            <br />
+            <br/>
             <h3> Dataset </h3>
             <div class="d-flex">
               <div> Id</div>
-              <v-spacer />
+              <v-spacer/>
               <div> {{ inspection.dataset.id }}</div>
             </div>
             <div class="d-flex pb-3">
               <div> Name</div>
-              <v-spacer />
-              <div class="pl-5"> {{ inspection.dataset.name }}</div>
+              <v-spacer/>
+              <div class="pl-5"> {{ $tags(inspection.dataset.name) }}</div>
             </div>
           </v-tooltip>
           <span class='subtitle-1 mr-2'>Dataset Explorer</span>
@@ -58,8 +58,10 @@
           <span class='caption grey--text' v-if="totalRows > 0">
             Entry #{{ totalRows === 0 ? 0 : rowNb + 1 }} / {{ totalRows }}
           </span>
-          <span v-show="originalData && isDefined(originalData['Index'])" class='caption grey--text' style='margin-left: 15px'>Row Index {{ originalData['Index'] + 1 }}</span>
-          <v-chip class="ml-2" outlined link :color="inspection.sample ? 'purple' : 'primary'" @click="handleSwitchSample" x-small>
+          <span v-show="originalData && isDefined(originalData['Index'])" class='caption grey--text'
+                style='margin-left: 15px'>Row Index {{ originalData['Index'] + 1 }}</span>
+          <v-chip class="ml-2" outlined link :color="inspection.sample ? 'purple' : 'primary'"
+                  @click="handleSwitchSample" x-small>
             {{ inspection.sample ? 'Sample' : 'Whole' }} data
           </v-chip>
         </v-toolbar>
@@ -67,17 +69,26 @@
       <v-col lg="6" sm="12" class="pl-4">
         <v-row no-gutters align="center">
           <v-col cols="8" class="pb-4">
-            <SlicingFunctionSelector label="Slice to apply" :project-id="projectId" :full-width="false" :icon="true" class="mr-3" :allow-no-code-slicing="true" @onChanged="processDataset" :value.sync="selectedSlicingFunction.uuid" :args.sync="selectedSlicingFunction.params" :dataset="inspection.dataset" />
+            <SlicingFunctionSelector label="Slice to apply" :project-id="projectId" :full-width="false" :icon="true"
+                                     class="mr-3" :allow-no-code-slicing="true" @onChanged="processDataset"
+                                     :value.sync="selectedSlicingFunction.uuid"
+                                     :args.sync="selectedSlicingFunction.params" :dataset="inspection.dataset"/>
           </v-col>
           <v-col cols="4" class="d-flex pl-2">
-            <InspectionFilter :is-target-available="isDefined(inspection.dataset.target)" :labels="labels" :model-type="inspection.model.modelType" @input="f => filter = f" :inspectionId="inspectionId" :value="filter" />
+            <InspectionFilter :is-target-available="isDefined(inspection.dataset.target)" :labels="labels"
+                              :model-type="inspection.model.modelType" @input="f => filter = f"
+                              :inspectionId="inspectionId" :value="filter"/>
           </v-col>
         </v-row>
       </v-col>
     </v-row>
-    <Inspector :dataset='inspection.dataset' :inputData.sync='inputData' :model='inspection.model' :originalData='originalData' :transformationModifications="modifications" class='px-0' @reset='resetInput' @submitValueFeedback='submitValueFeedback' @submitValueVariationFeedback='submitValueVariationFeedback' v-if="totalRows > 0" :key="inputData._GISKARD_INDEX_" />
+    <Inspector :dataset='inspection.dataset' :inputData.sync='inputData' :model='inspection.model'
+               :originalData='originalData' :transformationModifications="modifications" class='px-0'
+               @reset='resetInput' @submitValueFeedback='submitValueFeedback'
+               @submitValueVariationFeedback='submitValueVariationFeedback' v-if="totalRows > 0"
+               :key="inputData._GISKARD_INDEX_"/>
     <v-alert v-else border="bottom" colored-border type="warning" class="mt-8" elevation="2">
-      No data matches the selected filter.<br />
+      No data matches the selected filter.<br/>
       In order to show data, please refine the filter's criteria.
     </v-alert>
 
@@ -85,7 +96,8 @@
     <!-- For general feedback -->
     <v-tooltip left>
       <template v-slot:activator='{ on, attrs }'>
-        <v-btn :class="feedbackPopupToggle ? 'secondary' : 'primary'" bottom fab fixed class="zindex-10" right v-bind='attrs' @click='feedbackPopupToggle = !feedbackPopupToggle' v-on='on'>
+        <v-btn :class="feedbackPopupToggle ? 'secondary' : 'primary'" bottom fab fixed class="zindex-10" right
+               v-bind='attrs' @click='feedbackPopupToggle = !feedbackPopupToggle' v-on='on'>
           <v-icon v-if='feedbackPopupToggle'>mdi-close</v-icon>
           <v-icon v-else>mdi-message-plus</v-icon>
         </v-btn>
@@ -102,13 +114,15 @@
           <v-radio label='No' value='no'></v-radio>
           <v-radio label='Other' value='other'></v-radio>
         </v-radio-group>
-        <v-textarea v-model='feedback' :disabled='feedbackSubmitted' hide-details no-resize outlined placeholder='Why?' rows='2'></v-textarea>
+        <v-textarea v-model='feedback' :disabled='feedbackSubmitted' hide-details no-resize outlined placeholder='Why?'
+                    rows='2'></v-textarea>
       </v-card-text>
       <p v-if='feedbackError' class='caption error--text mb-0'>{{ feedbackError }}</p>
       <v-card-actions>
         <v-spacer></v-spacer>
         <v-btn :disabled='feedbackSubmitted' light small text @click='clearFeedback'>Cancel</v-btn>
-        <v-btn :disabled='!(feedback && feedbackChoice) || feedbackSubmitted' class='mx-1' color='white' light small @click='submitGeneralFeedback'>
+        <v-btn :disabled='!(feedback && feedbackChoice) || feedbackSubmitted' class='mx-1' color='white' light small
+               @click='submitGeneralFeedback'>
           Send
         </v-btn>
         <v-icon v-show='feedbackSubmitted' color='white'>mdi-check</v-icon>
@@ -119,8 +133,8 @@
 </template>
 
 <script setup lang='ts'>
-import { computed, onMounted, onUnmounted, ref, watch } from 'vue';
-import { api } from '@/api';
+import {computed, onMounted, onUnmounted, ref, watch} from 'vue';
+import {api} from '@/api';
 import Inspector from './Inspector.vue';
 import Mousetrap from 'mousetrap';
 import {
@@ -136,12 +150,15 @@ import mixpanel from "mixpanel-browser";
 import _ from "lodash";
 import InspectionFilter from './InspectionFilter.vue';
 import SlicingFunctionSelector from "@/views/main/utils/SlicingFunctionSelector.vue";
-import { useCatalogStore } from "@/stores/catalog";
-import { storeToRefs } from "pinia";
-import { useInspectionStore } from "@/stores/inspection";
-import { $vfm } from "vue-final-modal";
+import {useCatalogStore} from "@/stores/catalog";
+import {storeToRefs} from "pinia";
+import {useInspectionStore} from "@/stores/inspection";
+import {$vfm} from "vue-final-modal";
 import BlockingLoadingModal from "@/views/main/project/modals/BlockingLoadingModal.vue";
-import { confirm } from "@/utils/confirmation.utils";
+import {confirm} from "@/utils/confirmation.utils";
+import {usePushStore} from "@/stores/push";
+import {useDebuggingSessionsStore} from "@/stores/debugging-sessions";
+import {$tags} from "@/utils/nametags.utils";
 
 interface CreatedFeedbackCommonDTO {
   targetFeature?: string | null;
@@ -180,11 +197,7 @@ const filter = ref<Filter>({
   type: RowFilterType.ALL
 });
 
-const selectedSlicingFunction = ref<Partial<ParameterizedCallableDTO>>({
-  uuid: undefined,
-  params: [],
-  type: 'SLICING'
-});
+const {selectedSlicingFunction} = storeToRefs(useDebuggingSessionsStore())
 
 const dataProcessingResult = ref<DatasetProcessingResultDTO | null>(null);
 
@@ -199,7 +212,7 @@ const percentRegressionUnit = ref(true);
 
 const canPrevious = computed(() => rowNb.value > 0);
 const canNext = computed(() => rowNb.value < totalRows.value - 1);
-const { transformationFunctions } = storeToRefs(useInspectionStore());
+const {transformationFunctions} = storeToRefs(useInspectionStore());
 
 function commonFeedbackData(): CreatedFeedbackCommonDTO {
   return {
@@ -240,6 +253,12 @@ function next() {
   }
 }
 
+watch(() => inputData.value, async (newValue, oldValue) => {
+  console.log("RowNb changed");
+  const pushStore = usePushStore();
+  await pushStore.fetchPushSuggestions(inspection.value!.model.id, inspection.value!.dataset.id, rowNb.value, newValue, modelFeatures.value);
+});
+
 async function submitGeneralFeedback() {
   const newFeedback: CreateFeedbackDTO = {
     ...commonFeedbackData(),
@@ -293,7 +312,7 @@ watch(() => [
   shuffleMode.value,
   percentRegressionUnit.value,
   dataProcessingResult.value
-], async (nv, ov) => applyFilter(nv, ov), { deep: true, immediate: false });
+], async (nv, ov) => applyFilter(nv, ov), {deep: true, immediate: false});
 
 async function updateRow(forceFetch) {
   await fetchRows(rowNb.value, forceFetch);
@@ -310,13 +329,13 @@ async function fetchRows(rowIdxInResults: number, forceFetch: boolean) {
   const newPage = Math.floor(rowIdxInResults / itemsPerPage);
   if ((rowIdxInResults > 0 && remainder === 0) || forceFetch) {
     const result = await api.getDatasetRows(inspection.value!.dataset.id,
-      newPage * itemsPerPage, itemsPerPage, {
-      filter: {
-        ...filter.value,
-        inspectionId: props.inspectionId
-      },
-      removeRows: dataProcessingResult.value?.filteredRows
-    }, inspection.value!.sample, shuffleMode.value)
+        newPage * itemsPerPage, itemsPerPage, {
+          filter: {
+            ...filter.value,
+            inspectionId: props.inspectionId
+          },
+          removeRows: dataProcessingResult.value?.filteredRows
+        }, inspection.value!.sample, shuffleMode.value)
     rows.value = result.content;
     numberOfRows.value = result.totalItems;
   }
@@ -328,7 +347,7 @@ function assignCurrentRow(forceFetch: boolean) {
   loadingData.value = true;
 
   inputData.value = rows.value[rowIdxInPage.value];
-  originalData.value = { ...inputData.value }; // deep copy to avoid caching mechanisms
+  originalData.value = {...inputData.value}; // deep copy to avoid caching mechanisms
   dataErrorMsg.value = '';
   loadingData.value = false;
   totalRows.value = numberOfRows.value;
@@ -360,7 +379,7 @@ async function doSubmitFeedback(payload: CreateFeedbackDTO) {
 
 const transformationPipeline = computed(() => Object.values(transformationFunctions.value))
 
-watch(() => transformationPipeline.value, processDataset, { deep: true })
+watch(() => transformationPipeline.value, processDataset, {deep: true})
 
 watch(() => props.inspectionId, async (nv, ov) => {
   if (nv !== ov) {
@@ -368,9 +387,14 @@ watch(() => props.inspectionId, async (nv, ov) => {
   }
 });
 
+watch(() => selectedSlicingFunction.value, async () => {
+  console.log("watch updated");
+  await processDataset();
+})
+
 async function processDataset() {
   const pipeline = [selectedSlicingFunction.value, ...transformationPipeline.value]
-    .filter(callable => !!callable.uuid) as Array<ParameterizedCallableDTO>;
+      .filter(callable => !!callable.uuid) as Array<ParameterizedCallableDTO>;
 
   loadingProcessedDataset.value = true;
   dataProcessingResult.value = await api.datasetProcessing(props.projectId, inspection.value!.dataset.id, pipeline, inspection.value!.sample)
@@ -434,6 +458,26 @@ async function handleSwitchSample() {
     }
   });
 }
+
+const modelFeatures = computed(() => {
+  return inputMetaData
+      .value
+      //.filter(x => (!inspection.value?.model.featureNames || inspection.value.model.featureNames.includes(x.name)))
+      .map(x => x.name);
+});
+
+const inputMetaData = computed(() => {
+  if (!inspection.value?.model) {
+    return [];
+  }
+
+  return Object.entries(inspection.value?.dataset.columnTypes)
+      .map(([name, type]) => ({
+        name,
+        type,
+        values: inspection.value?.dataset.categoryFeatures[name]
+      }))
+});
 </script>
 
 <style scoped>
diff --git a/frontend/src/views/main/project/PredictionResults.vue b/frontend/src/views/main/project/PredictionResults.vue
index 1fda963beb..02ab629cb8 100644
--- a/frontend/src/views/main/project/PredictionResults.vue
+++ b/frontend/src/views/main/project/PredictionResults.vue
@@ -1,20 +1,26 @@
 <template>
   <v-card class="mb-4" id="resultCard" outlined>
-    <v-card-title>Result</v-card-title>
+    <v-card-title>Result
+      <PushPopover type="overconfidence"/>
+      <PushPopover type="borderline"/>
+    </v-card-title>
     <v-card-text class="text-center card-text" v-if="inputData">
-      <LoadingFullscreen v-show="loading" name="result" class="pb-6" />
+      <LoadingFullscreen v-show="loading" name="result" class="pb-6"/>
       <v-row v-if="prediction && isClassification(predictionTask) && !loading">
         <v-col lg="8" md="12" sm="12" xs="12" v-if="resultProbabilities && Object.keys(resultProbabilities).length > 0
           ">
-          <div>Probabilities <span v-if="Object.keys(resultProbabilities).length > 5"> (5 of {{ Object.keys(resultProbabilities).length }})</span></div>
-          <v-chart class="chart" :option="chartOptions" :init-options="chartInit" autoresize />
+          <div>Probabilities <span v-if="Object.keys(resultProbabilities).length > 5"> (5 of {{
+              Object.keys(resultProbabilities).length
+            }})</span></div>
+          <v-chart class="chart" :option="chartOptions" :init-options="chartInit" autoresize/>
         </v-col>
         <v-col lg="4">
           <div class="mb-3">
             <div>Prediction</div>
             <v-tooltip bottom>
               <template v-slot:activator="{ on, attrs }">
-                <div class="text-h6" :class="classColorPrediction" v-on="prediction.length > maxLengthDisplayedCategoryComp ? on : ''">
+                <div class="text-h6" :class="classColorPrediction"
+                     v-on="prediction.length > maxLengthDisplayedCategoryComp ? on : ''">
                   {{ abbreviateMiddle(prediction, maxLengthDisplayedCategoryComp) }}
                 </div>
               </template>
@@ -29,7 +35,9 @@
               <v-tooltip bottom>
                 <template v-slot:activator="{ on, attrs }">
                   <div class="text-h6">
-                    <div v-if="isDefined(actual)" v-on="actual.length > maxLengthDisplayedCategoryComp ? on : ''">{{ abbreviateMiddle(actual, maxLengthDisplayedCategoryComp) }}</div>
+                    <div v-if="isDefined(actual)" v-on="actual.length > maxLengthDisplayedCategoryComp ? on : ''">
+                      {{ abbreviateMiddle(actual, maxLengthDisplayedCategoryComp) }}
+                    </div>
                     <div v-else>-</div>
                   </div>
                 </template>
@@ -39,7 +47,8 @@
             </div>
             <div class="caption">
               <div v-if="targetFeature">target: {{ targetFeature }}</div>
-              <div v-if="model && model.threshold && (model.modelType != ModelType.CLASSIFICATION || model.classificationLabels.length == 2)">
+              <div
+                  v-if="model && model.threshold && (model.modelType != ModelType.CLASSIFICATION || model.classificationLabels.length == 2)">
                 threshold:
                 {{ model.threshold }}
               </div>
@@ -82,7 +91,8 @@
     </v-card-text>
 
     <v-card-actions v-show="Object.keys(resultProbabilities).length > predCategoriesN">
-      <ResultPopover :resultProbabilities='resultProbabilities' :prediction='prediction' :actual='actual' :classColorPrediction='classColorPrediction'></ResultPopover>
+      <ResultPopover :resultProbabilities='resultProbabilities' :prediction='prediction' :actual='actual'
+                     :classColorPrediction='classColorPrediction'></ResultPopover>
     </v-card-actions>
 
   </v-card>
@@ -93,16 +103,17 @@ import VChart from 'vue-echarts';
 import { computed, getCurrentInstance, onMounted, ref, watch } from 'vue';
 import ResultPopover from '@/components/ResultPopover.vue';
 import LoadingFullscreen from '@/components/LoadingFullscreen.vue';
-import { api } from '@/api';
-import { use } from 'echarts/core';
-import { BarChart } from 'echarts/charts';
-import { CanvasRenderer } from 'echarts/renderers';
-import { GridComponent } from 'echarts/components';
-import { ModelDTO, ModelType } from '@/generated-sources';
-import { isClassification } from '@/ml-utils';
-import { abbreviateMiddle, maxLengthDisplayedCategory } from '@/results-utils';
+import {api} from '@/api';
+import {use} from 'echarts/core';
+import {BarChart} from 'echarts/charts';
+import {CanvasRenderer} from 'echarts/renderers';
+import {GridComponent} from 'echarts/components';
+import {ModelDTO, ModelType} from '@/generated-sources';
+import {isClassification} from '@/ml-utils';
+import {abbreviateMiddle, maxLengthDisplayedCategory} from '@/results-utils';
 import * as _ from 'lodash';
-import { CanceledError } from 'axios';
+import {CanceledError} from 'axios';
+import PushPopover from "@/components/PushPopover.vue";
 
 use([CanvasRenderer, BarChart, GridComponent]);
 
@@ -163,11 +174,11 @@ async function submitPrediction() {
   if (Object.keys(props.inputData).length) {
     try {
       loading.value = true;
-      const predictionResult = (await api.predict(
-        props.model.id,
-        props.datasetId,
-        _.pick(props.inputData, props.modelFeatures),
-        controller.value
+        const predictionResult = (await api.predict(
+            props.model.id,
+            props.datasetId,
+            _.pick(props.inputData, props.modelFeatures),
+            controller.value
       ))
       prediction.value = predictionResult.prediction;
       emit("result", prediction.value);
@@ -176,7 +187,7 @@ async function submitPrediction() {
         .sort(([, v1], [, v2]) => +v2 - +v1)       // Sort the object by value - solution based on:
         .reduce((r, [k, v]) => ({ ...r, [k]: v }), {}); // https://stackoverflow.com/questions/55319092/sort-a-javascript-object-by-key-or-value-es6
 
-      errorMsg.value = "";
+            errorMsg.value = "";
       loading.value = false;
     } catch (error) {
       if (!(error instanceof CanceledError)) {
@@ -224,24 +235,24 @@ const chartOptions = computed(() => {
           show: true,
           position: "right",
           formatter: (params: any) =>
-            params.value % 1 == 0
-              ? params.value
-              : params.value.toFixed(2).toLocaleString(),
+                params.value % 1 == 0
+                    ? params.value
+                    : params.value.toFixed(2).toLocaleString(),
+          },
+          data: Object.values(results),
         },
-        data: Object.values(results),
+      ],
+      color: ["#0091EA"],
+      grid: {
+        width: "80%",
+        height: "80%",
+        top: "10%",
+        left: "10%",
+        right: "10%",
+        containLabel: true,
       },
-    ],
-    color: ["#0091EA"],
-    grid: {
-      width: "80%",
-      height: "80%",
-      top: "10%",
-      left: "10%",
-      right: "10%",
-      containLabel: true,
-    },
-  };
-});
+    };
+  });
 
 function firstNSortedByKey(obj: Object, n: number) {
   let listed = Object.entries(obj)
diff --git a/frontend/src/views/main/project/SuiteTestExecutionCard.vue b/frontend/src/views/main/project/SuiteTestExecutionCard.vue
index 15996b0056..4cea2b47db 100644
--- a/frontend/src/views/main/project/SuiteTestExecutionCard.vue
+++ b/frontend/src/views/main/project/SuiteTestExecutionCard.vue
@@ -84,21 +84,22 @@
 </template>
 
 <script lang='ts' setup>
-import { SuiteTestDTO, SuiteTestExecutionDTO } from '@/generated-sources';
-import { computed, ref } from 'vue';
-import { storeToRefs } from 'pinia';
-import { useCatalogStore } from '@/stores/catalog';
-import { $vfm } from 'vue-final-modal';
+import {SuiteTestDTO, SuiteTestExecutionDTO} from '@/generated-sources';
+import {computed, ref} from 'vue';
+import {storeToRefs} from 'pinia';
+import {useCatalogStore} from '@/stores/catalog';
+import {$vfm} from 'vue-final-modal';
 import SuiteTestInfoModal from '@/views/main/project/modals/SuiteTestInfoModal.vue';
-import { useTestSuiteStore } from '@/stores/test-suite';
-import { useDebuggingSessionsStore } from '@/stores/debugging-sessions';
+import {useTestSuiteStore} from '@/stores/test-suite';
+import {useDebuggingSessionsStore} from '@/stores/debugging-sessions';
 import ExecutionLogsModal from '@/views/main/project/modals/ExecutionLogsModal.vue';
 import mixpanel from 'mixpanel-browser';
-import { TEST_RESULT_DATA } from '@/utils/tests.utils';
-import { api } from '@/api';
+import {TEST_RESULT_DATA} from '@/utils/tests.utils';
+import {api} from '@/api';
 import router from '@/router';
 import ModelSelector from '@/views/main/utils/ModelSelector.vue';
-import { chain } from 'lodash';
+import {chain} from 'lodash';
+import {$tags} from "@/utils/nametags.utils";
 
 const {slicingFunctionsByUuid, transformationFunctionsByUuid} = storeToRefs(useCatalogStore());
 const {models, datasets} = storeToRefs(useTestSuiteStore());
@@ -135,7 +136,7 @@ function mapValue(value: string, type: string): string {
     return model.name ?? value;
   } else if (type === 'Dataset') {
     const dataset = datasets.value[value];
-    return dataset.name ?? value;
+    return $tags(dataset.name) ?? value;
   }
   return value;
 }
diff --git a/frontend/src/views/main/project/modals/AddTestToSuite.vue b/frontend/src/views/main/project/modals/AddTestToSuite.vue
index 54fd7ef330..15d722a700 100644
--- a/frontend/src/views/main/project/modals/AddTestToSuite.vue
+++ b/frontend/src/views/main/project/modals/AddTestToSuite.vue
@@ -1,5 +1,6 @@
 <template>
-  <vue-final-modal v-slot="{ close }" v-bind="$attrs" classes="modal-container" content-class="modal-content" v-on="$listeners">
+  <vue-final-modal v-slot="{ close }" v-bind="$attrs" classes="modal-container" content-class="modal-content"
+                   v-on="$listeners">
     <v-form @submit.prevent="">
       <ValidationObserver ref="observer" v-slot="{ invalid }">
         <v-card class="modal-card">
@@ -11,11 +12,13 @@
             <v-row>
               <v-col cols=12>
                 <ValidationProvider name="Test suite" mode="eager" rules="required" v-slot="{ errors }">
-                  <v-select outlined label="Test suite" v-model="selectedSuite" :items="testSuites" :item-text="'name'" :item-value="'id'" dense hide-details>
+                  <v-select outlined label="Test suite" v-model="selectedSuite" :items="testSuites" :item-text="'name'"
+                            :item-value="'id'" dense hide-details>
                     <template v-slot:append-item>
                       <v-divider></v-divider>
                       <v-list-item link @click="createTestSuite" class="pt-1">
-                        <v-list-item-avatar color="grey lighten-4" class="my-1 mr-2" style="height: 25px;min-width: 25px;width: 25px;">
+                        <v-list-item-avatar color="grey lighten-4" class="my-1 mr-2"
+                                            style="height: 25px;min-width: 25px;width: 25px;">
                           <v-icon small>
                             mdi-plus
                           </v-icon>
@@ -29,10 +32,13 @@
                     </template>
                   </v-select>
                 </ValidationProvider>
-                <p class="text-h6 pt-4">Fixed inputs</p>
-                <p>Specify inputs that will be constant during each execution of the test.<br />
-                  The inputs left blank will have to be provided at test execution time.</p>
-                <SuiteInputListSelector class="pt-4" :editing="true" :project-id="projectId" :inputs="inputs" :model-value="testInputs" :doc="doc" />
+                <template v-if="!hideFixedInputs">
+                  <p class="text-h6 pt-4">Fixed inputs</p>
+                  <p>Specify inputs that will be constant during each execution of the test.<br/>
+                    The inputs left blank will have to be provided at test execution time.</p>
+                  <SuiteInputListSelector class="pt-4" :editing="true" :project-id="projectId" :inputs="inputs"
+                                          :model-value="testInputs" :doc="doc"/>
+                </template>
               </v-col>
             </v-row>
           </v-card-text>
@@ -53,25 +59,26 @@
 
 <script setup lang="ts">
 
-import { computed, onMounted, ref } from 'vue';
-import { api } from '@/api';
-import { FunctionInputDTO, SuiteTestDTO, TestFunctionDTO, TestSuiteDTO } from '@/generated-sources';
+import {computed, onMounted, ref} from 'vue';
+import {api} from '@/api';
+import {FunctionInputDTO, SuiteTestDTO, TestFunctionDTO, TestSuiteDTO} from '@/generated-sources';
 import SuiteInputListSelector from '@/components/SuiteInputListSelector.vue';
-import { chain } from 'lodash';
-import { useMainStore } from "@/stores/main";
-import { TYPE } from 'vue-toastification';
-import { extractArgumentDocumentation, ParsedDocstring } from "@/utils/python-doc.utils";
+import {chain} from 'lodash';
+import {useMainStore} from "@/stores/main";
+import {TYPE} from 'vue-toastification';
+import {extractArgumentDocumentation, ParsedDocstring} from "@/utils/python-doc.utils";
 import mixpanel from 'mixpanel-browser';
-import { anonymize } from "@/utils";
-import { useRouter } from 'vue-router/composables';
+import {anonymize} from "@/utils";
+import {useRouter} from 'vue-router/composables';
 
 const router = useRouter();
 
-const { projectId, test, suiteId, testArguments } = defineProps<{
+const {projectId, test, suiteId, testArguments} = defineProps<{
   projectId: number,
   test: TestFunctionDTO,
   suiteId?: number,
-  testArguments: { [name: string]: FunctionInputDTO }
+  testArguments: { [name: string]: FunctionInputDTO },
+  hideFixedInputs?: boolean
 }>();
 
 const dialog = ref<boolean>(false);
@@ -83,7 +90,7 @@ const doc = ref<ParsedDocstring | null>(null);
 async function loadData() {
   doc.value = extractArgumentDocumentation(test)
   testSuites.value = await api.getTestSuites(projectId);
-  selectedSuite.value = testSuites.value.find(({ id }) => id === suiteId)?.id ?? null
+  selectedSuite.value = testSuites.value.find(({id}) => id === suiteId)?.id ?? null
   testInputs.value = test.args.reduce((result, arg) => {
     result[arg.name] = testArguments[arg.name] ?? {
       name: arg.name,
@@ -98,10 +105,10 @@ async function loadData() {
 
 
 const inputs = computed(() =>
-  chain(test.args)
-    .keyBy('name')
-    .mapValues('type')
-    .value()
+    chain(test.args)
+        .keyBy('name')
+        .mapValues('type')
+        .value()
 );
 
 const mainStore = useMainStore();
@@ -117,15 +124,15 @@ async function submit(close) {
     test,
     testUuid: test.uuid,
     functionInputs: chain(testInputs.value)
-      .omitBy(({ value }) => value === null
-        || (typeof value === 'string' && value.trim() === '')
-        || (typeof value === 'number' && Number.isNaN(value)))
-      .value() as { [name: string]: FunctionInputDTO }
+        .omitBy(({value}) => value === null
+            || (typeof value === 'string' && value.trim() === '')
+            || (typeof value === 'number' && Number.isNaN(value)))
+        .value() as { [name: string]: FunctionInputDTO }
   }
 
   await api.addTestToSuite(projectId, selectedSuite.value!, suiteTest);
   mainStore.addNotification({
-    content: `'${test.displayName ?? test.name}' has been added to '${testSuites.value.find(({ id }) => id === selectedSuite.value)!.name}'`,
+    content: `'${test.displayName ?? test.name}' has been added to '${testSuites.value.find(({id}) => id === selectedSuite.value)!.name}'`,
     color: TYPE.SUCCESS
   });
 
@@ -142,12 +149,12 @@ async function submit(close) {
   close();
 
   mixpanel.track('Add test to test suite',
-    {
-      suiteId: selectedSuite.value,
-      projectId: projectId,
-      testUuid: test.uuid,
-      testName: test.displayName ?? test.name
-    });
+      {
+        suiteId: selectedSuite.value,
+        projectId: projectId,
+        testUuid: test.uuid,
+        testName: test.displayName ?? test.name
+      });
 }
 
 async function createTestSuite() {
@@ -163,11 +170,11 @@ async function createTestSuite() {
   });
 
   mixpanel.track('Create test suite',
-    {
-      id: suite,
-      projectKey: project.key,
-      screen: 'Test catalog (Add test to suite modal)'
-    });
+      {
+        id: suite,
+        projectKey: project.key,
+        screen: 'Test catalog (Add test to suite modal)'
+      });
 
   await loadData();
 
diff --git a/frontend/src/views/main/utils/SlicingFunctionSelector.vue b/frontend/src/views/main/utils/SlicingFunctionSelector.vue
index 4242fcfa4d..1bdfec6987 100644
--- a/frontend/src/views/main/utils/SlicingFunctionSelector.vue
+++ b/frontend/src/views/main/utils/SlicingFunctionSelector.vue
@@ -1,6 +1,7 @@
 <template>
   <div class="d-flex" :class="{ w100: fullWidth }">
-    <v-select attach clearable :outlined='fullWidth' class='slice-function-selector' :label='label' v-model='value' :items="[{
+    <v-autocomplete attach clearable :outlined='fullWidth' class='slice-function-selector' :label='label'
+                    v-model='value' :items="[{
       name: 'None',
       displayName: 'None',
       uuid: null,
@@ -16,7 +17,7 @@
           </v-list-item-content>
         </v-list-item>
       </template>
-    </v-select>
+    </v-autocomplete>
     <v-btn icon v-if="hasArguments" @click="updateArgs">
       <v-icon>settings</v-icon>
     </v-btn>
diff --git a/python-client/docs/reference/index.rst b/python-client/docs/reference/index.rst
index 5671745f4e..07eb88b9f6 100644
--- a/python-client/docs/reference/index.rst
+++ b/python-client/docs/reference/index.rst
@@ -11,3 +11,4 @@ API reference
    suite/index
    slicing-functions/index
    transformation-functions/index
+   push/index
diff --git a/python-client/docs/reference/push/index.rst b/python-client/docs/reference/push/index.rst
new file mode 100644
index 0000000000..00525c96ed
--- /dev/null
+++ b/python-client/docs/reference/push/index.rst
@@ -0,0 +1,32 @@
+Push feature
+============
+
+.. automodule:: giskard.push
+
+.. autoclass:: giskard.push.Push
+
+.. autoclass:: giskard.push.ExamplePush
+
+.. autoclass:: giskard.push.FeaturePush
+
+.. autoclass:: giskard.push.OverconfidencePush
+
+.. autoclass:: giskard.push.BorderlinePush
+
+.. autoclass:: giskard.push.ContributionPush
+
+.. autoclass:: giskard.push.PerturbationPush
+
+
+Push tests catalog
+-----------
+
+.. autofunction:: giskard.push.push_test_catalog.catalog.test_diff_rmse_push
+.. autofunction:: giskard.push.push_test_catalog.catalog.test_diff_f1_push
+.. autofunction:: giskard.push.push_test_catalog.catalog.if_underconfidence_rate_decrease
+.. autofunction:: giskard.push.push_test_catalog.catalog.if_overconfidence_rate_decrease
+.. autofunction:: giskard.push.push_test_catalog.catalog.correct_example
+.. autofunction:: giskard.push.push_test_catalog.catalog.increase_probability
+.. autofunction:: giskard.push.push_test_catalog.catalog.one_sample_overconfidence_test
+.. autofunction:: giskard.push.push_test_catalog.catalog.one_sample_underconfidence_test
+.. autofunction:: giskard.push.push_test_catalog.catalog.test_metamorphic_invariance_with_mad
\ No newline at end of file
diff --git a/python-client/giskard/__init__.py b/python-client/giskard/__init__.py
index 4249871366..f3a74a07d1 100644
--- a/python-client/giskard/__init__.py
+++ b/python-client/giskard/__init__.py
@@ -17,6 +17,7 @@
 from giskard.ml_worker.utils.logging import configure_logging
 from giskard.models.automodel import Model
 from giskard.models.model_explanation import explain_with_shap
+from giskard import push
 from . import demo
 from .ml_worker.utils.network import check_latest_giskard_version
 from .scanner import scan
@@ -46,6 +47,7 @@ def get_version() -> str:
     "Dataset",
     "GiskardClient",
     "test",
+    "push",
     "Model",
     "Suite",
     "slicing_function",
diff --git a/python-client/giskard/core/core.py b/python-client/giskard/core/core.py
index 00b56c1681..e8a57c1e22 100644
--- a/python-client/giskard/core/core.py
+++ b/python-client/giskard/core/core.py
@@ -148,6 +148,7 @@ def __init__(
         self.module_doc = None
         self.full_name = None
         self.args = None
+
         if callable_obj:
             from giskard.ml_worker.testing.registry.registry import get_object_uuid
 
diff --git a/python-client/giskard/ml_worker/testing/functions/transformation.py b/python-client/giskard/ml_worker/testing/functions/transformation.py
index 442d0b917b..c685114cc5 100644
--- a/python-client/giskard/ml_worker/testing/functions/transformation.py
+++ b/python-client/giskard/ml_worker/testing/functions/transformation.py
@@ -7,6 +7,7 @@
 import pandas as pd
 
 from giskard.ml_worker.testing.registry.transformation_function import transformation_function
+from scipy.stats import median_abs_deviation
 
 nearbykeys = {
     "a": ["q", "w", "s", "x", "z"],
@@ -139,3 +140,21 @@ def change_writing_style(
 
     x.at[index, column_name] = chain_rewrite.run({"text": x.at[index, column_name], "style": style})
     return x
+
+
+def compute_mad(x):
+    return median_abs_deviation(x, scale=1)
+
+
+@transformation_function(name="MAD Increment", tags=["num"], row_level=False)
+def mad_transformation(
+    data: pd.DataFrame, column_name: str, factor: float = 1, value_added: float = None
+) -> pd.DataFrame:
+    """
+    Add 3 times the value_added to the column, or if unavailable, add 3 times the MAD value.
+    """
+    data = data.copy()
+    if value_added is None:
+        value_added = compute_mad(data[column_name])
+    data[column_name] = data[column_name].apply(lambda x: x + factor * value_added)
+    return data
diff --git a/python-client/giskard/ml_worker/websocket/__init__.py b/python-client/giskard/ml_worker/websocket/__init__.py
index 35fdbcaf52..5c443029c3 100644
--- a/python-client/giskard/ml_worker/websocket/__init__.py
+++ b/python-client/giskard/ml_worker/websocket/__init__.py
@@ -1,7 +1,8 @@
 from enum import Enum
-from pydantic import BaseModel, Field
 from typing import Dict, List, Optional
 
+from pydantic import BaseModel, Field
+
 
 class WorkerReply(BaseModel):
     pass
@@ -305,3 +306,65 @@ class TestSuite(WorkerReply):
 class TestSuiteParam(BaseModel):
     tests: Optional[List[SuiteTestArgument]] = None
     globalArguments: Optional[List[FuncArgument]] = None
+
+
+class PushKind(Enum):
+    INVALID = 0
+    PERTURBATION = 1
+    CONTRIBUTION = 2
+    OVERCONFIDENCE = 3
+    BORDERLINE = 4
+
+
+class CallToActionKind(Enum):
+    NONE = 0
+    CREATE_SLICE = 1
+    CREATE_TEST = 2
+    CREATE_PERTURBATION = 3
+    SAVE_PERTURBATION = 4
+    CREATE_ROBUSTNESS_TEST = 5
+    CREATE_SLICE_OPEN_DEBUGGER = 6
+    OPEN_DEBUGGER_BORDERLINE = 7
+    ADD_TEST_TO_CATALOG = 8
+    SAVE_EXAMPLE = 9
+    OPEN_DEBUGGER_OVERCONFIDENCE = 10
+    CREATE_UNIT_TEST = 11
+
+
+class GetPushParam(BaseModel):
+    model: ArtifactRef
+    dataset: ArtifactRef
+    dataframe: Optional[DataFrame]
+    target: str
+    column_types: Dict[str, str]
+    column_dtypes: Dict[str, str]
+    push_kind: Optional[PushKind]
+    cta_kind: Optional[CallToActionKind]
+
+
+class PushDetails(BaseModel):
+    action: str
+    explanation: str
+    button: str
+    cta: CallToActionKind
+
+
+class Push(BaseModel):
+    kind: PushKind
+    key: Optional[str]
+    value: Optional[str]
+    push_title: str
+    push_details: List[PushDetails]
+
+
+class PushAction(BaseModel):
+    object_uuid: str
+    arguments: Optional[List[FuncArgument]]
+
+
+class GetPushResponse(BaseModel):
+    contribution: Optional[Push]
+    perturbation: Optional[Push]
+    overconfidence: Optional[Push]
+    borderline: Optional[Push]
+    action: Optional[PushAction]
diff --git a/python-client/giskard/ml_worker/websocket/action.py b/python-client/giskard/ml_worker/websocket/action.py
index b90aa0de4c..182f6d571c 100644
--- a/python-client/giskard/ml_worker/websocket/action.py
+++ b/python-client/giskard/ml_worker/websocket/action.py
@@ -15,3 +15,4 @@ class MLWorkerAction(Enum):
     stopWorker = 10
     getCatalog = 11
     generateQueryBasedSlicingFunction = 12
+    getPush = 13
diff --git a/python-client/giskard/ml_worker/websocket/listener.py b/python-client/giskard/ml_worker/websocket/listener.py
index 9a0c42a6c9..3ca0a85632 100644
--- a/python-client/giskard/ml_worker/websocket/listener.py
+++ b/python-client/giskard/ml_worker/websocket/listener.py
@@ -1,24 +1,26 @@
 import json
 import logging
-import math
-import numpy as np
 import os
-import pandas as pd
-import pkg_resources
 import platform
-import psutil
-import stomp
 import sys
 import tempfile
 import time
 import traceback
 from pathlib import Path
 
+import math
+import numpy as np
+import pandas as pd
+import pkg_resources
+import psutil
+import stomp
+
 import giskard
 from giskard.core.suite import Suite
 from giskard.datasets.base import Dataset
 from giskard.ml_worker import websocket
 from giskard.ml_worker.core.log_listener import LogListener
+from giskard.ml_worker.core.savable import RegistryArtifact
 from giskard.ml_worker.exceptions.giskard_exception import GiskardException
 from giskard.ml_worker.ml_worker import MLWorker
 from giskard.ml_worker.testing.registry.giskard_test import GiskardTest
@@ -27,7 +29,7 @@
     TransformationFunction,
 )
 from giskard.ml_worker.utils.file_utils import get_file_name
-from giskard.ml_worker.websocket import GetInfoParam
+from giskard.ml_worker.websocket import GetInfoParam, PushKind, CallToActionKind
 from giskard.ml_worker.websocket.action import MLWorkerAction
 from giskard.ml_worker.websocket.utils import (
     do_run_adhoc_test,
@@ -47,11 +49,10 @@
     explain,
     explain_text,
 )
+from giskard.push import Push
 from giskard.utils import threaded
-
 from giskard.utils.analytics_collector import analytics
 
-
 logger = logging.getLogger(__name__)
 
 
@@ -368,7 +369,7 @@ def run_model(ml_worker: MLWorker, params: websocket.RunModelParam, *args, **kwa
 
 @websocket_actor(MLWorkerAction.runModelForDataFrame)
 def run_model_for_data_frame(
-    ml_worker: MLWorker, params: websocket.RunModelForDataFrameParam, *args, **kwargs
+        ml_worker: MLWorker, params: websocket.RunModelForDataFrameParam, *args, **kwargs
 ) -> websocket.RunModelForDataFrame:
     model = BaseModel.download(ml_worker.client, params.model.project_key, params.model.id)
     df = pd.DataFrame.from_records([r.columns for r in params.dataframe.rows])
@@ -439,7 +440,7 @@ def get_catalog(*args, **kwargs) -> websocket.Catalog:
 
 @websocket_actor(MLWorkerAction.datasetProcessing)
 def dataset_processing(
-    ml_worker: MLWorker, params: websocket.DatasetProcessingParam, *args, **kwargs
+        ml_worker: MLWorker, params: websocket.DatasetProcessingParam, *args, **kwargs
 ) -> websocket.DatasetProcessing:
     dataset = Dataset.download(ml_worker.client, params.dataset.project_key, params.dataset.id, params.dataset.sample)
 
@@ -479,7 +480,7 @@ def dataset_processing(
 
 @websocket_actor(MLWorkerAction.runAdHocTest)
 def run_ad_hoc_test(
-    ml_worker: MLWorker, params: websocket.RunAdHocTestParam, *args, **kwargs
+        ml_worker: MLWorker, params: websocket.RunAdHocTestParam, *args, **kwargs
 ) -> websocket.RunAdHocTest:
     test: GiskardTest = GiskardTest.download(params.testUuid, ml_worker.client, None)
 
@@ -552,7 +553,7 @@ def run_test_suite(ml_worker: MLWorker, params: websocket.TestSuiteParam, *args,
 
 @websocket_actor(MLWorkerAction.generateTestSuite)
 def generate_test_suite(
-    ml_worker: MLWorker, params: websocket.GenerateTestSuiteParam, *args, **kwargs
+        ml_worker: MLWorker, params: websocket.GenerateTestSuiteParam, *args, **kwargs
 ) -> websocket.GenerateTestSuite:
     inputs = [map_suite_input_ws(i) for i in params.inputs]
 
@@ -575,3 +576,122 @@ def generate_test_suite(
 @websocket_actor(MLWorkerAction.echo)
 def echo(params: websocket.EchoMsg, *args, **kwargs) -> websocket.EchoMsg:
     return params
+
+
+@websocket_actor(MLWorkerAction.getPush)
+def get_push(
+        ml_worker: MLWorker, params: websocket.GetPushParam, *args, **kwargs
+) -> websocket.GetPushResponse:
+    object_uuid = ""
+    object_params = {}
+    project_key = params.model.project_key
+    try:
+        model = BaseModel.download(ml_worker.client, params.model.project_key, params.model.id)
+        dataset = Dataset.download(ml_worker.client, params.dataset.project_key, params.dataset.id)
+
+        df = pd.DataFrame.from_records([r.columns for r in params.dataframe.rows])
+        if params.column_dtypes:
+            for missing_column in [
+                column_name for column_name in params.column_dtypes.keys() if column_name not in df.columns
+            ]:
+                df[missing_column] = np.nan
+            df = Dataset.cast_column_to_dtypes(df, params.column_dtypes)
+
+    except ValueError as e:
+        if "unsupported pickle protocol" in str(e):
+            raise ValueError(
+                "Unable to unpickle object, "
+                "Make sure that Python version of client code is the same as the Python version in ML Worker."
+                "To change Python version, please refer to https://docs.giskard.ai/start/guides/configuration"
+                f"\nOriginal Error: {e}"
+            ) from e
+        raise e
+    except ModuleNotFoundError as e:
+        raise GiskardException(
+            f"Failed to import '{e.name}'. "
+            f"Make sure it's installed in the ML Worker environment."
+            "To have more information on ML Worker, please see: https://docs.giskard.ai/start/guides/installation/ml-worker"
+        ) from e
+
+    # if df is empty, return early
+    if df.empty:
+        return
+
+    from giskard.push.contribution import create_contribution_push
+    from giskard.push.perturbation import create_perturbation_push
+    from giskard.push.prediction import create_overconfidence_push
+    from giskard.push.prediction import create_borderline_push
+
+    contribs = create_contribution_push(model, dataset, df)
+    perturbs = create_perturbation_push(model, dataset, df)
+    overconf = create_overconfidence_push(model, dataset, df)
+    borderl = create_borderline_push(model, dataset, df)
+
+    contrib_ws = push_to_ws(contribs)
+    perturb_ws = push_to_ws(perturbs)
+    overconf_ws = push_to_ws(overconf)
+    borderl_ws = push_to_ws(borderl)
+
+    if params.cta_kind is not None and params.push_kind is not None:
+        if params.push_kind == PushKind.PERTURBATION:
+            push = perturbs
+        elif params.push_kind == PushKind.CONTRIBUTION:
+            push = contribs
+        elif params.push_kind == PushKind.OVERCONFIDENCE:
+            push = overconf
+        elif params.push_kind == PushKind.BORDERLINE:
+            push = borderl
+        else:
+            raise ValueError("Invalid push kind")
+
+        logger.info("Handling push kind: " + str(params.push_kind) + " with cta kind: " + str(params.cta_kind))
+
+        # Upload related object depending on CTA type
+        if (
+                params.cta_kind == CallToActionKind.CREATE_SLICE
+                or params.cta_kind == CallToActionKind.CREATE_SLICE_OPEN_DEBUGGER
+        ):
+            push.slicing_function.meta.tags.append("generated")
+            object_uuid = push.slicing_function.upload(ml_worker.client)
+        if params.cta_kind == CallToActionKind.SAVE_PERTURBATION:
+            for perturbation in push.transformation_function:
+                object_uuid = perturbation.upload(ml_worker.client)
+        if params.cta_kind == CallToActionKind.SAVE_EXAMPLE:
+            object_uuid = push.saved_example.upload(ml_worker.client, project_key)
+        if params.cta_kind == CallToActionKind.CREATE_TEST or params.cta_kind == CallToActionKind.ADD_TEST_TO_CATALOG:
+            for test in push.tests:
+                object_uuid = test.upload(ml_worker.client)
+            # create empty dict
+            object_params = {}
+            # for every object in push.test_params, check if they're a subclass of Savable and if yes upload them
+            for test_param_name in push.test_params:
+                test_param = push.test_params[test_param_name]
+                if isinstance(test_param, RegistryArtifact):
+                    object_params[test_param_name] = test_param.upload(ml_worker.client)
+                elif isinstance(test_param, Dataset):
+                    object_params[test_param_name] = test_param.upload(ml_worker.client, project_key)
+                else:
+                    object_params[test_param_name] = test_param
+
+        if object_uuid != "":
+            logger.info(f"Uploaded object for CTA with uuid: {object_uuid}")
+
+    if object_uuid != '':
+        return websocket.GetPushResponse(
+            contribution=contrib_ws,
+            perturbation=perturb_ws,
+            overconfidence=overconf_ws,
+            borderline=borderl_ws,
+            action=websocket.PushAction(object_uuid=object_uuid, arguments=function_argument_to_ws(object_params)),
+        )
+
+    return websocket.GetPushResponse(
+        contribution=contrib_ws,
+        perturbation=perturb_ws,
+        overconfidence=overconf_ws,
+        borderline=borderl_ws,
+    )
+
+
+def push_to_ws(push: Push):
+    return push.to_ws() if push is not None else None
diff --git a/python-client/giskard/ml_worker/websocket/utils.py b/python-client/giskard/ml_worker/websocket/utils.py
index e76abfb985..b2416ffb4e 100644
--- a/python-client/giskard/ml_worker/websocket/utils.py
+++ b/python-client/giskard/ml_worker/websocket/utils.py
@@ -2,10 +2,11 @@
 import os
 import posixpath
 import shutil
-from mlflow.store.artifact.artifact_repo import verify_artifact_path
 from pathlib import Path
 from typing import List, Dict, Any
 
+from mlflow.store.artifact.artifact_repo import verify_artifact_path
+
 from giskard.core.suite import ModelInput, DatasetInput, SuiteInput
 from giskard.datasets.base import Dataset
 from giskard.ml_worker import websocket
@@ -27,7 +28,7 @@
     RunAdHocTestParam,
     DatasetProcessingParam,
     GenerateTestSuiteParam,
-    RunModelForDataFrameParam,
+    RunModelForDataFrameParam, GetPushParam,
 )
 from giskard.ml_worker.websocket.action import MLWorkerAction
 from giskard.models.base import BaseModel
@@ -58,11 +59,13 @@ def parse_action_param(action, params):
         return EchoMsg.parse_obj(params)
     elif action == MLWorkerAction.generateTestSuite:
         return GenerateTestSuiteParam.parse_obj(params)
+    elif action == MLWorkerAction.getPush:
+        return GetPushParam.parse_obj(params)
     return params
 
 
 def fragment_message(payload: str, frag_i: int, frag_length: int):
-    return payload[frag_i * frag_length : min((frag_i + 1) * frag_length, len(payload))]
+    return payload[frag_i * frag_length: min((frag_i + 1) * frag_length, len(payload))]
 
 
 def extract_debug_info(request_arguments):
@@ -238,7 +241,6 @@ def map_result_to_single_test_result_ws(result) -> websocket.SingleTestResult:
 
 
 def do_run_adhoc_test(client, arguments, test, debug_info=None):
-
     logger.info(f"Executing {test.meta.display_name or f'{test.meta.module}.{test.meta.name}'}")
     test_result = test.get_builder()(**arguments).execute()
     if test_result.output_df is not None:  # i.e. if debug is True and test has failed
diff --git a/python-client/giskard/push/__init__.py b/python-client/giskard/push/__init__.py
new file mode 100644
index 0000000000..01249ce37c
--- /dev/null
+++ b/python-client/giskard/push/__init__.py
@@ -0,0 +1,432 @@
+"""
+This module defines various push classes used for model debugging.
+
+The main classes are:
+
+- Push: Base push class
+- ExamplePush: Push based on example data
+- OverconfidencePush: Push for overconfidence cases
+- BorderlinePush: Push for borderline/underconfidence cases
+- ContributionPush: Push for high contribution features
+- PerturbationPush: Push for perturbation analysis
+
+ExamplePush and its subclasses allow saving examples and generating
+one-sample tests. ContributionPush and PerturbationPush allow generating
+statistical tests and slicing functions.
+
+The push classes allow converting to gRPC protobuf format via the to_grpc() method.
+"""
+from abc import abstractmethod
+from typing import Optional
+
+from giskard.core.core import SupportedModelTypes
+from giskard.ml_worker import websocket
+from giskard.ml_worker.websocket import PushKind, CallToActionKind
+from giskard.push.push_test_catalog.catalog import (
+    one_sample_overconfidence_test,
+    one_sample_underconfidence_test,
+    test_diff_f1_push,
+    test_diff_rmse_push,
+    test_metamorphic_invariance_with_mad,
+)
+from giskard.push.utils import TransformationInfo
+from giskard.slicing.slice import EqualTo, GreaterThan, LowerThan, Query, QueryBasedSliceFunction
+from giskard.testing.tests.metamorphic import test_metamorphic_invariance
+from giskard.testing.tests.statistic import test_theil_u
+
+
+class Push:
+    """
+    Base push class.
+
+    Attributes:
+        push_title: Title of the push
+        details: List of details/actions for the push
+        tests: List of tests to generate
+        pushkind: Enum of push kind
+    """
+
+    push_title = None
+    details = None
+    tests = None
+    pushkind = None
+
+    @abstractmethod
+    def to_ws(self):
+        """
+        Convert to gRPC protobuf format.
+        """
+        pass
+
+
+class ExamplePush(Push):
+    """
+    Push class based on example data.
+
+    Adds attributes:
+        saved_example: Example dataset row
+        training_label: Ground truth label
+        training_label_proba: Probability of ground truth label
+
+    Can convert to gRPC protobuf format.
+    """
+
+    saved_example = None
+    training_label = None
+    training_label_proba = None
+
+    def to_ws(self):
+        """
+        Convert to gRPC protobuf format.
+        """
+        return websocket.Push(
+            kind=self.pushkind,
+            push_title=self.push_title,
+            push_details=self.details,
+        )
+
+
+class FeaturePush(Push):
+    """
+    Push related to a specific feature.
+
+    Adds attributes:
+        feature: Feature name
+        value: Feature value
+
+    Can convert to gRPC protobuf format.
+    """
+
+    feature = None
+    value = None
+
+    def to_ws(self):
+        """
+        Convert to gRPC protobuf format.
+        """
+        return websocket.Push(
+            kind=self.pushkind,
+            key=self.feature,
+            value=str(self.value),
+            push_title=self.push_title,
+            push_details=self.details,
+        )
+
+
+class OverconfidencePush(ExamplePush):
+    """
+    Recommand actions for overconfidence cases.
+
+    Description:
+        Tag examples that are incorrect but that were classified with a high probability as the wrong label.
+        This may indicate that the model is overconfident on this example.
+        This may be due to spurious correlation or a data leak
+
+    Triggering event:
+        When we switch examples, the example is incorrect and the example is classified as overconfident.
+        We quantify this as the difference between the largest probability assigned to a label and the
+        probability assigned to the correct label (this will be 0 if the model made the correct prediction).
+        If this is larger than a threshold (typically determined automatically depending on
+        the number of classes), then the prediction is considered overconfident.
+
+    Call to action description:
+        Create one-sample test : This adds a test that checks if the model is overconfident on this example to a test suite.
+        Get similar examples : This filters the debugging session to show examples with overconfidence only.
+
+    Requirements:
+        Ground truth label
+        Classification models only
+    """
+
+    def __init__(self, training_label, training_label_proba, dataset_row, predicted_label, rate):
+        self._overconfidence()
+        self.pushkind = PushKind.OVERCONFIDENCE
+
+        self.training_label_proba = training_label_proba
+        self.training_label = training_label
+        self.saved_example = dataset_row
+
+        self.tests = [one_sample_overconfidence_test()]
+        self.test_params = {"saved_example": dataset_row}
+        # if_overconfidence_rate_decrease(rate=rate),
+        #     correct_example(saved_example=dataset_row, training_label=training_label),
+        #     increase_probability(
+        #         saved_example=dataset_row, training_label=training_label, training_label_proba=training_label_proba
+        #     ),
+        self.predicted_label = predicted_label
+
+    def _overconfidence(self):
+        """
+        Generate overconfidence push title and details.
+        """
+        res = {
+            "push_title": "This example is incorrect while having a high confidence.",
+            "details": [
+                # Disabled temporarily
+                # {
+                # "action": "Save this example for further inspection and testing",
+                # "explanation": "This may help you identify spurious correlation and create one-sample tests based on these examples",
+                # "button": "Save Example",
+                #  "cta": CallToActionKind.SaveExample,
+                # },
+                {
+                    "action": "Generate a one-sample test to automatically check if this example is correctly predicted",
+                    "explanation": "This enables you to make sure this specific example is correct for a new model",
+                    "button": "Create one-sample test",
+                    "cta": CallToActionKind.CREATE_TEST,
+                },
+                {
+                    "action": "See similar examples",
+                    "explanation": "It will filter this debugging session to show examples with overconfidence only",
+                    "button": "Get similar examples",
+                    "cta": CallToActionKind.OPEN_DEBUGGER_OVERCONFIDENCE,
+                },
+            ],
+        }
+        self.push_title = res["push_title"]
+        self.details = res["details"]
+
+
+class BorderlinePush(ExamplePush):
+    """
+    Recommend actions for borderline/underconfidence cases.
+
+    Description:
+        Tag examples that are classified with very low confidence,
+        indicating the model is unsure about the prediction.
+        This may be due to inconsistent patterns or insufficient data.
+
+    Triggering event:
+        When we switch examples, the example is classified as underconfident.
+        By default, we mark a prediction as underconfident when the second most
+        probable prediction has a probability which is only less than 10%
+        smaller than the predicted label
+
+    Call to action description:
+        Create one-sample test: This adds a test that checks if the model is underconfident on this example to a test suite.
+        Get similar examples: This filters the debugging session to show examples with underconfidence only.
+
+    Requirements:
+        Classification models only
+    """
+
+    def __init__(self, training_label, training_label_proba, dataset_row, rate):
+        self._borderline()
+        self.pushkind = PushKind.BORDERLINE
+
+        self.training_label_proba = training_label_proba
+        self.training_label = training_label
+        self.saved_example = dataset_row
+
+        self.tests = [one_sample_underconfidence_test]
+        self.test_params = {"saved_example": dataset_row}
+        # [
+        #     if_underconfidence_rate_decrease(rate=rate),
+        #     correct_example(saved_example=dataset_row, training_label=training_label),
+        #     increase_probability(
+        #         saved_example=dataset_row, training_label=training_label, training_label_proba=training_label_proba
+        #     ),
+        # ]
+
+    def _borderline(self):
+        """
+        Generate borderline push title and details.
+        """
+        res = {
+            "push_title": "This example was predicted with very low confidence",
+            "details": [
+                # Disabled temporarily
+                # {
+                # "action": "Save this example for further inspection and testing",
+                # "explanation": "This may help you identify inconsistent patterns and create one-sample tests based on these examples",
+                # "button": "Save Example",
+                # "cta": CallToActionKind.SaveExample,
+                # },
+                {
+                    "action": "Generate a one-sample to automatically test the underconfidence",
+                    "explanation": "This may help you ensure this example is not predicted with low confidence for a new model",
+                    "button": "Create one-sample test",
+                    "cta": CallToActionKind.CREATE_TEST,
+                },
+                {
+                    "action": "See similar examples",
+                    "explanation": "It will filter this debugging session to show examples with underconfidence only",
+                    "button": "Get similar examples",
+                    "cta": CallToActionKind.OPEN_DEBUGGER_BORDERLINE,
+                },
+            ],
+        }
+        self.push_title = res["push_title"]
+        self.details = res["details"]
+
+
+class ContributionPush(FeaturePush):
+    """
+    Recommend actions for feature that have high SHAP values.
+
+    Description:
+        Tag features that have a high SHAP value for this example.
+        This may indicate that the model is relying heavily on this feature to make the prediction.
+
+    Triggering event:
+        When we switch examples and the most contributing shapley’s value
+        is really high compared to the rest of the features.
+        We mark a feature as high contributing by computing SHAP values
+        for all features. Then we calculates z-scores to find any significant outliers.
+        If the z-score is above a threshold (typically determined automatically
+        depending on the number of features), then the feature is considered high contributing.
+
+
+    Call to action description:
+        Save Slice : This will save the slice in the catalog and enable you to create tests more efficiently.
+        Add Test to a test suite : This will add a test to a test suite to check if this slice performs better or worse than the rest of the dataset.
+        Get similar examples : This will filter this debugging session to show examples from this slice only.
+
+    Requirements:
+        Numerical and Categorical features only
+    """
+
+    slicing_function = None
+    bounds = None
+    model_type = None
+    correct_prediction = None
+
+    def __init__(self, value=None, feature=None, bounds=None, model_type=None, correct_prediction=None):
+        self.pushkind = PushKind.CONTRIBUTION
+
+        self.value = value
+        self.bounds = bounds
+        self.feature = feature
+        self.model_type = model_type
+        self.correct_prediction = correct_prediction
+
+        self._slicing_function()
+        self._set_title_and_details()
+        self._test_selection()
+
+    def _set_title_and_details(self):
+        """
+        Generate title and details based on prediction.
+        """
+        if self.correct_prediction:
+            self.push_title = f"`{str(self.feature)}`=={str(self.value)} contributes a lot to the prediction"
+            self.details = [
+                {
+                    "action": f"Save the {'quartile' if self.bounds is not None else 'slice'} {self.slicing_function.query} and continue debugging session",
+                    "explanation": "Saving the slice will enable you to create tests more efficiently",
+                    "button": "Save Slice",
+                    "cta": CallToActionKind.CREATE_SLICE,
+                },
+                {
+                    "action": "Automatically generate a test ",
+                    "explanation": f"Theil`s U test will help you check the nominal association between {self.slicing_function.query} and the predicted label on the whole dataset",
+                    "button": "Add Test to a test suite",
+                    "cta": CallToActionKind.CREATE_TEST,
+                },
+                {
+                    "action": "Get similar examples",
+                    "explanation": "It will filter this debugging session to show examples from this slice only",
+                    "button": "Get similar examples",
+                    "cta": CallToActionKind.CREATE_SLICE_OPEN_DEBUGGER,
+                },
+            ]
+        else:
+            self.push_title = f"`{str(self.feature)}`=={str(self.value)} contributes a lot to the incorrect prediction"
+            self.details = [
+                {
+                    "action": f"Save the {'quartile' if self.bounds is not None else 'slice'} {self.slicing_function.query} and continue debugging session",
+                    "explanation": "Saving the slice will enable you to create tests more efficiently",
+                    "button": "Save Slice",
+                    "cta": CallToActionKind.CREATE_SLICE,
+                },
+                {
+                    "action": "Automatically generate a test",
+                    "explanation": "Performance (RMSE or F1) test will help you check if this slice performs better than the rest of the dataset",
+                    "button": "Add Test to a test suite",
+                    "cta": CallToActionKind.CREATE_TEST,
+                },
+                {
+                    "action": "Get similar examples",
+                    "explanation": "It will filter this debugging session to show examples from this slice only",
+                    "button": "Get similar examples",
+                    "cta": CallToActionKind.CREATE_SLICE_OPEN_DEBUGGER,
+                },
+            ]
+
+    def _slicing_function(self):
+        """
+        Generate slicing function based on feature/value.
+        """
+        if self.bounds is not None:
+            clause = [GreaterThan(self.feature, self.bounds[0], True), LowerThan(self.feature, self.bounds[1], True)]
+        else:
+            clause = [EqualTo(self.feature, self.value)]
+        slicing_func = QueryBasedSliceFunction(Query(clause))
+        self.slicing_function = slicing_func
+        self.test_params = {"slicing_function": slicing_func}
+
+    def _test_selection(self):
+        """
+        Select statistical test based on prediction type.
+        """
+        if not self.correct_prediction:
+            if self.model_type == SupportedModelTypes.REGRESSION:
+                self.tests = [test_diff_rmse_push]
+            elif self.model_type == SupportedModelTypes.CLASSIFICATION:
+                self.tests = [test_diff_f1_push]
+        elif self.correct_prediction:
+            self.tests = [test_theil_u]
+
+
+class PerturbationPush(FeaturePush):
+    """
+    Recommend actions for feature that perturb the prediction.
+
+    Description:
+        Tag features that when perturbed, change the prediction.
+        This may indicate that the model is sensitive to this feature.
+
+    Triggering event:
+        When we switch examples and the prediction changes when we perturb a feature.
+        We mark a feature as sensitive by applying supported perturbations to each feature in the dataset.
+        For numerical columns, we add/subtract values based on mean absolute deviation.
+        For text columns, we apply predefined text transformations.
+
+    Call to action description:
+        Add to test suite : This will add a test to a test suite to check if a
+        perturbation on this feature changes the prediction above a threshold.
+
+    Requirements:
+        Need Ground truth label
+        Numerical and Text features only
+    """
+
+    value_perturbed: Optional[list] = None
+    transformation_functions: Optional[list] = None
+    transformation_functions_params: Optional[list] = None
+    details = [
+        {
+            "action": "Generate a metamorphic invariance test that slightly perturbs this feature",
+            "explanation": "This will enable you to make sure the model is robust against similar small changes",
+            "button": "Add to test suite",
+            "cta": CallToActionKind.CREATE_TEST,
+        },
+    ]
+
+    def __init__(self, value, feature, transformation_info: TransformationInfo):
+        self.pushkind = PushKind.PERTURBATION
+        self.feature = feature
+        self.value = value
+        self.value_perturbed = transformation_info.value_perturbed
+        self.transformation_functions = transformation_info.transformation_functions
+        self.transformation_functions_params = transformation_info.transformation_functions_params
+        if self.transformation_functions_params:
+            self.tests = [test_metamorphic_invariance_with_mad]
+            self.test_params = self.transformation_functions_params[0]
+            self.push_title = (
+                f"Adding {round(self.value_perturbed[0] - self.value, 2)} to `{self.feature}` makes the prediction change"
+            )
+        else:
+            self.tests = [test_metamorphic_invariance]
+            self.test_params = {"transformation_function": self.transformation_functions[0]}
+            self.push_title = f"""Perturbing `{self.feature}` into "{self.value_perturbed[0]}" makes the prediction change"""
diff --git a/python-client/giskard/push/contribution.py b/python-client/giskard/push/contribution.py
new file mode 100644
index 0000000000..1a2066dbde
--- /dev/null
+++ b/python-client/giskard/push/contribution.py
@@ -0,0 +1,138 @@
+"""
+Trigger functions for model debugging contribution notifications.
+
+Functions:
+
+- create_contribution_push: Create contribution push.
+- detect_shap_outlier: Detect outlier SHAP value.
+- get_shap_values: Get SHAP values for example.
+- existing_shap_values: Check if SHAP values exist.
+
+"""
+import numpy as np
+import pandas as pd
+from scipy.stats import zscore
+
+from giskard.core.core import SupportedModelTypes
+from giskard.datasets.base import Dataset
+from giskard.models.base.model import BaseModel
+
+from ..models.model_explanation import explain
+from ..push import ContributionPush
+from .utils import slice_bounds
+
+
+def create_contribution_push(model: BaseModel, ds: Dataset, df: pd.DataFrame) -> ContributionPush:
+    """
+    Create contribution notification from SHAP values.
+
+    Analyzes SHAP values to find feature with outlier contribution.
+    Checks if contribution results in correct/incorrect prediction.
+
+    If outlier contribution found, creates ContributionPush.
+
+    Args:
+        model (BaseModel): ML model
+        ds (Dataset): Original dataset
+        df (pd.DataFrame): DataFrame with row to analyze
+
+    Returns:
+        ContributionPush if outlier contribution found, else None
+    """
+    if _existing_shap_values(ds):
+        shap_res = _detect_shap_outlier(model, ds, df)
+        slice_df = Dataset(df=df, target=ds.target, column_types=ds.column_types.copy(), validation=False)
+        values = slice_df.df
+
+        if model.meta.model_type == SupportedModelTypes.CLASSIFICATION:
+            training_label = values[ds.target].values[0]
+            prediction = model.predict(slice_df).prediction[0]
+
+            correct_prediction = training_label == prediction
+
+        if model.meta.model_type == SupportedModelTypes.REGRESSION:
+            y = values[ds.target].values[0]
+            y_hat = model.predict(slice_df).prediction[0]
+            error = abs(y_hat - y)
+
+            correct_prediction = abs(error - y) / y < 0.2
+
+        if shap_res is not None and ds.column_types[shap_res] != "text":
+            bounds = slice_bounds(feature=shap_res, value=values[shap_res].values[0], ds=ds)
+            return ContributionPush(
+                feature=shap_res,
+                value=values[shap_res].values[0],
+                bounds=bounds,
+                model_type=model.meta.model_type,
+                correct_prediction=correct_prediction,
+            )
+
+
+def _detect_shap_outlier(model: BaseModel, ds: Dataset, df: pd.DataFrame):
+    """
+    Detect outlier SHAP value for a given prediction.
+
+    Computes SHAP values for all features. Calculates z-scores
+    to find any significant outliers.
+
+    Args:
+        model (BaseModel): ML model
+        ds (Dataset): Dataset
+        df (pd.DataFrame): DataFrame with row
+
+    Returns:
+        Feature name with outlier SHAP value, if any
+    """
+    feature_shap = _get_shap_values(model, ds, df)
+    keys = list(feature_shap.keys())
+
+    zscore_array = np.round(zscore(list(feature_shap.values())) * 2) / 2
+
+    if zscore_array[-1] >= 2:
+        return keys[-1]
+    else:
+        return None
+
+
+def _get_shap_values(model: BaseModel, ds: Dataset, df: pd.DataFrame):
+    """
+    Get SHAP values for a model prediction on an example.
+
+    Computes SHAP values that explain the model's output for a given
+    input example.
+
+    For classification, returns values for predicted class label.
+    For regression, returns values for default output.
+
+    Args:
+        model (BaseModel): ML model
+        ds (Dataset): Dataset
+        df (pd.DataFrame): DataFrame with example row
+
+    Returns:
+        Dictionary of SHAP values per feature
+    """
+    if model.meta.model_type == SupportedModelTypes.CLASSIFICATION:
+        return explain(model, ds, df.iloc[0])["explanations"][model.meta.classification_labels[0]]
+    elif model.meta.model_type == SupportedModelTypes.REGRESSION:
+        return explain(model, ds, df.iloc[0])["explanations"]["default"]
+
+
+def _existing_shap_values(ds: Dataset):
+    """
+    Check if SHAP values can be computed for dataset features.
+
+    SHAP values require at least 2 numerical features.
+    Text features are excluded since SHAP is not supported.
+
+    Args:
+        ds (Dataset): Dataset
+
+    Returns:
+        True if SHAP values can be computed, False otherwise.
+    """
+    feature_types = list(ds.column_types.values())
+    if "text" in feature_types:
+        feature_types.remove("text")
+    shap_values_exist = len(feature_types) >= 2
+    return shap_values_exist
diff --git a/python-client/giskard/push/perturbation.py b/python-client/giskard/push/perturbation.py
new file mode 100644
index 0000000000..05e63247a0
--- /dev/null
+++ b/python-client/giskard/push/perturbation.py
@@ -0,0 +1,269 @@
+"""
+Trigger functions for model debugging prediction notifications.
+
+Functions:
+
+- create_perturbation_push: Create a perturbation notification by applying transformations.
+- _apply_perturbation: Apply perturbation to a feature and check if prediction changes.
+- _check_after_perturbation: Check if perturbation changed the model's prediction.
+
+"""
+from typing import Optional
+
+import numpy as np
+import pandas as pd
+
+from giskard.core.core import SupportedModelTypes
+from giskard.datasets.base import Dataset
+from giskard.ml_worker.testing.functions.transformation import (
+    compute_mad,
+    mad_transformation,
+)
+from giskard.models.base.model import BaseModel
+from giskard.push.utils import (
+    SupportedPerturbationType,
+    TransformationInfo,
+    coltype_to_supported_perturbation_type,
+)
+from giskard.scanner.robustness.text_transformations import (
+    TextGenderTransformation,
+    TextLowercase,
+    TextPunctuationRemovalTransformation,
+    TextTitleCase,
+    TextTypoTransformation,
+    TextUppercase,
+)
+from ..push import PerturbationPush
+
+text_transfo_list = [
+    TextLowercase,
+    TextUppercase,
+    TextTitleCase,
+    TextTypoTransformation,
+    TextPunctuationRemovalTransformation,
+    TextGenderTransformation,
+]
+
+
+def create_perturbation_push(
+    model: BaseModel, ds: Dataset, df: pd.DataFrame
+) -> PerturbationPush:
+    """Create a perturbation notification by applying transformations.
+
+    Applies supported perturbations to each feature in the dataset
+    based on column type. If the prediction changes after perturbation,
+    creates and returns a PerturbationPush.
+
+    Args:
+        model: Model used for prediction
+        ds: Dataset
+        df: DataFrame containing row to analyze
+
+    Returns:
+        PerturbationPush if perturbation changed prediction, else None
+    """
+
+    for feat, coltype in ds.column_types.items():
+        coltype = coltype_to_supported_perturbation_type(coltype)
+        transformation_info = _apply_perturbation(model, ds, df, feat, coltype)
+        value = df.iloc[0][feat]
+        if transformation_info is not None:
+            return PerturbationPush(
+                feature=feat,
+                value=value,
+                transformation_info=transformation_info,
+            )
+
+
+def _apply_perturbation(
+    model: BaseModel,
+    ds: Dataset,
+    df: pd.DataFrame,
+    feature: str,
+    col_type: SupportedPerturbationType,
+) -> Optional[TransformationInfo]:
+    """
+    Apply perturbation to a feature and check if prediction changes.
+
+    Creates a slice of the input dataframe with only the row to perturb.
+    Applies supported perturbations based on column type.
+
+    For numeric columns, adds/subtracts values based on mean absolute deviation.
+    For text columns, applies predefined text transformations.
+
+    After each perturbation, checks if the model's prediction changes
+    compared to the original unperturbed input.
+
+    Args:
+        model (BaseModel): ML model to make predictions
+        ds (Dataset): Original dataset
+        df (pd.Dataframe): DataFrame containing row to perturb
+        feature (str): Name of feature column to perturb
+        col_type: Data type of feature column
+
+    Returns:
+        TransformationInfo if perturbation changed prediction, else None.
+        Includes details like perturbed values, functions.
+    """
+    transformation_function = list()
+    value_perturbed = list()
+    transformation_functions_params = list()
+    passed = False
+    # Create a slice of the dataset with only the row to perturb
+    ds_slice = Dataset(
+        df=df,
+        target=ds.target,
+        column_types=ds.column_types.copy(),
+        validation=False,
+    )
+
+    # Create a copy of the slice to apply the transformation
+    ds_slice_copy = ds_slice.copy()
+
+    # Apply the transformation
+    if col_type == SupportedPerturbationType.NUMERIC:
+        passed = _numeric(
+            ds,
+            ds_slice,
+            ds_slice_copy,
+            feature,
+            model,
+            transformation_function,
+            transformation_functions_params,
+            value_perturbed,
+        )
+
+    elif col_type == SupportedPerturbationType.TEXT:
+        passed = _text(
+            ds_slice,
+            ds_slice_copy,
+            feature,
+            model,
+            transformation_function,
+            value_perturbed,
+        )
+
+    value_perturbed.reverse()
+    transformation_function.reverse()
+    transformation_functions_params.reverse()
+    return (
+        TransformationInfo(
+            value_perturbed=value_perturbed,
+            transformation_functions=transformation_function,
+            transformation_functions_params=transformation_functions_params,
+        )
+        if passed
+        else None
+    )
+
+
+def _text(
+    ds_slice,
+    ds_slice_copy,
+    feature,
+    model,
+    transformation_function,
+    value_perturbed,
+):
+    passed = False
+    # Iterate over the possible text transformations
+    for text_transformation in text_transfo_list:
+        # Create the transformation
+        t = text_transformation(column=feature)
+
+        # Transform the slice
+        transformed = ds_slice_copy.transform(t)
+
+        # Generate the perturbation
+        passed = _check_after_perturbation(model, ds_slice, transformed)
+
+        if passed:
+            value_perturbed.append(transformed.df[feature].values.item(0))
+            transformation_function.append(t)
+    if len(value_perturbed) > 0:
+        passed = True
+    return passed
+
+
+def _numeric(
+    ds: Dataset,
+    ds_slice,
+    ds_slice_copy,
+    feature,
+    model,
+    transformation_function,
+    transformation_functions_params,
+    value_perturbed,
+):
+    # Compute the MAD of the column
+    mad = compute_mad(ds.df[feature])  # Small issue: distribution might not be normal
+    values_added_list = [
+        np.linspace(-2 * mad, 0, num=10),
+        np.linspace(2 * mad, 0, num=10),
+    ]
+    if ds.df.dtypes[feature] == "int64":
+        values_added_list = [
+            np.unique(np.linspace(-2 * mad, 0, num=10).round().astype(int)),
+            np.unique(np.linspace(2 * mad, 0, num=10).round().astype(int)),
+        ]
+    value_to_perturb = ds.df[feature].iloc[0]
+    for values_added in values_added_list:
+        for value in values_added:
+            if ds.df[feature].max() >= value + value_to_perturb >= ds.df[feature].min():
+                # Create the transformation
+                t = mad_transformation(column_name=feature, value_added=value)
+
+                # Transform the slice
+                transformed = ds_slice_copy.transform(t)
+
+                # Generate the perturbation
+                perturbed = _check_after_perturbation(model, ds_slice, transformed)
+
+                if perturbed:
+                    value_perturbed.append(transformed.df[feature].values.item(0))
+                    transformation_function.append(t)
+                    transformation_functions_params.append(
+                        dict(column_name=feature, value_added=float(value))
+                    )
+                else:
+                    break
+    return len(transformation_function) > 0
+
+
+def _check_after_perturbation(
+    model: BaseModel, ref_row: Dataset, row_perturbed: Dataset
+) -> bool:
+    """
+    Check if perturbation changed the model's prediction.
+
+    Compares the model's prediction on the original unperturbed
+    row versus the perturbed row.
+
+    For classification, checks if predicted class changes.
+    For regression, checks if prediction value changes significantly.
+
+    Args:
+        model (BaseModel): ML model
+        ref_row (Dataset): Row before perturbation
+        row_perturbed (Dataset): Row after perturbation
+
+    Returns:
+        bool indicating if prediction changed
+    """
+    if model.meta.model_type == SupportedModelTypes.CLASSIFICATION:
+        # Compute the probability of the reference row
+        ref_pred = model.predict(ref_row).prediction[0]
+        # Compute the probability of the perturbed row
+        pred = model.predict(row_perturbed).prediction[0]
+        # Check if the probability of the reference row is different from the probability of the perturbed row
+        passed = ref_pred != pred
+        return passed
+
+    elif model.meta.model_type == SupportedModelTypes.REGRESSION:
+        # Compute the prediction of the reference row
+        ref_val = model.predict(ref_row).prediction[0]
+        # Compute the prediction of the perturbed row
+        new_val = model.predict(row_perturbed).prediction[0]
+        # Check if the prediction of the reference row is different from the prediction of the perturbed row
+        passed = (new_val - ref_val) / ref_val >= 0.2
+        return passed
diff --git a/python-client/giskard/push/prediction.py b/python-client/giskard/push/prediction.py
new file mode 100644
index 0000000000..f263ebd335
--- /dev/null
+++ b/python-client/giskard/push/prediction.py
@@ -0,0 +1,88 @@
+"""
+Trigger functions for model debugging prediction notifications.
+
+Functions:
+
+- create_overconfidence_push: Create overconfidence notification from model prediction.
+- create_borderline_push: Create borderline/underconfidence notification from prediction.
+
+"""
+import pandas as pd
+
+from giskard.datasets.base import Dataset
+from giskard.models.base.model import BaseModel
+from giskard.testing.tests.calibration import (
+    test_overconfidence_rate,
+    test_underconfidence_rate,
+)
+
+from ..push import BorderlinePush, OverconfidencePush
+
+
+def create_overconfidence_push(model: BaseModel, ds: Dataset, df: pd.DataFrame) -> OverconfidencePush:
+    """
+    Create overconfidence notification from model prediction.
+
+    Checks if model is overconfident on a given row based on
+    overconfidence rate test.
+
+    If overconfidence detected and predicted class is incorrect,
+    creates and returns OverconfidencePush.
+
+    Args:
+        model (BaseModel): Giskard model
+        ds (Dataset): Original dataset
+        df (pd.DataFrame): DataFrame with row to analyze
+
+    Returns:
+        OverconfidencePush if overconfidence and misprediction
+        None otherwise
+    """
+    if model.is_classification:
+        row_slice = Dataset(df=df, target=ds.target, column_types=ds.column_types.copy(), validation=False)
+
+        values = row_slice.df
+        training_label = values[ds.target].values[0]
+        model_prediction_results = model.predict(row_slice)
+        training_label_proba = model_prediction_results.all_predictions[training_label].values[0]
+        prediction = model_prediction_results.prediction[0]
+
+        test_result = test_overconfidence_rate(model, row_slice).execute()
+        if not test_result.passed and training_label != prediction:
+            return OverconfidencePush(
+                training_label, training_label_proba, row_slice, prediction, rate=test_result.metric
+            )
+
+
+def create_borderline_push(model: BaseModel, ds: Dataset, df: pd.DataFrame) -> BorderlinePush:
+    """
+    Create borderline/underconfidence notification from prediction.
+
+    Checks if model is underconfident on a given row based on
+    underconfidence rate test.
+
+    If underconfidence detected, creates and returns BorderlinePush.
+
+    Args:
+        model (BaseModel): ML model
+        ds (Dataset): Original dataset
+        df (pd.DataFrame): DataFrame with row to analyze
+
+    Returns:
+        BorderlinePush if underconfident, None otherwise.
+    """
+    if model.is_classification:
+        row_slice = Dataset(
+            df=df,
+            target=ds.target,
+            column_types=ds.column_types.copy(),
+            validation=False,
+            name=f"One-Sample of <dataset:{ds.id}> for underconfidence test using <model:{model.id}>",
+        )
+        values = row_slice.df
+        target_value = values[ds.target].values.item()
+        prediction_results = model.predict(row_slice)
+        target_value_proba = prediction_results.all_predictions[target_value].values.item()
+        test_result = test_underconfidence_rate(model, row_slice).execute()
+        if not test_result.passed:
+            return BorderlinePush(target_value, target_value_proba, row_slice, rate=test_result.metric)
diff --git a/python-client/giskard/push/push_test_catalog/catalog.py b/python-client/giskard/push/push_test_catalog/catalog.py
new file mode 100644
index 0000000000..a79f5849af
--- /dev/null
+++ b/python-client/giskard/push/push_test_catalog/catalog.py
@@ -0,0 +1,262 @@
+"""
+This module defines various test functions that can be used with pushes.
+
+The main functions are:
+
+- if_underconfidence_rate_decrease: Custom test for underconfidence rate decrease  
+- if_overconfidence_rate_decrease: Custom test for overconfidence rate decrease
+- correct_example: Unit test for example correctness
+- increase_probability: Test for increasing probability of ground truth label
+- one_sample_overconfidence_test: One-sample test for overconfidence
+- one_sample_underconfidence_test: One-sample test for underconfidence
+- test_metamorphic_invariance_with_mad: Metamorphic test with mean absolute deviation
+
+These test functions allow validating pushes and can be added to test suites.
+"""
+from typing import Any, Optional
+
+from giskard import SlicingFunction, TestResult, test
+from giskard.datasets.base import Dataset
+from giskard.ml_worker.testing.functions.transformation import mad_transformation
+from giskard.ml_worker.testing.utils import Direction, check_slice_not_empty
+from giskard.models.base import BaseModel
+from giskard.testing.tests.calibration import test_overconfidence_rate, test_underconfidence_rate
+from giskard.testing.tests.metamorphic import test_metamorphic_invariance
+from giskard.testing.tests.performance import _test_diff_prediction, test_f1, test_rmse
+
+
+@test(name="Slicing RMSE difference", tags=["performance", "regression", "ground_truth", "push"])
+def test_diff_rmse_push(
+    model: BaseModel,
+    dataset: Dataset,
+    slicing_function: Optional[SlicingFunction] = None,
+    threshold: float = 0.1,
+    direction: Direction = Direction.Decreasing,
+    debug: bool = False,
+):
+    """
+    Test for difference in RMSE between a slice and full dataset.
+
+    Checks if the RMSE on a sliced subset of the data is significantly
+    different from the full dataset based on a threshold and direction.
+
+    Can be used with pushes to test if problematic slices have worse RMSE.
+
+    Args:
+        model: Model to test
+        dataset: Full dataset
+        slicing_function: Function to slice dataset
+        threshold: Allowed RMSE difference
+        direction: Whether slice RMSE should increase or decrease
+        debug: Whether to return debug dataset
+
+    Returns:
+        TestResult with pass/fail, slice sizes, RMSE diff, debug dataset
+    """
+    if slicing_function:
+        test_name = "test_diff_rmse_push"
+        actual_dataset = dataset.slice(slicing_function)
+        check_slice_not_empty(sliced_dataset=actual_dataset, dataset_name="actual_dataset", test_name=test_name)
+        check_slice_not_empty(sliced_dataset=dataset, dataset_name="reference_dataset", test_name=test_name)
+
+    return _test_diff_prediction(
+        test_rmse.test_fn,
+        model,
+        actual_dataset,
+        dataset,
+        threshold=threshold,
+        direction=direction,
+        test_name="RMSE",
+        debug=debug,
+    )
+
+
+@test(name="Slicing f1 difference", tags=["performance", "classification", "ground_truth", "push"])
+def test_diff_f1_push(
+    model: BaseModel,
+    dataset: Dataset,
+    slicing_function: Optional[SlicingFunction] = None,
+    threshold: float = -0.1,
+    direction: Direction = Direction.Increasing,
+    debug: bool = False,
+):
+    """
+    Test for difference in F1 score between a slice and full dataset.
+
+    Checks if the F1 score on a sliced subset of the data is significantly
+    different from the full dataset based on a threshold and direction.
+
+    Can be used with pushes to test if problematic slices have worse F1 score.
+
+    Args:
+        model: Model to test
+        dataset: Full dataset
+        slicing_function: Function to slice dataset
+        threshold: Allowed F1 score difference
+        direction: Whether slice F1 should increase or decrease
+        debug: Whether to return debug dataset
+
+    Returns:
+       TestResult with pass/fail, slice sizes, F1 diff, debug dataset
+    """
+    if slicing_function:
+        test_name = "test_diff_f1_push"
+        actual_dataset = dataset.slice(slicing_function)
+        check_slice_not_empty(sliced_dataset=actual_dataset, dataset_name="actual_dataset", test_name=test_name)
+        check_slice_not_empty(sliced_dataset=dataset, dataset_name="reference_dataset", test_name=test_name)
+
+    return _test_diff_prediction(
+        test_f1.test_fn,
+        model,
+        actual_dataset,
+        dataset,
+        threshold=threshold,
+        direction=direction,
+        test_name="f1",
+        debug=debug,
+    )
+
+
+@test(name="If Underconfidence Decreases", tags=["custom"])
+def if_underconfidence_rate_decrease(model: BaseModel, dataset: Dataset, rate: float):
+    """
+    Test if underconfidence rate decreases for model on dataset.
+
+    Checks if the underconfidence rate for the model on the provided dataset
+    is lower than the specified rate.
+
+    Args:
+        model: Model to test
+        dataset: Dataset to test on
+        rate: Target underconfidence rate to decrease from
+
+    Returns:
+        TestResult: Test result with pass/fail and underconfidence rate metric
+    """
+    new_rate = test_underconfidence_rate(model, dataset).metric
+    return TestResult(passed=new_rate < rate, metric=new_rate - rate)
+
+
+@test(name="If Overconfidence Decreases", tags=["custom"])
+def if_overconfidence_rate_decrease(model: BaseModel, dataset: Dataset, rate: float):
+    """
+    Test if overconfidence rate decreases for model on dataset.
+
+    Checks if the overconfidence rate for the model on the provided dataset
+    is lower than the specified rate.
+
+    Args:
+        model: Model to test
+        dataset: Dataset to test on
+        rate: Target overconfidence rate to decrease from
+
+    Returns:
+        TestResult: Test result with pass/fail and overconfidence rate metric
+    """
+    new_rate = test_overconfidence_rate(model, dataset).metric
+    return TestResult(passed=new_rate < rate, metric=new_rate - rate)
+
+
+@test(name="Example Correctness", tags=["unit test", "custom"])
+def correct_example(model: BaseModel, saved_example: Dataset, training_label: Any):
+    """
+    Test if model correctly predicts example.
+
+    Checks if the model's prediction on the saved example matches the
+    provided training label ground truth.
+
+    Args:
+        model: Model to test
+        saved_example: Example dataset
+        training_label: Ground truth label
+
+    Returns:
+        TestResult: Test result with pass/fail
+    """
+    prediction = model.predict(saved_example).prediction.values[0]
+    return TestResult(passed=prediction == training_label, metric=prediction == training_label)
+
+
+@test(name="Increase Probability", tags=["unit test", "custom"])
+def increase_probability(model: BaseModel, saved_example: Dataset, training_label: Any, training_label_proba: Any):
+    """
+    Test if model probability for ground truth label increases.
+
+    Checks if the predicted probability for the training label increases
+    compared to the original training probability.
+
+    Args:
+        model: Model to test
+        saved_example: Example dataset
+        training_label: Ground truth label
+        training_label_proba: Original probability
+
+    Returns:
+        TestResult: Test result with pass/fail and probability metric
+    """
+    proba = model.predict(saved_example).all_predictions[training_label].values[0]
+    return TestResult(passed=proba > training_label_proba, metric=proba - training_label_proba)
+
+
+@test(name="One-Sample Overconfidence test", tags=["one-sample test", "custom"])
+def one_sample_overconfidence_test(model: BaseModel, saved_example: Dataset):
+    """
+    One-sample overconfidence test for example.
+
+    Checks if the overconfidence rate for the model on the
+    provided example is below a threshold.
+
+    Args:
+        model: Model to test
+        saved_example: Example dataset
+
+    Returns:
+        TestResult: Test result with pass/fail and overconfidence rate metric
+    """
+    if model.is_classification:
+        test_result = test_overconfidence_rate(model, saved_example).execute()
+        return TestResult(passed=test_result.passed, metric=test_result.metric)
+
+
+@test(name="One-Sample Underconfidence test", tags=["one-sample test", "custom"])
+def one_sample_underconfidence_test(model: BaseModel, saved_example: Dataset):
+    """
+    One-sample underconfidence test for example.
+
+    Checks if the underconfidence rate for the model on the
+    provided example is below a threshold.
+
+    Args:
+        model: Model to test
+        saved_example: Example dataset
+
+    Returns:
+        TestResult: Test result with pass/fail and underconfidence rate metric
+    """
+    if model.is_classification:
+        test_result = test_underconfidence_rate(model, saved_example).execute()
+        return TestResult(passed=test_result.passed, metric=test_result.metric)
+
+
+@test(name="Numerical Invariance test", tags=["custom"])
+def test_metamorphic_invariance_with_mad(model: BaseModel, dataset: Dataset, column_name: str, value_added: float):
+    """
+    Metamorphic test for numerical invariance with mean absolute deviation.
+
+    Checks if adding a value to a numerical feature keeps the prediction
+    approximately the same using mean absolute deviation.
+
+    Args:
+        model: Model to test
+        dataset: Dataset to test
+        column_name: Name of numerical feature column
+        value_added: Value to add to column
+
+    Returns:
+        TestResult: Test result with pass/fail
+    """
+    return test_metamorphic_invariance(
+        model=model,
+        dataset=dataset,
+        transformation_function=mad_transformation(column_name=column_name, value_added=value_added),
+    ).execute()
diff --git a/python-client/giskard/push/utils.py b/python-client/giskard/push/utils.py
new file mode 100644
index 0000000000..49167039cd
--- /dev/null
+++ b/python-client/giskard/push/utils.py
@@ -0,0 +1,78 @@
+"""
+Utility functions for model debugging notifications.
+
+Classes:
+- SupportedPerturbationType: Enumeration of supported perturbation types.
+- TransformationInfo: Dataclass to hold perturbation info.
+
+Functions:
+
+- slice_bounds: Get quartile bounds values to slice Giskard dataset on a numerical feature.
+- coltype_to_supported_perturbation_type: Map column type to perturbation type enum.
+
+"""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Union, Optional
+
+import numpy as np
+
+from giskard import Dataset
+
+
+class SupportedPerturbationType(Enum):
+    """Enumeration of supported perturbation types."""
+
+    NUMERIC = "numeric"
+    TEXT = "text"
+
+
+@dataclass
+class TransformationInfo:
+    """Class to hold perturbation transformation information."""
+
+    value_perturbed: list
+    transformation_functions: list
+    transformation_functions_params: list
+
+
+def slice_bounds(feature: str, value: Union[int, float], ds: Dataset) -> Optional[List[Union[int, float]]]:
+    """Get quartile bounds values to slice Giskard dataset on a numerical feature.
+
+    Args:
+        feature (str): Feature name
+        value (float or int): Feature value
+        ds (Dataset): Dataset
+
+    Returns:
+        list: Lower and upper bounds of the slice
+    """
+    if ds.column_types[feature] == "numeric":
+        # Find the quartile bounds for the value
+        q1, q2, q3 = np.nanpercentile(ds.df[feature], [25, 50, 75])
+        if value < q1:
+            return [ds.df[feature].min(), q1]
+        elif q1 <= value < q2:
+            return [q1, q2]
+        elif q2 <= value < q3:
+            return [q2, q3]
+        else:
+            return [q3, ds.df[feature].max()]
+    else:
+        return None
+
+
+def coltype_to_supported_perturbation_type(coltype: str) -> SupportedPerturbationType:
+    """Map column type to supported perturbation type enum.
+
+    Args:
+        coltype (str): Column type
+
+    Returns:
+        SupportedPerturbationType: Perturbation type enum
+    """
+    if coltype == "numeric":
+        return SupportedPerturbationType.NUMERIC
+    elif coltype == "text":
+        return SupportedPerturbationType.TEXT
diff --git a/python-client/giskard/slicing/slice.py b/python-client/giskard/slicing/slice.py
index f2fd20ffe6..05998d781a 100644
--- a/python-client/giskard/slicing/slice.py
+++ b/python-client/giskard/slicing/slice.py
@@ -222,6 +222,9 @@ class Query:
     def __init__(self, clauses, optimize=False):
         self.clauses = defaultdict(list)
         for clause in clauses:
+            # if clause.value is an int64, convert it to an int
+            if isinstance(clause.value, np.int64):
+                clause.value = int(clause.value)
             self.clauses[clause.column].append(clause)
 
         if optimize:
diff --git a/python-client/giskard/utils/artifacts.py b/python-client/giskard/utils/artifacts.py
index 554eebe807..a535d15b1e 100644
--- a/python-client/giskard/utils/artifacts.py
+++ b/python-client/giskard/utils/artifacts.py
@@ -1,17 +1,17 @@
 import inspect
 import uuid
-from typing import Any, Union
+from typing import Any, Optional, Union
 
 try:
     from types import NoneType
 except ImportError:
     # types.NoneType is only available from python >=3.10
-    NoneType = None.__class__
+    NoneType = type(None)
 
 PRIMITIVES = Union[bool, str, int, float, NoneType]
 
 
-def _serialize_artifact(artifact, artifact_uuid: Union[str, uuid.UUID, NoneType] = None) -> str:
+def _serialize_artifact(artifact, artifact_uuid: Optional[Union[str, uuid.UUID]]) -> str:
     if artifact_uuid is None:
         raise ValueError(f"Cannot serialize artifacts without UUID: {artifact}")
 
diff --git a/python-client/tests/test_push.py b/python-client/tests/test_push.py
new file mode 100644
index 0000000000..41d85cbf67
--- /dev/null
+++ b/python-client/tests/test_push.py
@@ -0,0 +1,213 @@
+import numpy as np
+from giskard.ml_worker.testing.functions.transformation import mad_transformation
+
+from giskard.ml_worker.testing.registry.giskard_test import GiskardTest
+from giskard.ml_worker.testing.registry.slicing_function import slicing_function
+from giskard.push import Push
+from giskard.push.contribution import create_contribution_push
+from giskard.push.perturbation import create_perturbation_push
+from giskard.push.prediction import create_borderline_push, create_overconfidence_push
+from giskard.push.utils import (
+    SupportedPerturbationType,
+    TransformationInfo,
+    coltype_to_supported_perturbation_type,
+    slice_bounds,
+)
+from giskard.slicing.slice import QueryBasedSliceFunction
+import pandas as pd
+
+
+# Classification
+def test_instance_if_not_none(german_credit_model, german_credit_data):
+    for i in range(50):
+        push_list = [
+            create_contribution_push(german_credit_model, german_credit_data, german_credit_data.df.iloc[[i]]),
+            create_perturbation_push(german_credit_model, german_credit_data, german_credit_data.df.iloc[[i]]),
+            create_overconfidence_push(german_credit_model, german_credit_data, german_credit_data.df.iloc[[i]]),
+            create_borderline_push(german_credit_model, german_credit_data, german_credit_data.df.iloc[[i]]),
+        ]
+        for push in push_list:
+            if push is not None:
+                assert isinstance(push, Push)
+
+
+def test_slicing_function(german_credit_model, german_credit_data):
+    for i in range(50):
+        push = create_contribution_push(german_credit_model, german_credit_data, german_credit_data.df.iloc[[i]])
+        if push is not None:
+            assert isinstance(push.slicing_function, QueryBasedSliceFunction)
+
+
+def test_test_function(german_credit_model, german_credit_data):
+    for i in range(50):
+        push_list = [
+            create_contribution_push(german_credit_model, german_credit_data, german_credit_data.df.iloc[[i]]),
+            create_perturbation_push(german_credit_model, german_credit_data, german_credit_data.df.iloc[[i]]),
+            create_overconfidence_push(german_credit_model, german_credit_data, german_credit_data.df.iloc[[i]]),
+            create_borderline_push(german_credit_model, german_credit_data, german_credit_data.df.iloc[[i]]),
+        ]
+        for push in push_list:
+            if push is not None:
+                for test in push.tests:
+                    assert isinstance(test(), GiskardTest)
+
+
+# Regression
+def test_instance_if_not_none_reg(linear_regression_diabetes, diabetes_dataset_with_target):
+    for i in range(50):
+        push_list = [
+            create_contribution_push(
+                linear_regression_diabetes, diabetes_dataset_with_target, diabetes_dataset_with_target.df.iloc[[i]]
+            ),
+            create_perturbation_push(
+                linear_regression_diabetes, diabetes_dataset_with_target, diabetes_dataset_with_target.df.iloc[[i]]
+            ),
+            create_overconfidence_push(
+                linear_regression_diabetes, diabetes_dataset_with_target, diabetes_dataset_with_target.df.iloc[[i]]
+            ),
+            create_borderline_push(
+                linear_regression_diabetes, diabetes_dataset_with_target, diabetes_dataset_with_target.df.iloc[[i]]
+            ),
+        ]
+        for push in push_list:
+            if push is not None:
+                assert isinstance(push, Push)
+
+
+def test_slicing_function_reg(linear_regression_diabetes, diabetes_dataset_with_target):
+    for i in range(50):
+        push = create_contribution_push(
+            linear_regression_diabetes, diabetes_dataset_with_target, diabetes_dataset_with_target.df.iloc[[i]]
+        )
+        if push is not None:
+            assert isinstance(push.slicing_function, QueryBasedSliceFunction)
+
+
+def test_test_function_reg(linear_regression_diabetes, diabetes_dataset_with_target):
+    for i in range(50):
+        push_list = [
+            create_contribution_push(
+                linear_regression_diabetes, diabetes_dataset_with_target, diabetes_dataset_with_target.df.iloc[[i]]
+            ),
+            create_perturbation_push(
+                linear_regression_diabetes, diabetes_dataset_with_target, diabetes_dataset_with_target.df.iloc[[i]]
+            ),
+            create_overconfidence_push(
+                linear_regression_diabetes, diabetes_dataset_with_target, diabetes_dataset_with_target.df.iloc[[i]]
+            ),
+            create_borderline_push(
+                linear_regression_diabetes, diabetes_dataset_with_target, diabetes_dataset_with_target.df.iloc[[i]]
+            ),
+        ]
+        for push in push_list:
+            if push is not None:
+                for test in push.tests:
+                    assert isinstance(test(), GiskardTest)
+
+
+# Multiclass Classification
+def test_instance_if_not_none_multi(enron_model, enron_data):
+    for i in range(50):
+        push_list = [
+            create_contribution_push(enron_model, enron_data, enron_data.df.iloc[[i]]),
+            create_perturbation_push(enron_model, enron_data, enron_data.df.iloc[[i]]),
+            create_overconfidence_push(enron_model, enron_data, enron_data.df.iloc[[i]]),
+            create_borderline_push(enron_model, enron_data, enron_data.df.iloc[[i]]),
+        ]
+        for push in push_list:
+            if push is not None:
+                assert isinstance(push, Push)
+
+
+def test_slicing_function_multi(enron_model, enron_data):
+    for i in range(50):
+        push = create_contribution_push(enron_model, enron_data, enron_data.df.iloc[[i]])
+        if push is not None:
+            assert isinstance(push.slicing_function, QueryBasedSliceFunction)
+
+
+def test_test_function_multi(enron_model, enron_data):
+    for i in range(50):
+        push_list = [
+            create_contribution_push(enron_model, enron_data, enron_data.df.iloc[[i]]),
+            create_perturbation_push(enron_model, enron_data, enron_data.df.iloc[[i]]),
+            create_overconfidence_push(enron_model, enron_data, enron_data.df.iloc[[i]]),
+            create_borderline_push(enron_model, enron_data, enron_data.df.iloc[[i]]),
+        ]
+        for push in push_list:
+            if push is not None:
+                for test in push.tests:
+                    assert isinstance(test(), GiskardTest)
+
+
+def test_mad_transformation_mad_precomputed(enron_data):
+    data = enron_data.copy().df
+    res = mad_transformation(data, "salary", value_added=1000)
+    assert res
+
+
+def test_mad_transformation_mad_empty(enron_data):
+    data = enron_data.copy().df
+    res = mad_transformation(data, "salary")
+    assert res
+
+
+def test_mad_transformation_slicing(enron_data):
+    @slicing_function(row_level=False)
+    def head_slice(df: pd.DataFrame) -> pd.DataFrame:
+        return df.head(10)
+
+    data = enron_data.copy()
+    res = mad_transformation(column_name="Nb_of_forwarded_msg")
+    data_s = data.slice(head_slice)
+    output = data_s.transform(res)
+    assert output
+
+
+def test_supported_perturbation_type_enum():
+    assert SupportedPerturbationType.NUMERIC.value == "numeric"
+    assert SupportedPerturbationType.TEXT.value == "text"
+
+
+def test_transformation_info():
+    ti = TransformationInfo([1, 2], [np.log, np.sqrt], [{"base": 2}, {}])
+    assert ti.value_perturbed == [1, 2]
+    assert ti.transformation_functions == [np.log, np.sqrt]
+    assert ti.transformation_functions_params == [{"base": 2}, {}]
+
+
+def test_slice_bounds_valid_numeric(german_credit_data):
+    numeric_col = german_credit_data.df["credit_amount"]
+    # Get quartile bounds
+    q1, q2, q3 = np.percentile(numeric_col, [25, 50, 75])
+
+    # Test quartile values
+    bounds = slice_bounds("credit_amount", q2, german_credit_data)
+    assert bounds == [q2, q3]
+
+    # Test min/max
+    bounds = slice_bounds("credit_amount", numeric_col.min(), german_credit_data)
+    assert bounds == [numeric_col.min(), q1]
+
+    bounds = slice_bounds("credit_amount", numeric_col.max(), german_credit_data)
+    assert bounds == [q3, numeric_col.max()]
+
+    # Test valid values
+    bounds = slice_bounds("credit_amount", 1500, german_credit_data)
+    assert bounds == [1365.5, 2319.5]
+
+    bounds = slice_bounds("credit_amount", 2500, german_credit_data)
+    assert bounds == [2319.5, 3972.25]
+
+
+def test_slice_bounds_non_numeric(german_credit_data):
+    bounds = slice_bounds("account_check_status", "c", german_credit_data)
+    assert bounds is None
+
+
+def test_coltype_to_supported_perturbation_type():
+    perturbation_type = coltype_to_supported_perturbation_type("numeric")
+    assert perturbation_type == SupportedPerturbationType.NUMERIC
+
+    perturbation_type = coltype_to_supported_perturbation_type("text")
+    assert perturbation_type == SupportedPerturbationType.TEXT