diff --git a/core/config/preconditioner_ic_config.cpp b/core/config/preconditioner_ic_config.cpp
index 7d4cd3d9ca4..d90792c2609 100644
--- a/core/config/preconditioner_ic_config.cpp
+++ b/core/config/preconditioner_ic_config.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -6,11 +6,6 @@
 #include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/preconditioner/ic.hpp>
-#include <ginkgo/core/preconditioner/ilu.hpp>
-#include <ginkgo/core/preconditioner/isai.hpp>
-#include <ginkgo/core/solver/gmres.hpp>
-#include <ginkgo/core/solver/ir.hpp>
-#include <ginkgo/core/solver/triangular.hpp>
 
 #include "core/config/config_helper.hpp"
 #include "core/config/dispatch.hpp"
@@ -22,85 +17,30 @@ namespace gko {
 namespace config {
 
 
-// For Ic and Ilu, we use additional ValueType to help Solver type decision
-template <typename Solver>
-class IcSolverHelper {
-public:
-    template <typename ValueType, typename IndexType>
-    class Configurator {
-    public:
-        static
-            typename gko::preconditioner::Ic<Solver, IndexType>::parameters_type
-            parse(const pnode& config, const registry& context,
-                  const type_descriptor& td_for_child)
-        {
-            return gko::preconditioner::Ic<Solver, IndexType>::parse(
-                config, context, td_for_child);
-        }
-    };
-};
-
-
-// Do not use the partial specialization for SolverBase<V> and SolverBase<V, I>
-// because the default template arguments are allowed for a template template
-// argument (detail: CWG 150 after c++17
-// https://en.cppreference.com/w/cpp/language/template_parameters#Template_template_arguments)
-template <template <typename V> class SolverBase>
-class IcHelper1 {
-public:
-    template <typename ValueType, typename IndexType>
-    class Configurator
-        : public IcSolverHelper<SolverBase<ValueType>>::template Configurator<
-              ValueType, IndexType> {};
-};
-
-
-template <template <typename V, typename I> class SolverBase>
-class IcHelper2 {
-public:
-    template <typename ValueType, typename IndexType>
-    class Configurator
-        : public IcSolverHelper<SolverBase<ValueType, IndexType>>::
-              template Configurator<ValueType, IndexType> {};
-};
-
-
 template <>
-deferred_factory_parameter<gko::LinOpFactory> parse<LinOpFactoryType::Ic>(
-    const pnode& config, const registry& context, const type_descriptor& td)
+deferred_factory_parameter<gko::LinOpFactory>
+parse<gko::config::LinOpFactoryType::Ic>(const gko::config::pnode& config,
+                                         const gko::config::registry& context,
+                                         const gko::config::type_descriptor& td)
 {
-    auto updated = update_type(config, td);
-    std::string str("solver::LowerTrs");
-    if (auto& obj = config.get("l_solver_type")) {
-        str = obj.get_string();
-    }
-    if (str == "solver::LowerTrs") {
-        return dispatch<gko::LinOpFactory,
-                        IcHelper2<solver::LowerTrs>::Configurator>(
-            config, context, updated,
-            make_type_selector(updated.get_value_typestr(), value_type_list()),
-            make_type_selector(updated.get_index_typestr(), index_type_list()));
-    } else if (str == "solver::Ir") {
-        return dispatch<gko::LinOpFactory, IcHelper1<solver::Ir>::Configurator>(
-            config, context, updated,
-            make_type_selector(updated.get_value_typestr(), value_type_list()),
-            make_type_selector(updated.get_index_typestr(), index_type_list()));
-    } else if (str == "preconditioner::LowerIsai") {
-        return dispatch<gko::LinOpFactory,
-                        IcHelper2<preconditioner::LowerIsai>::Configurator>(
-            config, context, updated,
-            make_type_selector(updated.get_value_typestr(), value_type_list()),
-            make_type_selector(updated.get_index_typestr(), index_type_list()));
-    } else if (str == "solver::Gmres") {
-        return dispatch<gko::LinOpFactory,
-                        IcHelper1<solver::Gmres>::Configurator>(
-            config, context, updated,
-            make_type_selector(updated.get_value_typestr(), value_type_list()),
-            make_type_selector(updated.get_index_typestr(), index_type_list()));
-    } else {
-        GKO_INVALID_CONFIG_VALUE("l_solver_type", str);
+    auto updated = gko::config::update_type(config, td);
+    if (config.get("l_solver_type_or_value_type")) {
+        GKO_INVALID_STATE(
+            "preconditioner::Ic only allows value_type from "
+            "l_solver_type_or_value_type. To avoid type confusion between "
+            "these types and value_type, l_solver_type_or_value_type uses "
+            "the value_type directly.");
     }
+    return gko::config::dispatch<gko::LinOpFactory, gko::preconditioner::Ic>(
+        config, context, updated,
+        gko::config::make_type_selector(updated.get_value_typestr(),
+                                        gko::config::value_type_list()),
+        gko::config::make_type_selector(updated.get_index_typestr(),
+                                        gko::config::index_type_list()));
 }
+static_assert(true,
+              "This assert is used to counter the false positive extra "
+              "semi-colon warnings");
 
 
 }  // namespace config
diff --git a/core/preconditioner/ic.cpp b/core/preconditioner/ic.cpp
index 691795ad60b..0cfa534b546 100644
--- a/core/preconditioner/ic.cpp
+++ b/core/preconditioner/ic.cpp
@@ -1,16 +1,13 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
 #include "ginkgo/core/preconditioner/ic.hpp"
 
 #include <ginkgo/core/base/types.hpp>
+#include <ginkgo/core/base/utils_helper.hpp>
 #include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
-#include <ginkgo/core/preconditioner/isai.hpp>
-#include <ginkgo/core/preconditioner/utils.hpp>
-#include <ginkgo/core/solver/gmres.hpp>
-#include <ginkgo/core/solver/ir.hpp>
 
 #include "core/config/config_helper.hpp"
 #include "core/config/dispatch.hpp"
@@ -21,18 +18,19 @@ namespace preconditioner {
 namespace detail {
 
 
-template <typename Ic,
-          std::enable_if_t<support_ic_parse<typename Ic::l_solver_type>>*>
+template <typename Ic, std::enable_if_t<support_ic_parse<Ic>>*>
 typename Ic::parameters_type ic_parse(
     const config::pnode& config, const config::registry& context,
     const config::type_descriptor& td_for_child)
 {
     auto params = Ic::build();
-
+    using l_solver_type = typename Ic::l_solver_type;
+    static_assert(std::is_same_v<l_solver_type, LinOp>,
+                  "only support IC parse when l_solver_type is LinOp.");
     if (auto& obj = config.get("l_solver")) {
         params.with_l_solver(
-            gko::config::parse_or_get_specific_factory<
-                const typename Ic::l_solver_type>(obj, context, td_for_child));
+            gko::config::parse_or_get_factory<const LinOpFactory>(
+                obj, context, td_for_child));
     }
     if (auto& obj = config.get("factorization")) {
         params.with_factorization(
@@ -44,35 +42,23 @@ typename Ic::parameters_type ic_parse(
 }
 
 
-#define GKO_DECLARE_LOWERTRS_IC_PARSE(ValueType, IndexType)          \
-    typename Ic<solver::LowerTrs<ValueType, IndexType>,              \
-                IndexType>::parameters_type                          \
-    ic_parse<Ic<solver::LowerTrs<ValueType, IndexType>, IndexType>>( \
-        const config::pnode&, const config::registry&,               \
-        const config::type_descriptor&)
-GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_LOWERTRS_IC_PARSE);
-
-#define GKO_DECLARE_IR_IC_PARSE(ValueType, IndexType)              \
-    typename Ic<solver::Ir<ValueType>, IndexType>::parameters_type \
-    ic_parse<Ic<solver::Ir<ValueType>, IndexType>>(                \
-        const config::pnode&, const config::registry&,             \
-        const config::type_descriptor&)
-GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_IR_IC_PARSE);
-
-#define GKO_DECLARE_GMRES_IC_PARSE(ValueType, IndexType)              \
-    typename Ic<solver::Gmres<ValueType>, IndexType>::parameters_type \
-    ic_parse<Ic<solver::Gmres<ValueType>, IndexType>>(                \
-        const config::pnode&, const config::registry&,                \
-        const config::type_descriptor&)
-GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_GMRES_IC_PARSE);
-
-#define GKO_DECLARE_LOWERISAI_IC_PARSE(ValueType, IndexType)                 \
-    typename Ic<LowerIsai<ValueType, IndexType>, IndexType>::parameters_type \
-    ic_parse<Ic<LowerIsai<ValueType, IndexType>, IndexType>>(                \
-        const config::pnode&, const config::registry&,                       \
-        const config::type_descriptor&)
-GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_LOWERISAI_IC_PARSE);
+#define GKO_DECLARE_IC_PARSE(ValueType, IndexType)              \
+    typename Ic<ValueType, IndexType>::parameters_type          \
+    ic_parse<Ic<ValueType, IndexType>>(const config::pnode&,    \
+                                       const config::registry&, \
+                                       const config::type_descriptor&)
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_IC_PARSE);
+
 
 }  // namespace detail
+
+
+// only instantiate the value type variants of IC, whose solver is LinOp.
+#define GKO_DECLARE_IC(ValueType, IndexType) class Ic<ValueType, IndexType>
+
+GKO_INSTANTIATE_FOR_EACH_VALUE_AND_INDEX_TYPE(GKO_DECLARE_IC);
+
+
 }  // namespace preconditioner
 }  // namespace gko
diff --git a/core/test/config/preconditioner.cpp b/core/test/config/preconditioner.cpp
index 447ec5aefc9..153eafd057f 100644
--- a/core/test/config/preconditioner.cpp
+++ b/core/test/config/preconditioner.cpp
@@ -46,9 +46,8 @@ struct PreconditionerConfigTest {
 };
 
 
-struct Ic : PreconditionerConfigTest<
-                ::gko::preconditioner::Ic<DummyIr, int>,
-                ::gko::preconditioner::Ic<gko::solver::LowerTrs<>, int>> {
+struct Ic : PreconditionerConfigTest<::gko::preconditioner::Ic<float, int>,
+                                     ::gko::preconditioner::Ic<double, int>> {
     static pnode::map_type setup_base()
     {
         return {{"type", pnode{"preconditioner::Ic"}}};
@@ -57,7 +56,6 @@ struct Ic : PreconditionerConfigTest<
     static void change_template(pnode::map_type& config_map)
     {
         config_map["value_type"] = pnode{"float32"};
-        config_map["l_solver_type"] = pnode{"solver::Ir"};
     }
 
     template <bool from_reg, typename ParamType>
@@ -66,9 +64,9 @@ struct Ic : PreconditionerConfigTest<
     {
         if (from_reg) {
             config_map["l_solver"] = pnode{"l_solver"};
-            param.with_l_solver(detail::registry_accessor::get_data<
-                                typename changed_type::l_solver_type::Factory>(
-                reg, "l_solver"));
+            param.with_l_solver(
+                detail::registry_accessor::get_data<gko::LinOpFactory>(
+                    reg, "l_solver"));
             config_map["factorization"] = pnode{"factorization"};
             param.with_factorization(
                 detail::registry_accessor::get_data<gko::LinOpFactory>(
@@ -76,7 +74,7 @@ struct Ic : PreconditionerConfigTest<
         } else {
             config_map["l_solver"] = pnode{{{"type", pnode{"solver::Ir"}},
                                             {"value_type", pnode{"float32"}}}};
-            param.with_l_solver(changed_type::l_solver_type::build().on(exec));
+            param.with_l_solver(DummyIr::build().on(exec));
             config_map["factorization"] =
                 pnode{{{"type", pnode{"solver::Ir"}},
                        {"value_type", pnode{"float32"}}}};
diff --git a/include/ginkgo/core/base/composition.hpp b/include/ginkgo/core/base/composition.hpp
index 9c16f8720aa..8e66fb720a9 100644
--- a/include/ginkgo/core/base/composition.hpp
+++ b/include/ginkgo/core/base/composition.hpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
diff --git a/include/ginkgo/core/base/type_traits.hpp b/include/ginkgo/core/base/type_traits.hpp
new file mode 100644
index 00000000000..e3977aa61b0
--- /dev/null
+++ b/include/ginkgo/core/base/type_traits.hpp
@@ -0,0 +1,75 @@
+// SPDX-FileCopyrightText: 2025 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#ifndef GKO_PUBLIC_CORE_BASE_TYPE_TRAITS_HPP_
+#define GKO_PUBLIC_CORE_BASE_TYPE_TRAITS_HPP_
+
+#include <type_traits>
+
+#include <ginkgo/core/base/lin_op.hpp>
+
+namespace gko {
+namespace detail {
+
+
+template <typename Type>
+constexpr bool is_ginkgo_linop = std::is_base_of_v<LinOp, Type>;
+
+
+// helper to get factory type of concrete type or LinOp
+template <typename Type>
+struct factory_type_impl {
+    using type = typename Type::Factory;
+};
+
+// It requires LinOp to be complete type
+template <>
+struct factory_type_impl<LinOp> {
+    using type = LinOpFactory;
+};
+
+
+template <typename Type>
+using factory_type = typename factory_type_impl<Type>::type;
+
+
+// helper for handle the transposed type of concrete type and LinOp
+template <typename Type>
+struct transposed_type_impl {
+    using type = typename Type::transposed_type;
+};
+
+// It requires LinOp to be complete type
+template <>
+struct transposed_type_impl<LinOp> {
+    using type = LinOp;
+};
+
+
+template <typename Type>
+using transposed_type = typename transposed_type_impl<Type>::type;
+
+
+// helper to get value_type of concrete type or void for LinOp
+template <typename Type, typename = void>
+struct get_value_type_impl {
+    using type = typename Type::value_type;
+};
+
+// We need to use SFINAE not conditional_t because both type needs to be
+// valid in conditional_t
+template <typename Type>
+struct get_value_type_impl<Type, std::enable_if_t<!is_ginkgo_linop<Type>>> {
+    using type = Type;
+};
+
+
+template <typename Type>
+using get_value_type = typename get_value_type_impl<Type>::type;
+
+
+}  // namespace detail
+}  // namespace gko
+
+#endif  // GKO_PUBLIC_CORE_BASE_TYPE_TRAITS_HPP_
diff --git a/include/ginkgo/core/base/utils_helper.hpp b/include/ginkgo/core/base/utils_helper.hpp
index 951ea4bbf5d..05ab04d4377 100644
--- a/include/ginkgo/core/base/utils_helper.hpp
+++ b/include/ginkgo/core/base/utils_helper.hpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
diff --git a/include/ginkgo/core/preconditioner/ic.hpp b/include/ginkgo/core/preconditioner/ic.hpp
index 9260bfbb891..6c0b4be4573 100644
--- a/include/ginkgo/core/preconditioner/ic.hpp
+++ b/include/ginkgo/core/preconditioner/ic.hpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -15,14 +15,11 @@
 #include <ginkgo/core/base/exception_helpers.hpp>
 #include <ginkgo/core/base/lin_op.hpp>
 #include <ginkgo/core/base/precision_dispatch.hpp>
+#include <ginkgo/core/base/type_traits.hpp>
 #include <ginkgo/core/config/config.hpp>
 #include <ginkgo/core/config/registry.hpp>
 #include <ginkgo/core/factorization/par_ic.hpp>
 #include <ginkgo/core/matrix/dense.hpp>
-#include <ginkgo/core/preconditioner/isai.hpp>
-#include <ginkgo/core/preconditioner/utils.hpp>
-#include <ginkgo/core/solver/gmres.hpp>
-#include <ginkgo/core/solver/ir.hpp>
 #include <ginkgo/core/solver/solver_traits.hpp>
 #include <ginkgo/core/solver/triangular.hpp>
 #include <ginkgo/core/stop/combined.hpp>
@@ -37,15 +34,10 @@ namespace detail {
 
 template <typename Type>
 constexpr bool support_ic_parse =
-    is_instantiation_of<Type, solver::LowerTrs>::value ||
-    is_instantiation_of<Type, solver::Ir>::value ||
-    is_instantiation_of<Type, solver::Gmres>::value ||
-    is_instantiation_of<Type, preconditioner::LowerIsai>::value;
+    std::is_same_v<typename Type::l_solver_type, LinOp>;
 
 
-template <
-    typename Ic,
-    std::enable_if_t<!support_ic_parse<typename Ic::l_solver_type>>* = nullptr>
+template <typename Ic, std::enable_if_t<!support_ic_parse<Ic>>* = nullptr>
 typename Ic::parameters_type ic_parse(
     const config::pnode& config, const config::registry& context,
     const config::type_descriptor& td_for_child)
@@ -54,9 +46,7 @@ typename Ic::parameters_type ic_parse(
         "preconditioner::Ic only supports limited type for parse.");
 }
 
-template <
-    typename Ic,
-    std::enable_if_t<support_ic_parse<typename Ic::l_solver_type>>* = nullptr>
+template <typename Ic, std::enable_if_t<support_ic_parse<Ic>>* = nullptr>
 typename Ic::parameters_type ic_parse(
     const config::pnode& config, const config::registry& context,
     const config::type_descriptor& td_for_child);
@@ -64,6 +54,7 @@ typename Ic::parameters_type ic_parse(
 
 }  // namespace detail
 
+
 /**
  * The Incomplete Cholesky (IC) preconditioner solves the equation $LL^H*x = b$
  * for a given lower triangular matrix L and the right hand side b (can contain
@@ -101,29 +92,37 @@ typename Ic::parameters_type ic_parse(
  *       Using it in parallel can lead to segmentation faults, wrong results
  *       and other unwanted behavior.
  *
- * @tparam LSolverType  type of the solver used for the L matrix.
- *                      Defaults to solver::LowerTrs
+ * @note The default template during parse is <ValueType, IndexType> not
+ *       <LowerTrs, IndexType>. Only the variants with ValueType are supported
+ *       in parse.
+ *
+ * @tparam LSolverTypeOrValueType  type of the solver or the value type used for
+ *                                 the L matrix. Defaults to solver::LowerTrs
  * @tparam IndexType  type of the indices when ParIc is used to generate
  *                    the L and L^H factors. Irrelevant otherwise.
  *
  * @ingroup precond
  * @ingroup LinOp
  */
-template <typename LSolverType = solver::LowerTrs<>, typename IndexType = int32>
-class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
+template <typename LSolverTypeOrValueType = solver::LowerTrs<>,
+          typename IndexType = int32>
+class Ic : public EnableLinOp<Ic<LSolverTypeOrValueType, IndexType>>,
+           public Transposable {
     friend class EnableLinOp<Ic>;
     friend class EnablePolymorphicObject<Ic, LinOp>;
 
 public:
-    static_assert(
-        std::is_same<typename LSolverType::transposed_type::transposed_type,
-                     LSolverType>::value,
-        "LSolverType::transposed_type must be symmetric");
-    using value_type = typename LSolverType::value_type;
-    using l_solver_type = LSolverType;
-    using lh_solver_type = typename LSolverType::transposed_type;
+    using l_solver_type =
+        std::conditional_t<gko::detail::is_ginkgo_linop<LSolverTypeOrValueType>,
+                           LSolverTypeOrValueType, LinOp>;
+    static_assert(std::is_same<gko::detail::transposed_type<
+                                   gko::detail::transposed_type<l_solver_type>>,
+                               l_solver_type>::value,
+                  "l_solver_type::transposed_type must be symmetric");
+    using value_type = gko::detail::get_value_type<LSolverTypeOrValueType>;
+    using lh_solver_type = gko::detail::transposed_type<l_solver_type>;
     using index_type = IndexType;
-    using transposed_type = Ic<LSolverType, IndexType>;
+    using transposed_type = Ic<LSolverTypeOrValueType, IndexType>;
 
     class Factory;
 
@@ -132,7 +131,7 @@ class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
         /**
          * Factory for the L solver
          */
-        std::shared_ptr<const typename l_solver_type::Factory>
+        std::shared_ptr<const gko::detail::factory_type<l_solver_type>>
             l_solver_factory{};
 
         /**
@@ -142,14 +141,21 @@ class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
 
         GKO_DEPRECATED("use with_l_solver instead")
         parameters_type& with_l_solver_factory(
-            deferred_factory_parameter<const typename l_solver_type::Factory>
+            deferred_factory_parameter<
+                const gko::detail::factory_type<l_solver_type>>
                 solver)
         {
             return with_l_solver(std::move(solver));
         }
 
+        /**
+         * When LSolverTypeOrValueType is a concrete solver type, this only
+         * accepts the factory from the same concrete solver type. When
+         * LSolverTypeOrValueType is a value type, it accepts any LinOpFactory.
+         */
         parameters_type& with_l_solver(
-            deferred_factory_parameter<const typename l_solver_type::Factory>
+            deferred_factory_parameter<
+                const gko::detail::factory_type<l_solver_type>>
                 solver)
         {
             this->l_solver_generator = std::move(solver);
@@ -185,7 +191,8 @@ class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
         }
 
     private:
-        deferred_factory_parameter<const typename l_solver_type::Factory>
+        deferred_factory_parameter<
+            const gko::detail::factory_type<l_solver_type>>
             l_solver_generator;
 
         deferred_factory_parameter<const LinOpFactory> factorization_generator;
@@ -204,17 +211,20 @@ class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
      * @param context  the registry
      * @param td_for_child  the type descriptor for children configs. The
      *                      default uses the value/index type of this class.
+     *                      When l_solver_type uses LinOp not concrete type, it
+     *                      will use the default_precision in ginkgo.
      *
      * @return parameters
      *
-     * @note only support the following for l_solver:
-     *       Ir, Gmres, LowerTrs, and LowerIsai
+     * @note only support the following when using <ValueType, IndexType> not
+     *       <LSolverType, IndexType> variants
      */
     static parameters_type parse(
         const config::pnode& config, const config::registry& context,
         const config::type_descriptor& td_for_child =
             config::make_type_descriptor<value_type, index_type>())
     {
+        // parse is not templated, so we can only use SFINAE later
         return detail::ic_parse<Ic>(config, context, td_for_child);
     }
 
@@ -244,11 +254,11 @@ class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
             new transposed_type{this->get_executor()}};
         transposed->set_size(gko::transpose(this->get_size()));
         transposed->l_solver_ =
-            share(as<typename lh_solver_type::transposed_type>(
-                this->get_lh_solver()->transpose()));
+            share(as<gko::detail::transposed_type<lh_solver_type>>(
+                as<Transposable>(this->get_lh_solver())->transpose()));
         transposed->lh_solver_ =
-            share(as<typename l_solver_type::transposed_type>(
-                this->get_l_solver()->transpose()));
+            share(as<gko::detail::transposed_type<l_solver_type>>(
+                as<Transposable>(this->get_l_solver())->transpose()));
 
         return std::move(transposed);
     }
@@ -259,11 +269,11 @@ class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
             new transposed_type{this->get_executor()}};
         transposed->set_size(gko::transpose(this->get_size()));
         transposed->l_solver_ =
-            share(as<typename lh_solver_type::transposed_type>(
-                this->get_lh_solver()->conj_transpose()));
+            share(as<gko::detail::transposed_type<lh_solver_type>>(
+                as<Transposable>(this->get_lh_solver())->conj_transpose()));
         transposed->lh_solver_ =
-            share(as<typename l_solver_type::transposed_type>(
-                this->get_l_solver()->conj_transpose()));
+            share(as<gko::detail::transposed_type<l_solver_type>>(
+                as<Transposable>(this->get_l_solver())->conj_transpose()));
 
         return std::move(transposed);
     }
@@ -368,6 +378,7 @@ class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
         // build factorization if we weren't passed a composition
         if (!comp) {
             auto exec = lin_op->get_executor();
+
             if (!parameters_.factorization_factory) {
                 parameters_.factorization_factory =
                     factorization::ParIc<value_type, index_type>::build()
@@ -377,11 +388,7 @@ class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
             auto fact = std::shared_ptr<const LinOp>(
                 parameters_.factorization_factory->generate(lin_op));
             // ensure that the result is a composition
-            comp =
-                std::dynamic_pointer_cast<const Composition<value_type>>(fact);
-            if (!comp) {
-                GKO_NOT_SUPPORTED(comp);
-            }
+            comp = gko::as<const Composition<value_type>>(fact);
         }
         // comp must contain one or two factors
         if (comp->get_operators().size() > 2 || comp->get_operators().empty()) {
@@ -394,19 +401,28 @@ class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
 
         // If no factories are provided, generate default ones
         if (!parameters_.l_solver_factory) {
-            l_solver_ = generate_default_solver<l_solver_type>(exec, l_factor);
-            // If comp contains both factors: use the transposed factor to avoid
-            // transposing twice
-            if (comp->get_operators().size() == 2) {
-                auto lh_factor = comp->get_operators()[1];
-                GKO_ASSERT_EQUAL_DIMENSIONS(l_factor, lh_factor);
-                lh_solver_ = as<lh_solver_type>(l_solver_->conj_transpose());
+            if constexpr (std::is_same_v<l_solver_type, LinOp>) {
+                // linop can not have a default factory generation
+                GKO_NOT_IMPLEMENTED;
             } else {
-                lh_solver_ = as<lh_solver_type>(l_solver_->conj_transpose());
+                l_solver_ =
+                    generate_default_solver<l_solver_type>(exec, l_factor);
+                // If comp contains both factors: use the transposed factor to
+                // avoid transposing twice
+                if (comp->get_operators().size() == 2) {
+                    auto lh_factor = comp->get_operators()[1];
+                    GKO_ASSERT_EQUAL_DIMENSIONS(l_factor, lh_factor);
+                    lh_solver_ = as<lh_solver_type>(
+                        as<Transposable>(l_solver_)->conj_transpose());
+                } else {
+                    lh_solver_ = as<lh_solver_type>(
+                        as<Transposable>(l_solver_)->conj_transpose());
+                }
             }
         } else {
             l_solver_ = parameters_.l_solver_factory->generate(l_factor);
-            lh_solver_ = as<lh_solver_type>(l_solver_->conj_transpose());
+            lh_solver_ = as<lh_solver_type>(
+                as<Transposable>(l_solver_)->conj_transpose());
         }
     }
 
@@ -427,7 +443,6 @@ class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
         cache_.intermediate->copy_from(b);
     }
 
-
     /**
      * Generates a default solver of type SolverType.
      *
@@ -436,7 +451,8 @@ class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
      * preconditioner.
      */
     template <typename SolverType>
-    static std::enable_if_t<solver::has_with_criteria<SolverType>::value,
+    static std::enable_if_t<solver::has_with_criteria<SolverType>::value &&
+                                !std::is_same_v<SolverType, LinOp>,
                             std::unique_ptr<SolverType>>
     generate_default_solver(const std::shared_ptr<const Executor>& exec,
                             const std::shared_ptr<const LinOp>& mtx)
@@ -458,7 +474,8 @@ class Ic : public EnableLinOp<Ic<LSolverType, IndexType>>, public Transposable {
      * @copydoc generate_default_solver
      */
     template <typename SolverType>
-    static std::enable_if_t<!solver::has_with_criteria<SolverType>::value,
+    static std::enable_if_t<!solver::has_with_criteria<SolverType>::value &&
+                                !std::is_same_v<SolverType, LinOp>,
                             std::unique_ptr<SolverType>>
     generate_default_solver(const std::shared_ptr<const Executor>& exec,
                             const std::shared_ptr<const LinOp>& mtx)
diff --git a/reference/test/preconditioner/ic.cpp b/reference/test/preconditioner/ic.cpp
index 16ffc8d7b3c..f79a1f14db9 100644
--- a/reference/test/preconditioner/ic.cpp
+++ b/reference/test/preconditioner/ic.cpp
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -30,11 +30,11 @@ class Ic : public ::testing::Test {
         typename std::tuple_element<1, decltype(ValueIndexType())>::type;
     using Mtx = gko::matrix::Csr<value_type, index_type>;
     using Vec = gko::matrix::Dense<value_type>;
-    using ic_prec_type =
-        gko::preconditioner::Ic<gko::solver::LowerTrs<value_type, index_type>,
-                                index_type>;
+    using lower_trs = gko::solver::LowerTrs<value_type, index_type>;
+    using ic_prec_type = gko::preconditioner::Ic<lower_trs, index_type>;
     using ic_isai_prec_type = gko::preconditioner::Ic<
         gko::preconditioner::LowerIsai<value_type, index_type>, index_type>;
+    using ic_linop_prec_type = gko::preconditioner::Ic<value_type, index_type>;
     using Composition = gko::Composition<value_type>;
 
     Ic()
@@ -51,6 +51,13 @@ class Ic : public ::testing::Test {
           l_lh_composition(Composition::create(l_factor, lh_factor)),
           ic_pre_factory(ic_prec_type::build().on(exec)),
           ic_isai_pre_factory(ic_isai_prec_type::build().on(exec)),
+          ic_linop_pre_factory(
+              ic_linop_prec_type::build()
+                  .with_l_solver(lower_trs::build())
+                  .with_factorization(
+                      gko::factorization::ParIc<value_type, index_type>::build()
+                          .with_both_factors(false))
+                  .on(exec)),
           tol{r<value_type>::value}
     {}
 
@@ -64,6 +71,7 @@ class Ic : public ::testing::Test {
     std::shared_ptr<Composition> l_lh_composition;
     std::shared_ptr<typename ic_prec_type::Factory> ic_pre_factory;
     std::shared_ptr<typename ic_isai_prec_type::Factory> ic_isai_pre_factory;
+    std::shared_ptr<typename ic_linop_prec_type::Factory> ic_linop_pre_factory;
     gko::remove_complex<value_type> tol;
 };
 
@@ -126,6 +134,72 @@ TYPED_TEST(Ic, BuildsIsaiFromMatrix)
 }
 
 
+TYPED_TEST(Ic, BuildsTwoFactorCompositionWithLinOp)
+{
+    using lower_trs = typename TestFixture::lower_trs;
+
+    auto precond = this->ic_linop_pre_factory->generate(this->l_lh_composition);
+
+    GKO_ASSERT_MTX_NEAR(
+        gko::as<lower_trs>(precond->get_l_solver())->get_system_matrix(),
+        this->l_factor, this->tol);
+    GKO_ASSERT_MTX_NEAR(
+        gko::as<typename lower_trs::transposed_type>(precond->get_lh_solver())
+            ->get_system_matrix(),
+        this->lh_factor, this->tol);
+}
+
+
+TYPED_TEST(Ic, BuildsOneFactorCompositionWithLinOp)
+{
+    using lower_trs = typename TestFixture::lower_trs;
+
+    auto precond = this->ic_linop_pre_factory->generate(this->l_composition);
+
+    GKO_ASSERT_MTX_NEAR(
+        gko::as<lower_trs>(precond->get_l_solver())->get_system_matrix(),
+        this->l_factor, this->tol);
+    GKO_ASSERT_MTX_NEAR(
+        gko::as<typename lower_trs::transposed_type>(precond->get_lh_solver())
+            ->get_system_matrix(),
+        this->lh_factor, this->tol);
+}
+
+
+TYPED_TEST(Ic, BuildsSymmetricTwoFactorWithLinOp)
+{
+    using lower_trs = typename TestFixture::lower_trs;
+
+    auto precond = this->ic_linop_pre_factory->generate(this->l_lh_composition);
+
+    // the first factor should be identical, the second not as it was transposed
+    ASSERT_EQ(
+        gko::as<lower_trs>(precond->get_l_solver())->get_system_matrix().get(),
+        this->l_factor.get());
+    ASSERT_NE(
+        gko::as<typename lower_trs::transposed_type>(precond->get_lh_solver())
+            ->get_system_matrix()
+            .get(),
+        this->lh_factor.get());
+}
+
+
+TYPED_TEST(Ic, BuildsFromMatrixWithLinOp)
+{
+    using lower_trs = typename TestFixture::lower_trs;
+
+    auto precond = this->ic_linop_pre_factory->generate(this->mtx);
+
+    GKO_ASSERT_MTX_NEAR(
+        gko::as<lower_trs>(precond->get_l_solver())->get_system_matrix(),
+        this->l_factor, this->tol);
+    GKO_ASSERT_MTX_NEAR(
+        gko::as<typename lower_trs::transposed_type>(precond->get_lh_solver())
+            ->get_system_matrix(),
+        this->lh_factor, this->tol);
+}
+
+
 TYPED_TEST(Ic, ThrowOnWrongCompositionInput)
 {
     using Composition = typename TestFixture::Composition;
@@ -226,6 +300,52 @@ TYPED_TEST(Ic, CanBeConjTransposed)
 }
 
 
+TYPED_TEST(Ic, CanBeTransposedWithLinOp)
+{
+    using Ic = typename TestFixture::ic_linop_prec_type;
+    using Mtx = typename TestFixture::Mtx;
+    using lower_trs = typename TestFixture::lower_trs;
+    using upper_trs = typename lower_trs::transposed_type;
+    auto ic = this->ic_linop_pre_factory->generate(this->l_lh_composition);
+    auto l_ref = gko::as<Mtx>(
+        gko::as<lower_trs>(ic->get_l_solver())->get_system_matrix());
+    auto lh_ref = gko::as<Mtx>(
+        gko::as<upper_trs>(ic->get_lh_solver())->get_system_matrix());
+
+    auto transp = gko::as<Ic>(ic->transpose());
+
+    auto l_transp = gko::as<Mtx>(
+        gko::as<lower_trs>(transp->get_l_solver())->get_system_matrix());
+    auto lh_transp = gko::as<Mtx>(
+        gko::as<upper_trs>(transp->get_lh_solver())->get_system_matrix());
+    GKO_ASSERT_MTX_NEAR(l_transp, l_ref, 0);
+    GKO_ASSERT_MTX_NEAR(lh_transp, lh_ref, 0);
+}
+
+
+TYPED_TEST(Ic, CanBeConjTransposedWithLinOp)
+{
+    using Ic = typename TestFixture::ic_linop_prec_type;
+    using Mtx = typename TestFixture::Mtx;
+    using lower_trs = typename TestFixture::lower_trs;
+    using upper_trs = typename lower_trs::transposed_type;
+    auto ic = this->ic_linop_pre_factory->generate(this->l_lh_composition);
+    auto l_ref = gko::as<Mtx>(
+        gko::as<lower_trs>(ic->get_l_solver())->get_system_matrix());
+    auto lh_ref = gko::as<Mtx>(
+        gko::as<upper_trs>(ic->get_lh_solver())->get_system_matrix());
+
+    auto transp = gko::as<Ic>(ic->conj_transpose());
+
+    auto l_transp = gko::as<Mtx>(
+        gko::as<lower_trs>(transp->get_l_solver())->get_system_matrix());
+    auto lh_transp = gko::as<Mtx>(
+        gko::as<upper_trs>(transp->get_lh_solver())->get_system_matrix());
+    GKO_ASSERT_MTX_NEAR(l_transp, l_ref, 0);
+    GKO_ASSERT_MTX_NEAR(lh_transp, lh_ref, 0);
+}
+
+
 TYPED_TEST(Ic, SolvesSingleRhs)
 {
     using ic_prec_type = typename TestFixture::ic_prec_type;
@@ -392,4 +512,20 @@ TYPED_TEST(Ic, SolvesMultipleRhs)
 }
 
 
+TYPED_TEST(Ic, SolvesMultipleRhsWithLinop)
+{
+    using Vec = typename TestFixture::Vec;
+    const auto b = gko::initialize<Vec>(
+        {{1.0, 2.0, 3.0}, {3.0, 6.0, 9.0}, {6.0, 12.0, 18.0}}, this->exec);
+    auto x = Vec::create(this->exec, gko::dim<2>{3, 3});
+    auto preconditioner = this->ic_linop_pre_factory->generate(this->mtx);
+
+    preconditioner->apply(b, x);
+
+    GKO_ASSERT_MTX_NEAR(
+        x, l({{3.0, 6.0, 9.0}, {-2.0, -4.0, -6.0}, {4.0, 8.0, 12.0}}),
+        this->tol);
+}
+
+
 }  // namespace