diff --git a/framework/math/linear_solver/linear_eigen_solver.h b/framework/math/linear_solver/linear_eigen_solver.h
new file mode 100644
index 0000000000..d23c8a3bf6
--- /dev/null
+++ b/framework/math/linear_solver/linear_eigen_solver.h
@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: 2025 The OpenSn Authors <https://open-sn.github.io/opensn/>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "framework/math/linear_solver/linear_solver.h"
+#include "framework/math/linear_solver/linear_solver_context.h"
+
+namespace opensn
+{
+
+class LinearEigenSolver : public LinearSolver
+{
+public:
+  enum class IterativeMethod : int
+  {
+    POWER
+  };
+
+  LinearEigenSolver(IterativeMethod method, std::shared_ptr<LinearEigenContext> ctx)
+    : LinearSolver(ctx), method_(method)
+  {
+  }
+
+  std::string GetIterativeMethodName()
+  {
+    switch (method_)
+    {
+      case IterativeMethod::POWER:
+        return "POWER ITERATION";
+      default:
+        return "UNKNOWN ITERATIVE METHOD";
+    }
+  }
+
+protected:
+  IterativeMethod method_;
+};
+
+} // namespace opensn
diff --git a/framework/math/linear_solver/linear_solver.cc b/framework/math/linear_solver/linear_solver.cc
deleted file mode 100644
index d813f17649..0000000000
--- a/framework/math/linear_solver/linear_solver.cc
+++ /dev/null
@@ -1,29 +0,0 @@
-// SPDX-FileCopyrightText: 2024 The OpenSn Authors <https://open-sn.github.io/opensn/>
-// SPDX-License-Identifier: MIT
-
-#include "framework/math/linear_solver/linear_solver.h"
-
-namespace opensn
-{
-
-std::string
-LinearSolver::IterativeMethodName(LinearSolver::IterativeMethod iterative_method)
-{
-  switch (iterative_method)
-  {
-    case IterativeMethod::NONE:
-      return "NONE";
-    case IterativeMethod::CLASSIC_RICHARDSON:
-      return "CLASSIC_RICHARDSON";
-    case IterativeMethod::PETSC_RICHARDSON:
-      return "PETSC_RICHARDSON";
-    case IterativeMethod::PETSC_GMRES:
-      return "PETSC_GMRES";
-    case IterativeMethod::PETSC_BICGSTAB:
-      return "PETSC_BICGSTAB";
-    default:
-      throw std::runtime_error("Unrecognized iterative method.");
-  }
-}
-
-} // namespace opensn
diff --git a/framework/math/linear_solver/linear_solver.h b/framework/math/linear_solver/linear_solver.h
index b4a8c82b7b..486347443b 100644
--- a/framework/math/linear_solver/linear_solver.h
+++ b/framework/math/linear_solver/linear_solver.h
@@ -14,23 +14,12 @@ struct LinearSolverContext;
 class LinearSolver
 {
 public:
-  enum class IterativeMethod : int
-  {
-    NONE = 0,
-    CLASSIC_RICHARDSON = 1, ///< Classic Richardson (source iteration)
-    PETSC_RICHARDSON = 3,   ///< PETSc Richardson iteration
-    PETSC_GMRES = 2,        ///< PETSc GMRES iterative algorithm
-    PETSC_BICGSTAB = 4,     ///< PETSc BiCGStab iterative algorithm
-  };
-
-  LinearSolver(IterativeMethod iterative_method, std::shared_ptr<LinearSolverContext> context_ptr)
-    : iterative_method_(iterative_method), context_ptr_(context_ptr)
+  explicit LinearSolver(std::shared_ptr<LinearSolverContext> context_ptr)
+    : context_ptr_(context_ptr)
   {
   }
 
-  virtual ~LinearSolver() {}
-
-  std::shared_ptr<LinearSolverContext> GetContext() { return context_ptr_; }
+  virtual ~LinearSolver() = default;
 
   /// Set up the linaer solver
   virtual void Setup() {}
@@ -38,12 +27,10 @@ class LinearSolver
   /// Solve the system
   virtual void Solve() = 0;
 
+  std::shared_ptr<LinearSolverContext> GetContext() { return context_ptr_; }
+
 protected:
-  const IterativeMethod iterative_method_;
   std::shared_ptr<LinearSolverContext> context_ptr_;
-
-public:
-  static std::string IterativeMethodName(IterativeMethod iterative_method);
 };
 
 } // namespace opensn
diff --git a/framework/math/linear_solver/linear_solver_context.h b/framework/math/linear_solver/linear_solver_context.h
index baf475f150..2c47b8435f 100644
--- a/framework/math/linear_solver/linear_solver_context.h
+++ b/framework/math/linear_solver/linear_solver_context.h
@@ -17,15 +17,23 @@ enum class ResidualScaleType
 };
 
 struct LinearSolverContext
+{
+  virtual int MatrixAction(Mat& matrix, Vec& vector, Vec& action) { return 0; }
+
+  virtual ~LinearSolverContext() = default;
+};
+
+struct LinearSystemContext : public LinearSolverContext
 {
   double rhs_norm = 0.0;
   double rhs_preconditioned_norm = 0.0;
   double custom_residual_scale = 1.0;
   ResidualScaleType residual_scale_type = ResidualScaleType::NONE;
+};
 
-  virtual int MatrixAction(Mat& matrix, Vec& vector, Vec& action) { return 0; }
-
-  virtual ~LinearSolverContext() = default;
+struct LinearEigenContext : public LinearSolverContext
+{
+  double eigenvalue = 0.0;
 };
 
 } // namespace opensn
diff --git a/framework/math/linear_solver/linear_system_solver.h b/framework/math/linear_solver/linear_system_solver.h
new file mode 100644
index 0000000000..e7f50d3e7d
--- /dev/null
+++ b/framework/math/linear_solver/linear_system_solver.h
@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: 2025 The OpenSn Authors <https://open-sn.github.io/opensn/>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include "framework/math/linear_solver/linear_solver.h"
+#include "framework/math/linear_solver/linear_solver_context.h"
+
+namespace opensn
+{
+
+class LinearSystemSolver : public LinearSolver
+{
+public:
+  enum class IterativeMethod : int
+  {
+    NONE,
+    CLASSIC_RICHARDSON,
+    PETSC_RICHARDSON,
+    PETSC_GMRES,
+    PETSC_BICGSTAB
+  };
+
+  LinearSystemSolver(IterativeMethod method, std::shared_ptr<LinearSystemContext> ctx)
+    : LinearSolver(ctx), method_(method)
+  {
+  }
+
+  std::string GetIterativeMethodName()
+  {
+    switch (method_)
+    {
+      case IterativeMethod::NONE:
+        return "NONE";
+      case IterativeMethod::CLASSIC_RICHARDSON:
+        return "CLASSIC_RICHARDSON";
+      case IterativeMethod::PETSC_RICHARDSON:
+        return "PETSC_RICHARDSON";
+      case IterativeMethod::PETSC_GMRES:
+        return "PETSC_GMRES";
+      case IterativeMethod::PETSC_BICGSTAB:
+        return "PETSC_BICGSTAB";
+      default:
+        return "UNKNOWN ITERATIVE METHOD";
+    }
+  }
+
+protected:
+  IterativeMethod method_;
+};
+
+} // namespace opensn
diff --git a/framework/math/linear_solver/petsc_linear_solver.cc b/framework/math/linear_solver/petsc_linear_system_solver.cc
similarity index 79%
rename from framework/math/linear_solver/petsc_linear_solver.cc
rename to framework/math/linear_solver/petsc_linear_system_solver.cc
index eac541a464..07436b606c 100644
--- a/framework/math/linear_solver/petsc_linear_solver.cc
+++ b/framework/math/linear_solver/petsc_linear_system_solver.cc
@@ -1,15 +1,15 @@
 // SPDX-FileCopyrightText: 2024 The OpenSn Authors <https://open-sn.github.io/opensn/>
 // SPDX-License-Identifier: MIT
 
-#include "framework/math/linear_solver/petsc_linear_solver.h"
+#include "framework/math/linear_solver/petsc_linear_system_solver.h"
 #include "framework/runtime.h"
 
 namespace opensn
 {
 
-PETScLinearSolver::PETScLinearSolver(IterativeMethod iterative_method,
-                                     std::shared_ptr<LinearSolverContext> context_ptr)
-  : LinearSolver(iterative_method, context_ptr),
+PETScLinearSolver::PETScLinearSolver(IterativeMethod method,
+                                     std::shared_ptr<LinearSystemContext> context_ptr)
+  : LinearSystemSolver(method, context_ptr),
     A_(nullptr),
     b_(nullptr),
     x_(nullptr),
@@ -82,34 +82,25 @@ PETScLinearSolver::Setup()
     return;
 
   PreSetupCallback();
-
   KSPCreate(opensn::mpi_comm, &ksp_);
-
-  const auto petsc_iterative_method = PETScIterativeMethodName(iterative_method_);
+  const auto petsc_iterative_method = PETScIterativeMethodName();
   KSPSetType(ksp_, petsc_iterative_method.c_str());
-
   ApplyToleranceOptions();
-
-  if (iterative_method_ == IterativeMethod::PETSC_GMRES)
+  if (method_ == IterativeMethod::PETSC_GMRES)
   {
     KSPGMRESSetRestart(ksp_, tolerance_options.gmres_restart_interval);
     KSPGMRESSetBreakdownTolerance(ksp_, tolerance_options.gmres_breakdown_tolerance);
   }
-
   KSPSetInitialGuessNonzero(ksp_, PETSC_FALSE);
-
   SetOptions();
-
   SetSolverContext();
   SetConvergenceTest();
   SetMonitor();
-
   SetSystemSize();
   SetSystem();
-
   SetPreconditioner();
-
   PostSetupCallback();
+
   system_set_ = true;
 }
 
@@ -135,9 +126,9 @@ PETScLinearSolver::Solve()
 }
 
 std::string
-PETScLinearSolver::PETScIterativeMethodName(opensn::LinearSolver::IterativeMethod iterative_method)
+PETScLinearSolver::PETScIterativeMethodName()
 {
-  switch (iterative_method)
+  switch (method_)
   {
     case IterativeMethod::NONE:
       return "preonly";
@@ -148,14 +139,14 @@ PETScLinearSolver::PETScIterativeMethodName(opensn::LinearSolver::IterativeMetho
     case IterativeMethod::PETSC_BICGSTAB:
       return "bcgs";
     default:
-      throw std::runtime_error("Cannot get a PETSc option name for a non-PETSc iterative method.");
+      throw std::runtime_error("Unsupported PETSc iterative method.");
   }
 }
 
 int
 PETScLinearSolver::LinearSolverMatrixAction(Mat matrix, Vec vector, Vec action)
 {
-  LinearSolverContext* context;
+  LinearSystemContext* context;
   MatShellGetContext(matrix, &context);
 
   context->MatrixAction(matrix, vector, action);
diff --git a/framework/math/linear_solver/petsc_linear_solver.h b/framework/math/linear_solver/petsc_linear_system_solver.h
similarity index 85%
rename from framework/math/linear_solver/petsc_linear_solver.h
rename to framework/math/linear_solver/petsc_linear_system_solver.h
index 9c2c2f9258..27b28374a6 100644
--- a/framework/math/linear_solver/petsc_linear_solver.h
+++ b/framework/math/linear_solver/petsc_linear_system_solver.h
@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include "framework/math/linear_solver/linear_solver.h"
+#include "framework/math/linear_solver/linear_system_solver.h"
 #include "framework/math/linear_solver/linear_solver_context.h"
 #include <string>
 #include <utility>
@@ -13,7 +13,7 @@
 namespace opensn
 {
 
-class PETScLinearSolver : public LinearSolver
+class PETScLinearSolver : public LinearSystemSolver
 {
 public:
   struct ToleranceOptions
@@ -26,8 +26,7 @@ class PETScLinearSolver : public LinearSolver
     double gmres_breakdown_tolerance = 1.0e6;
   } tolerance_options;
 
-  PETScLinearSolver(IterativeMethod iterative_method,
-                    std::shared_ptr<LinearSolverContext> context_ptr);
+  PETScLinearSolver(IterativeMethod method, std::shared_ptr<LinearSystemContext> context_ptr);
 
   virtual ~PETScLinearSolver();
 
@@ -72,12 +71,10 @@ class PETScLinearSolver : public LinearSolver
 private:
   bool system_set_;
   bool suppress_kspsolve_;
+  std::string PETScIterativeMethodName();
 
 protected:
   static int LinearSolverMatrixAction(Mat matrix, Vec vector, Vec action);
-
-private:
-  static std::string PETScIterativeMethodName(IterativeMethod iterative_method);
 };
 
 } // namespace opensn
diff --git a/modules/linear_boltzmann_solvers/discrete_ordinates_problem/discrete_ordinates_problem.cc b/modules/linear_boltzmann_solvers/discrete_ordinates_problem/discrete_ordinates_problem.cc
index 56969322ae..ae9901d5e4 100644
--- a/modules/linear_boltzmann_solvers/discrete_ordinates_problem/discrete_ordinates_problem.cc
+++ b/modules/linear_boltzmann_solvers/discrete_ordinates_problem/discrete_ordinates_problem.cc
@@ -311,8 +311,11 @@ DiscreteOrdinatesProblem::InitializeWGSSolvers()
       options_.verbose_inner_iterations,
       sweep_chunk);
 
-    if (groupset.iterative_method == LinearSolver::IterativeMethod::CLASSIC_RICHARDSON)
-      wgs_solvers_.push_back(std::make_shared<ClassicRichardson>(sweep_wgs_context_ptr));
+    if (groupset.iterative_method == LinearSystemSolver::IterativeMethod::CLASSIC_RICHARDSON)
+    {
+      wgs_solvers_.push_back(std::make_shared<ClassicRichardson>(
+        sweep_wgs_context_ptr, options_.verbose_inner_iterations));
+    }
     else
       wgs_solvers_.push_back(std::make_shared<WGSLinearSolver>(sweep_wgs_context_ptr));
   }
diff --git a/modules/linear_boltzmann_solvers/discrete_ordinates_problem/iterative_methods/sweep_wgs_context.cc b/modules/linear_boltzmann_solvers/discrete_ordinates_problem/iterative_methods/sweep_wgs_context.cc
index 199e351faa..a17cc96b44 100644
--- a/modules/linear_boltzmann_solvers/discrete_ordinates_problem/iterative_methods/sweep_wgs_context.cc
+++ b/modules/linear_boltzmann_solvers/discrete_ordinates_problem/iterative_methods/sweep_wgs_context.cc
@@ -3,12 +3,12 @@
 
 #include "modules/linear_boltzmann_solvers/discrete_ordinates_problem/iterative_methods/sweep_wgs_context.h"
 #include "modules/linear_boltzmann_solvers/discrete_ordinates_problem/discrete_ordinates_problem.h"
-#include "modules/linear_boltzmann_solvers/lbs_problem/lbs_vecops.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/preconditioning/lbs_shell_operations.h"
-#include "framework/runtime.h"
+#include "modules/linear_boltzmann_solvers/lbs_problem/lbs_vecops.h"
 #include "framework/logging/log.h"
-#include <petscksp.h>
+#include "framework/runtime.h"
 #include "caliper/cali.h"
+#include <petscksp.h>
 #include <iomanip>
 
 namespace opensn
@@ -33,20 +33,6 @@ SweepWGSContext::SweepWGSContext(DiscreteOrdinatesProblem& do_problem,
 {
 }
 
-void
-SweepWGSContext::PreSetupCallback()
-{
-  CALI_CXX_MARK_SCOPE("SweepWGSContext::PreSetupCallback");
-
-  if (log_info)
-    log.Log() << "\n\n"
-              << "********** Solving groupset " << groupset.id << " with "
-              << LinearSolver::IterativeMethodName(groupset.iterative_method) << ".\n\n"
-              << "Quadrature number of angles: " << groupset.quadrature->abscissae.size() << "\n"
-              << "Groups " << groupset.groups.front().id << " " << groupset.groups.back().id
-              << "\n\n";
-}
-
 void
 SweepWGSContext::SetPreconditioner(KSP& solver)
 {
@@ -130,9 +116,9 @@ SweepWGSContext::PostSolveCallback()
   // Perform final sweep with converged phi and delayed psi dofs. This step is necessary for
   // Krylov methods to recover the actual solution (this includes all of the PETSc methods
   // currently used in OpenSn).
-  if (groupset.iterative_method == LinearSolver::IterativeMethod::PETSC_GMRES or
-      groupset.iterative_method == LinearSolver::IterativeMethod::PETSC_BICGSTAB or
-      (groupset.iterative_method == LinearSolver::IterativeMethod::PETSC_RICHARDSON and
+  if (groupset.iterative_method == LinearSystemSolver::IterativeMethod::PETSC_GMRES or
+      groupset.iterative_method == LinearSystemSolver::IterativeMethod::PETSC_BICGSTAB or
+      (groupset.iterative_method == LinearSystemSolver::IterativeMethod::PETSC_RICHARDSON and
        groupset.max_iterations > 1))
   {
     const auto scope = lhs_src_scope | rhs_src_scope;
diff --git a/modules/linear_boltzmann_solvers/discrete_ordinates_problem/iterative_methods/sweep_wgs_context.h b/modules/linear_boltzmann_solvers/discrete_ordinates_problem/iterative_methods/sweep_wgs_context.h
index 69689aa95d..34d0186bf6 100644
--- a/modules/linear_boltzmann_solvers/discrete_ordinates_problem/iterative_methods/sweep_wgs_context.h
+++ b/modules/linear_boltzmann_solvers/discrete_ordinates_problem/iterative_methods/sweep_wgs_context.h
@@ -21,8 +21,6 @@ struct SweepWGSContext : public WGSContext
                   bool log_info,
                   std::shared_ptr<SweepChunk> sweep_chunk);
 
-  void PreSetupCallback() override;
-
   void SetPreconditioner(KSP& solver) override;
 
   std::pair<int64_t, int64_t> GetSystemSize() override;
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/groupset/lbs_groupset.cc b/modules/linear_boltzmann_solvers/lbs_problem/groupset/lbs_groupset.cc
index 6fdafc21f9..535c4bc3fd 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/groupset/lbs_groupset.cc
+++ b/modules/linear_boltzmann_solvers/lbs_problem/groupset/lbs_groupset.cc
@@ -96,7 +96,7 @@ LBSGroupset::Init(int aid)
   quadrature = nullptr;
   angle_agg = nullptr;
   master_num_ang_subsets = 1;
-  iterative_method = LinearSolver::IterativeMethod::PETSC_RICHARDSON;
+  iterative_method = LinearSystemSolver::IterativeMethod::PETSC_RICHARDSON;
   angleagg_method = AngleAggregationType::POLAR;
   residual_tolerance = 1.0e-6;
   max_iterations = 200;
@@ -172,13 +172,13 @@ LBSGroupset::LBSGroupset(const InputParameters& params, const int id, const LBSP
   // Inner solver
   const auto inner_linear_method = params.GetParamValue<std::string>("inner_linear_method");
   if (inner_linear_method == "classic_richardson")
-    iterative_method = LinearSolver::IterativeMethod::CLASSIC_RICHARDSON;
+    iterative_method = LinearSystemSolver::IterativeMethod::CLASSIC_RICHARDSON;
   else if (inner_linear_method == "petsc_richardson")
-    iterative_method = LinearSolver::IterativeMethod::PETSC_RICHARDSON;
+    iterative_method = LinearSystemSolver::IterativeMethod::PETSC_RICHARDSON;
   else if (inner_linear_method == "petsc_gmres")
-    iterative_method = LinearSolver::IterativeMethod::PETSC_GMRES;
+    iterative_method = LinearSystemSolver::IterativeMethod::PETSC_GMRES;
   else if (inner_linear_method == "petsc_bicgstab")
-    iterative_method = LinearSolver::IterativeMethod::PETSC_BICGSTAB;
+    iterative_method = LinearSystemSolver::IterativeMethod::PETSC_BICGSTAB;
 
   gmres_restart_intvl = params.GetParamValue<int>("gmres_restart_interval");
   allow_cycles = params.GetParamValue<bool>("allow_cycles");
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/groupset/lbs_groupset.h b/modules/linear_boltzmann_solvers/lbs_problem/groupset/lbs_groupset.h
index 47a7b71099..45b6d74480 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/groupset/lbs_groupset.h
+++ b/modules/linear_boltzmann_solvers/lbs_problem/groupset/lbs_groupset.h
@@ -9,7 +9,7 @@
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_structs.h"
 #include "framework/math/quadratures/angular/legendre_poly/legendrepoly.h"
 #include "framework/math/quadratures/angular/angular_quadrature.h"
-#include "framework/math/linear_solver/linear_solver.h"
+#include "framework/math/linear_solver/linear_system_solver.h"
 #include "framework/math/unknown_manager/unknown_manager.h"
 #include "framework/utils/utils.h"
 
@@ -32,7 +32,7 @@ class LBSGroupset
 
   int master_num_ang_subsets;
 
-  LinearSolver::IterativeMethod iterative_method;
+  LinearSystemSolver::IterativeMethod iterative_method;
   AngleAggregationType angleagg_method;
   double residual_tolerance;
   int max_iterations;
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_solver.cc b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_linear_solver.cc
similarity index 95%
rename from modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_solver.cc
rename to modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_linear_solver.cc
index f4a4c5cea5..4494fa2c94 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_solver.cc
+++ b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_linear_solver.cc
@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: 2024 The OpenSn Authors <https://open-sn.github.io/opensn/>
 // SPDX-License-Identifier: MIT
 
-#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_solver.h"
+#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_linear_solver.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/convergence.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_problem.h"
 #include "framework/mesh/mesh_continuum/mesh_continuum.h"
@@ -14,9 +14,9 @@ namespace opensn
 {
 
 void
-AGSSolver::Solve()
+AGSLinearSolver::Solve()
 {
-  CALI_CXX_MARK_SCOPE("AGSSolver::Solve");
+  CALI_CXX_MARK_SCOPE("AGSLinearSolver::Solve");
 
   std::fill(phi_old_.begin(), phi_old_.end(), 0.0);
 
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_solver.h b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_linear_solver.h
similarity index 74%
rename from modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_solver.h
rename to modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_linear_solver.h
index 29f7c36454..4503ae8ac0 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_solver.h
+++ b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_linear_solver.h
@@ -4,6 +4,7 @@
 #pragma once
 
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_problem.h"
+#include "framework/math/linear_solver/linear_system_solver.h"
 #include "framework/utils/timer.h"
 #include <vector>
 
@@ -11,11 +12,12 @@ namespace opensn
 {
 
 /**Solver for Across-Groupset (AGS) solves.*/
-class AGSSolver
+class AGSLinearSolver : public LinearSystemSolver
 {
 public:
-  AGSSolver(LBSProblem& lbs_problem, std::vector<std::shared_ptr<LinearSolver>> wgs_solvers)
-    : lbs_problem_(lbs_problem),
+  AGSLinearSolver(LBSProblem& lbs_problem, std::vector<std::shared_ptr<LinearSolver>> wgs_solvers)
+    : LinearSystemSolver(IterativeMethod::CLASSIC_RICHARDSON, nullptr),
+      lbs_problem_(lbs_problem),
       wgs_solvers_(std::move(wgs_solvers)),
       phi_old_(lbs_problem.GetPhiOldLocal().size()),
       max_iterations_(100),
@@ -24,9 +26,9 @@ class AGSSolver
   {
   }
 
-  ~AGSSolver() {}
+  ~AGSLinearSolver() override {}
 
-  void Solve();
+  void Solve() override;
 
   bool IsVerbose() const { return verbose_; }
 
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/classic_richardson.cc b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/classic_richardson.cc
index c631d9bd3b..d8d2ee252f 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/classic_richardson.cc
+++ b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/classic_richardson.cc
@@ -19,8 +19,9 @@
 namespace opensn
 {
 
-ClassicRichardson::ClassicRichardson(const std::shared_ptr<WGSContext>& gs_context_ptr)
-  : LinearSolver(LinearSolver::IterativeMethod::CLASSIC_RICHARDSON, gs_context_ptr)
+ClassicRichardson::ClassicRichardson(const std::shared_ptr<WGSContext>& gs_context_ptr,
+                                     bool verbose = true)
+  : LinearSystemSolver(IterativeMethod::CLASSIC_RICHARDSON, gs_context_ptr), verbose_(verbose)
 {
 }
 
@@ -90,21 +91,24 @@ ClassicRichardson::Solve()
       psi_old_ = psi_new_;
     }
 
-    std::stringstream iter_stats;
-    iter_stats << program_timer.GetTimeString() << " WGS groups [" << groupset.groups.front().id
-               << "-" << groupset.groups.back().id << "]:"
-               << " Iteration = " << std::left << std::setw(5) << k
-               << " Point-wise change = " << std::left << std::setw(14) << pw_phi_change
-               << " Spectral-radius estimate = " << std::left << std::setw(10) << rho;
-
-    if (converged)
+    if (verbose_)
     {
-      iter_stats << " CONVERGED";
-      log.Log() << iter_stats.str();
-      break;
+      std::stringstream iter_stats;
+      iter_stats << program_timer.GetTimeString() << " WGS groups [" << groupset.groups.front().id
+                 << "-" << groupset.groups.back().id << "]:"
+                 << " Iteration = " << std::left << std::setw(5) << k
+                 << " Point-wise change = " << std::left << std::setw(14) << pw_phi_change
+                 << " Spectral-radius estimate = " << std::left << std::setw(10) << rho;
+
+      if (converged)
+      {
+        iter_stats << " CONVERGED";
+        log.Log() << iter_stats.str();
+        break;
+      }
+      else
+        log.Log() << iter_stats.str();
     }
-    else
-      log.Log() << iter_stats.str();
   }
 
   do_problem.GetQMomentsLocal() = saved_q_moments_local_;
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/classic_richardson.h b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/classic_richardson.h
index 785cd13acc..668f165ed1 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/classic_richardson.h
+++ b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/classic_richardson.h
@@ -5,7 +5,7 @@
 
 #include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/groupset/lbs_groupset.h"
-#include "framework/math/linear_solver/linear_solver.h"
+#include "framework/math/linear_solver/linear_system_solver.h"
 #include <memory>
 #include <vector>
 #include <functional>
@@ -17,20 +17,21 @@ namespace opensn
  * Linear Solver specialization for Within GroupSet (WGS) solves with classic
  * Richardson.
  */
-class ClassicRichardson : public LinearSolver
+class ClassicRichardson : public LinearSystemSolver
 {
 public:
   /**
    * Constructor.
    * \param gs_context_ptr Context Pointer to abstract context.
    */
-  explicit ClassicRichardson(const std::shared_ptr<WGSContext>& gs_context_ptr);
+  explicit ClassicRichardson(const std::shared_ptr<WGSContext>& gs_context_ptr, bool verbose);
 
   ~ClassicRichardson() override;
 
   void Solve() override;
 
 private:
+  bool verbose_;
   std::vector<double> saved_q_moments_local_;
   std::vector<double> psi_new_, psi_old_;
 };
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_context.h b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_context.h
similarity index 100%
rename from modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_context.h
rename to modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_context.h
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_residual_func.cc b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_residual_func.cc
similarity index 98%
rename from modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_residual_func.cc
rename to modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_residual_func.cc
index ebf7adad65..81f5bf8054 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_residual_func.cc
+++ b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_residual_func.cc
@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: 2024 The OpenSn Authors <https://open-sn.github.io/opensn/>
 // SPDX-License-Identifier: MIT
 
-#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_context.h"
+#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_context.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_vecops.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_compute.h"
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_residual_func.h b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_residual_func.h
similarity index 100%
rename from modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_residual_func.h
rename to modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_residual_func.h
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_solver.cc b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_solver.cc
similarity index 97%
rename from modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_solver.cc
rename to modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_solver.cc
index 8a19ea1c1a..2561d354a5 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_solver.cc
+++ b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_solver.cc
@@ -1,9 +1,9 @@
 // SPDX-FileCopyrightText: 2024 The OpenSn Authors <https://open-sn.github.io/opensn/>
 // SPDX-License-Identifier: MIT
 
-#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_solver.h"
+#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_solver.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/snes_k_monitor.h"
-#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_residual_func.h"
+#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_residual_func.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_vecops.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_compute.h"
 #include "framework/math/petsc_utils/petsc_utils.h"
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_solver.h b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_solver.h
similarity index 95%
rename from modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_solver.h
rename to modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_solver.h
index 74cd91e967..9fa0a59f04 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_solver.h
+++ b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_solver.h
@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_context.h"
+#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_context.h"
 #include "framework/math/nonlinear_solver/petsc_nonlinear_solver.h"
 
 namespace opensn
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/power_iteration_keigen.cc b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/power_iteration_keigen.cc
index a4479d9577..dfffe12478 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/power_iteration_keigen.cc
+++ b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/power_iteration_keigen.cc
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_problem.h"
-#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_solver.h"
+#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_linear_solver.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_compute.h"
 #include "framework/runtime.h"
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.cc b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.cc
index 5dd7169fd2..ccca4753ad 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.cc
+++ b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.cc
@@ -15,7 +15,7 @@ WGSContext::WGSContext(DiscreteOrdinatesProblem& do_problem,
                        SourceFlags lhs_scope,
                        SourceFlags rhs_scope,
                        bool log_info)
-  : LinearSolverContext(),
+  : LinearSystemContext(),
     do_problem(do_problem),
     groupset(groupset),
     set_source_function(set_source_function),
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.h b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.h
index 71ce9e361d..5622589464 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.h
+++ b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.h
@@ -16,7 +16,7 @@ namespace opensn
 class LBSGroupset;
 class DiscreteOrdinatesProblem;
 
-struct WGSContext : public LinearSolverContext
+struct WGSContext : public LinearSystemContext
 {
   WGSContext(DiscreteOrdinatesProblem& do_problem,
              LBSGroupset& groupset,
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_linear_solver.cc b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_linear_solver.cc
index 296881fdf0..519b7695d4 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_linear_solver.cc
+++ b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_linear_solver.cc
@@ -35,29 +35,21 @@ WGSLinearSolver::~WGSLinearSolver()
 void
 WGSLinearSolver::PreSetupCallback()
 {
-  CALI_CXX_MARK_SCOPE("WGSLinearSolver::PreSetupCallback");
-
   auto gs_context_ptr = std::dynamic_pointer_cast<WGSContext>(context_ptr_);
-
   gs_context_ptr->PreSetupCallback();
 }
 
 void
 WGSLinearSolver::SetConvergenceTest()
 {
-  CALI_CXX_MARK_SCOPE("WGSLinearSolver::SetConvergenceTest");
-
   KSPSetConvergenceTest(ksp_, &GSConvergenceTest, nullptr, nullptr);
 }
 
 void
 WGSLinearSolver::SetSystemSize()
 {
-  CALI_CXX_MARK_SCOPE("WGSLinearSolver::SetSystemSize");
-
   auto gs_context_ptr = std::dynamic_pointer_cast<WGSContext>(context_ptr_);
   const auto sizes = gs_context_ptr->GetSystemSize();
-
   num_local_dofs_ = sizes.first;
   num_global_dofs_ = sizes.second;
 }
@@ -65,8 +57,6 @@ WGSLinearSolver::SetSystemSize()
 void
 WGSLinearSolver::SetSystem()
 {
-  CALI_CXX_MARK_SCOPE("WGSLinearSolver::SetSystem");
-
   if (IsSystemSet())
     return;
 
@@ -95,45 +85,44 @@ WGSLinearSolver::SetSystem()
 void
 WGSLinearSolver::SetPreconditioner()
 {
-  CALI_CXX_MARK_SCOPE("WGSLinearSolver::SetPreconditioner");
-
   if (IsSystemSet())
     return;
   auto gs_context_ptr = std::dynamic_pointer_cast<WGSContext>(context_ptr_);
-
   gs_context_ptr->SetPreconditioner(ksp_);
 }
 
 void
 WGSLinearSolver::PostSetupCallback()
 {
-  CALI_CXX_MARK_SCOPE("WGSLinearSolver::PostSetupCallback");
-
   auto gs_context_ptr = std::dynamic_pointer_cast<WGSContext>(context_ptr_);
-
   gs_context_ptr->PostSetupCallback();
 }
 
 void
 WGSLinearSolver::PreSolveCallback()
 {
-  CALI_CXX_MARK_SCOPE("WGSLinearSolver::PreSolveCallback");
-
   auto gs_context_ptr = std::dynamic_pointer_cast<WGSContext>(context_ptr_);
-
+  auto& groupset = gs_context_ptr->groupset;
+  auto& do_problem = gs_context_ptr->do_problem;
+  if (do_problem.GetOptions().verbose_inner_iterations)
+  {
+    log.Log() << "\n\n"
+              << "********** Solving groupset " << groupset.id << " with "
+              << this->GetIterativeMethodName() << "\n\n"
+              << "Quadrature number of angles: " << groupset.quadrature->abscissae.size() << "\n"
+              << "Groups " << groupset.groups.front().id << " " << groupset.groups.back().id
+              << "\n\n";
+  }
   gs_context_ptr->PreSolveCallback();
 }
 
 void
 WGSLinearSolver::SetInitialGuess()
 {
-  CALI_CXX_MARK_SCOPE("WGSLinearSolver::SetInitialGuess");
-
   // If the norm of the initial guess is large enough, the initial guess will be used, otherwise it
   // is assumed to be zero.
 
   auto gs_context_ptr = std::dynamic_pointer_cast<WGSContext>(context_ptr_);
-
   auto& groupset = gs_context_ptr->groupset;
   auto& do_problem = gs_context_ptr->do_problem;
 
@@ -156,7 +145,6 @@ WGSLinearSolver::SetRHS()
   CALI_CXX_MARK_SCOPE("WGSLinearSolver::SetRHS");
 
   auto gs_context_ptr = std::dynamic_pointer_cast<WGSContext>(context_ptr_);
-
   auto& groupset = gs_context_ptr->groupset;
   auto& do_problem = gs_context_ptr->do_problem;
 
@@ -167,7 +155,7 @@ WGSLinearSolver::SetRHS()
   saved_q_moments_local_ = do_problem.GetQMomentsLocal();
 
   const bool single_richardson =
-    groupset.iterative_method == LinearSolver::IterativeMethod::PETSC_RICHARDSON and
+    groupset.iterative_method == LinearSystemSolver::IterativeMethod::PETSC_RICHARDSON and
     tolerance_options.maximum_iterations == 1;
 
   if (not single_richardson)
@@ -183,7 +171,7 @@ WGSLinearSolver::SetRHS()
     LBSVecOps::SetGSPETScVecFromPrimarySTLvector(do_problem, groupset, b_, PhiSTLOption::PHI_NEW);
 
     // Compute RHS norm
-    VecNorm(b_, NORM_2, &context_ptr_->rhs_norm);
+    VecNorm(b_, NORM_2, &gs_context_ptr->rhs_norm);
 
     // Compute precondition RHS norm
     PC pc;
@@ -191,7 +179,7 @@ WGSLinearSolver::SetRHS()
     Vec temp_vec;
     VecDuplicate(b_, &temp_vec);
     PCApply(pc, b_, temp_vec);
-    VecNorm(temp_vec, NORM_2, &context_ptr_->rhs_preconditioned_norm);
+    VecNorm(temp_vec, NORM_2, &gs_context_ptr->rhs_preconditioned_norm);
     VecDestroy(&temp_vec);
   }
   // If we have a single richardson iteration then the user probably wants
@@ -211,7 +199,7 @@ WGSLinearSolver::SetRHS()
     LBSVecOps::SetGSPETScVecFromPrimarySTLvector(do_problem, groupset, x_, PhiSTLOption::PHI_NEW);
 
     // Compute RHS norm
-    VecNorm(x_, NORM_2, &context_ptr_->rhs_norm);
+    VecNorm(x_, NORM_2, &gs_context_ptr->rhs_norm);
 
     // Compute precondition RHS norm
     PC pc;
@@ -219,7 +207,7 @@ WGSLinearSolver::SetRHS()
     Vec temp_vec;
     VecDuplicate(x_, &temp_vec);
     PCApply(pc, x_, temp_vec);
-    VecNorm(temp_vec, NORM_2, &context_ptr_->rhs_preconditioned_norm);
+    VecNorm(temp_vec, NORM_2, &gs_context_ptr->rhs_preconditioned_norm);
     VecDestroy(&temp_vec);
 
     SetKSPSolveSuppressionFlag(true);
@@ -229,10 +217,6 @@ WGSLinearSolver::SetRHS()
 void
 WGSLinearSolver::PostSolveCallback()
 {
-  CALI_CXX_MARK_SCOPE("WGSLinearSolver::PostSolveCallback");
-
-  // We simply restore the q_moments_local vector.
-
   // Get convergence reason
   if (not GetKSPSolveSuppressionFlag())
   {
@@ -245,10 +229,8 @@ WGSLinearSolver::PostSolveCallback()
 
   // Copy x to local solution
   auto gs_context_ptr = std::dynamic_pointer_cast<WGSContext>(context_ptr_);
-
   auto& groupset = gs_context_ptr->groupset;
   auto& do_problem = gs_context_ptr->do_problem;
-
   LBSVecOps::SetPrimarySTLvectorFromGSPETScVec(do_problem, groupset, x_, PhiSTLOption::PHI_NEW);
   LBSVecOps::SetPrimarySTLvectorFromGSPETScVec(do_problem, groupset, x_, PhiSTLOption::PHI_OLD);
 
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_linear_solver.h b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_linear_solver.h
index 4a680776f4..5843d0bfc0 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_linear_solver.h
+++ b/modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_linear_solver.h
@@ -4,7 +4,7 @@
 #pragma once
 
 #include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.h"
-#include "framework/math/linear_solver/petsc_linear_solver.h"
+#include "framework/math/linear_solver/petsc_linear_system_solver.h"
 #include <memory>
 #include <vector>
 #include <functional>
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/lbs_problem.cc b/modules/linear_boltzmann_solvers/lbs_problem/lbs_problem.cc
index 06025fda2c..1dc828909e 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/lbs_problem.cc
+++ b/modules/linear_boltzmann_solvers/lbs_problem/lbs_problem.cc
@@ -3,7 +3,7 @@
 
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_problem.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/wgs_context.h"
-#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_solver.h"
+#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_linear_solver.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/point_source/point_source.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/groupset/lbs_groupset.h"
 #include "framework/math/spatial_discretization/finite_element/piecewise_linear/piecewise_linear_discontinuous.h"
@@ -385,7 +385,7 @@ LBSProblem::GetActiveSetSourceFunction() const
   return active_set_source_function_;
 }
 
-std::shared_ptr<AGSSolver>
+std::shared_ptr<AGSLinearSolver>
 LBSProblem::GetAGSSolver()
 {
   return ags_solver_;
@@ -1395,7 +1395,7 @@ LBSProblem::InitializeSolverSchemes()
 
   InitializeWGSSolvers();
 
-  ags_solver_ = std::make_shared<AGSSolver>(*this, wgs_solvers_);
+  ags_solver_ = std::make_shared<AGSLinearSolver>(*this, wgs_solvers_);
   if (groupsets_.size() == 1)
   {
     ags_solver_->SetMaxIterations(1);
diff --git a/modules/linear_boltzmann_solvers/lbs_problem/lbs_problem.h b/modules/linear_boltzmann_solvers/lbs_problem/lbs_problem.h
index 8ddd5881e0..a485d5c0e6 100644
--- a/modules/linear_boltzmann_solvers/lbs_problem/lbs_problem.h
+++ b/modules/linear_boltzmann_solvers/lbs_problem/lbs_problem.h
@@ -24,7 +24,7 @@ namespace opensn
 class MPICommunicatorSet;
 class GridFaceHistogram;
 class TimeIntegration;
-class AGSSolver;
+class AGSLinearSolver;
 class WGSLinearSolver;
 struct WGSContext;
 
@@ -198,7 +198,7 @@ class LBSProblem : public Problem
 
   SetSourceFunction GetActiveSetSourceFunction() const;
 
-  std::shared_ptr<AGSSolver> GetAGSSolver();
+  std::shared_ptr<AGSLinearSolver> GetAGSSolver();
 
   std::vector<std::shared_ptr<LinearSolver>>& GetWGSSolvers();
 
@@ -329,7 +329,7 @@ class LBSProblem : public Problem
 
   SetSourceFunction active_set_source_function_;
 
-  std::shared_ptr<AGSSolver> ags_solver_;
+  std::shared_ptr<AGSLinearSolver> ags_solver_;
   std::vector<std::shared_ptr<LinearSolver>> wgs_solvers_;
 
   std::map<std::pair<size_t, size_t>, size_t> phi_field_functions_local_map_;
diff --git a/modules/linear_boltzmann_solvers/solvers/nl_keigen_solver.h b/modules/linear_boltzmann_solvers/solvers/nl_keigen_solver.h
index 194f7b43bf..f935c17444 100644
--- a/modules/linear_boltzmann_solvers/solvers/nl_keigen_solver.h
+++ b/modules/linear_boltzmann_solvers/solvers/nl_keigen_solver.h
@@ -5,7 +5,7 @@
 
 #include "modules/solver.h"
 #include "modules/linear_boltzmann_solvers/discrete_ordinates_problem/discrete_ordinates_problem.h"
-#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nl_keigen_ags_solver.h"
+#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/nonlinear_keigen_ags_solver.h"
 #include <petscsnes.h>
 
 namespace opensn
diff --git a/modules/linear_boltzmann_solvers/solvers/pi_keigen_solver.cc b/modules/linear_boltzmann_solvers/solvers/pi_keigen_solver.cc
index 2c48e13060..14f305adc2 100644
--- a/modules/linear_boltzmann_solvers/solvers/pi_keigen_solver.cc
+++ b/modules/linear_boltzmann_solvers/solvers/pi_keigen_solver.cc
@@ -9,7 +9,7 @@
 #include "modules/linear_boltzmann_solvers/solvers/pi_keigen_solver.h"
 #include "modules/linear_boltzmann_solvers/discrete_ordinates_problem/discrete_ordinates_problem.h"
 #include "modules/linear_boltzmann_solvers/discrete_ordinates_problem/acceleration/discrete_ordinates_keigen_acceleration.h"
-#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_solver.h"
+#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_linear_solver.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_vecops.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_compute.h"
 #include <iomanip>
diff --git a/modules/linear_boltzmann_solvers/solvers/pi_keigen_solver.h b/modules/linear_boltzmann_solvers/solvers/pi_keigen_solver.h
index 24d1c785aa..7811f6ae7a 100644
--- a/modules/linear_boltzmann_solvers/solvers/pi_keigen_solver.h
+++ b/modules/linear_boltzmann_solvers/solvers/pi_keigen_solver.h
@@ -11,7 +11,7 @@ namespace opensn
 
 class DiscreteOrdinatesProblem;
 class DiscreteOrdinatesKEigenAcceleration;
-class AGSSolver;
+class AGSLinearSolver;
 class LinearSolver;
 
 class PowerIterationKEigenSolver : public Solver
@@ -31,7 +31,7 @@ class PowerIterationKEigenSolver : public Solver
   std::vector<double>& phi_new_local_;
 
   std::vector<LBSGroupset>& groupsets_;
-  std::shared_ptr<AGSSolver> ags_solver_;
+  std::shared_ptr<AGSLinearSolver> ags_solver_;
   SetSourceFunction active_set_source_function_;
 
   LBSGroupset& front_gs_;
diff --git a/modules/linear_boltzmann_solvers/solvers/steady_state_solver.cc b/modules/linear_boltzmann_solvers/solvers/steady_state_solver.cc
index 19b7978024..1994ceaa8f 100644
--- a/modules/linear_boltzmann_solvers/solvers/steady_state_solver.cc
+++ b/modules/linear_boltzmann_solvers/solvers/steady_state_solver.cc
@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 
 #include "modules/linear_boltzmann_solvers/solvers/steady_state_solver.h"
-#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_solver.h"
+#include "modules/linear_boltzmann_solvers/lbs_problem/iterative_methods/ags_linear_solver.h"
 #include "modules/linear_boltzmann_solvers/lbs_problem/lbs_compute.h"
 #include "framework/object_factory.h"
 #include "framework/utils/hdf_utils.h"