diff --git a/vowpalwabbit/kernel_svm.cc b/vowpalwabbit/kernel_svm.cc
index 4657c859f6a..5ee0523e76e 100644
--- a/vowpalwabbit/kernel_svm.cc
+++ b/vowpalwabbit/kernel_svm.cc
@@ -84,33 +84,34 @@ void free_svm_model(svm_model* model)
 
 struct svm_params
 {
-  size_t current_pass;
-  bool active;
-  bool active_pool_greedy;
-  bool para_active;
-  double active_c;
-
-  size_t pool_size;
-  size_t pool_pos;
-  size_t subsample;  // NOTE: Eliminating subsample to only support 1/pool_size
-  size_t reprocess;
-
-  svm_model* model;
-  size_t maxcache;
+  size_t current_pass = 0;
+  bool active = false;
+  bool active_pool_greedy = false;
+  bool para_active = false;
+  double active_c = 0.0;
+
+  size_t pool_size = 0;
+  size_t pool_pos = 0;
+  size_t subsample = 0;  // NOTE: Eliminating subsample to only support 1/pool_size
+  size_t reprocess = 0;
+
+  svm_model* model = nullptr;
+  size_t maxcache = 0;
   // size_t curcache;
 
-  svm_example** pool;
-  float lambda;
+  svm_example** pool = nullptr;
+  float lambda = 0.f;
 
-  void* kernel_params;
-  size_t kernel_type;
+  void* kernel_params = nullptr;
+  size_t kernel_type = 0;
 
-  size_t local_begin, local_end;
-  size_t current_t;
+  size_t local_begin = 0;
+  size_t local_end = 0;
+  size_t current_t = 0;
 
-  float loss_sum;
+  float loss_sum = 0.f;
 
-  vw* all;  // flatten, parallel
+  vw* all = nullptr;  // flatten, parallel
   std::shared_ptr<rand_state> _random_state;
 
   ~svm_params()
@@ -438,7 +439,7 @@ void predict(svm_params& params, svm_example** ec_arr, float* scores, size_t n)
   }
 }
 
-void predict(svm_params& params, single_learner&, example& ec)
+void predict(svm_params& params, base_learner&, example& ec)
 {
   flat_example* fec = flatten_sort_example(*(params.all), &ec);
   if (fec)
@@ -762,7 +763,7 @@ void train(svm_params& params)
   free(train_pool);
 }
 
-void learn(svm_params& params, single_learner&, example& ec)
+void learn(svm_params& params, base_learner&, example& ec)
 {
   flat_example* fec = flatten_sort_example(*(params.all), &ec);
   if (fec)
@@ -799,7 +800,7 @@ VW::LEARNER::base_learner* kernel_svm_setup(VW::setup_base_i& stack_builder)
   options_i& options = *stack_builder.get_options();
   vw& all = *stack_builder.get_all_pointer();
 
-  auto params = scoped_calloc_or_throw<svm_params>();
+  auto params = VW::make_unique<svm_params>();
   std::string kernel_type;
   float bandwidth = 1.f;
   int degree = 2;
@@ -872,8 +873,10 @@ VW::LEARNER::base_learner* kernel_svm_setup(VW::setup_base_i& stack_builder)
 
   params->all->weights.stride_shift(0);
 
-  learner<svm_params, example>& l =
-      init_learner(params, learn, predict, 1, stack_builder.get_setupfn_name(kernel_svm_setup));
-  l.set_save_load(save_load);
-  return make_base(l);
+  auto* l = make_base_learner(std::move(params), learn, predict, stack_builder.get_setupfn_name(kernel_svm_setup),
+      prediction_type_t::scalar, label_type_t::simple)
+                .set_save_load(save_load)
+                .build();
+
+  return make_base(*l);
 }
diff --git a/vowpalwabbit/lda_core.cc b/vowpalwabbit/lda_core.cc
index a743dd47382..dffad8e5118 100644
--- a/vowpalwabbit/lda_core.cc
+++ b/vowpalwabbit/lda_core.cc
@@ -37,6 +37,7 @@
 #endif
 
 using namespace VW::config;
+using namespace VW::LEARNER;
 
 namespace logger = VW::io::logger;
 
@@ -57,15 +58,15 @@ class index_feature
 
 struct lda
 {
-  size_t topics;
-  float lda_alpha;
-  float lda_rho;
-  float lda_D;
-  float lda_epsilon;
-  size_t minibatch;
+  size_t topics = 0;
+  float lda_alpha = 0.f;
+  float lda_rho = 0.f;
+  float lda_D = 0.f;
+  float lda_epsilon = 0.f;
+  size_t minibatch = 0;
   lda_math_mode mmode;
 
-  size_t finish_example_count;
+  size_t finish_example_count = 0;
 
   v_array<float> Elogtheta;
   v_array<float> decay_levels;
@@ -77,16 +78,16 @@ struct lda
   v_array<float> v;
   std::vector<index_feature> sorted_features;
 
-  bool compute_coherence_metrics;
+  bool compute_coherence_metrics = false;
 
   // size by 1 << bits
   std::vector<uint32_t> feature_counts;
   std::vector<std::vector<size_t>> feature_to_example_map;
 
-  bool total_lambda_init;
+  bool total_lambda_init = false;
 
-  double example_t;
-  vw *all;  // regressor, lda
+  double example_t = 0.0;
+  vw* all = nullptr;  // regressor, lda
 
   static constexpr float underflow_threshold = 1.0e-10f;
   inline float digamma(float x);
@@ -963,7 +964,7 @@ void learn_batch(lda &l)
   l.doc_lengths.clear();
 }
 
-void learn(lda &l, VW::LEARNER::single_learner &, example &ec)
+void learn(lda& l, base_learner&, example& ec)
 {
   uint32_t num_ex = static_cast<uint32_t>(l.examples.size());
   l.examples.push_back(&ec);
@@ -980,7 +981,7 @@ void learn(lda &l, VW::LEARNER::single_learner &, example &ec)
   if (++num_ex == l.minibatch) learn_batch(l);
 }
 
-void learn_with_metrics(lda &l, VW::LEARNER::single_learner &base, example &ec)
+void learn_with_metrics(lda& l, base_learner& base, example& ec)
 {
   if (l.all->passes_complete == 0)
   {
@@ -1003,8 +1004,8 @@ void learn_with_metrics(lda &l, VW::LEARNER::single_learner &base, example &ec)
 }
 
 // placeholder
-void predict(lda &l, VW::LEARNER::single_learner &base, example &ec) { learn(l, base, ec); }
-void predict_with_metrics(lda &l, VW::LEARNER::single_learner &base, example &ec) { learn_with_metrics(l, base, ec); }
+void predict(lda& l, base_learner& base, example& ec) { learn(l, base, ec); }
+void predict_with_metrics(lda& l, base_learner& base, example& ec) { learn_with_metrics(l, base, ec); }
 
 struct word_doc_frequency
 {
@@ -1273,12 +1274,12 @@ std::istream &operator>>(std::istream &in, lda_math_mode &mmode)
   return in;
 }
 
-VW::LEARNER::base_learner* lda_setup(VW::setup_base_i& stack_builder)
+base_learner* lda_setup(VW::setup_base_i& stack_builder)
 {
   options_i& options = *stack_builder.get_options();
   vw& all = *stack_builder.get_all_pointer();
 
-  auto ld = scoped_calloc_or_throw<lda>();
+  auto ld = VW::make_unique<lda>();
   option_group_definition new_options("Latent Dirichlet Allocation");
   int math_mode;
   new_options.add(make_option("lda", ld->topics).keep().necessary().help("Run lda with <int> topics"))
@@ -1341,14 +1342,16 @@ VW::LEARNER::base_learner* lda_setup(VW::setup_base_i& stack_builder)
 
   all.example_parser->lbl_parser = no_label::no_label_parser;
 
-  VW::LEARNER::learner<lda, example>& l = init_learner(ld, ld->compute_coherence_metrics ? learn_with_metrics : learn,
-      ld->compute_coherence_metrics ? predict_with_metrics : predict, UINT64_ONE << all.weights.stride_shift(),
-      prediction_type_t::scalars, stack_builder.get_setupfn_name(lda_setup), true);
-
-  l.set_save_load(save_load);
-  l.set_finish_example(finish_example);
-  l.set_end_examples(end_examples);
-  l.set_end_pass(end_pass);
-
-  return make_base(l);
+  auto* l = make_base_learner(std::move(ld), ld->compute_coherence_metrics ? learn_with_metrics : learn,
+      ld->compute_coherence_metrics ? predict_with_metrics : predict, stack_builder.get_setupfn_name(lda_setup),
+      prediction_type_t::scalars, label_type_t::nolabel)
+                .set_params_per_weight(UINT64_ONE << all.weights.stride_shift())
+                .set_learn_returns_prediction(true)
+                .set_save_load(save_load)
+                .set_finish_example(finish_example)
+                .set_end_examples(end_examples)
+                .set_end_pass(end_pass)
+                .build();
+
+  return make_base(*l);
 }
diff --git a/vowpalwabbit/lrq.cc b/vowpalwabbit/lrq.cc
index dbffd20767d..e3a5135de70 100644
--- a/vowpalwabbit/lrq.cc
+++ b/vowpalwabbit/lrq.cc
@@ -14,13 +14,19 @@ using namespace VW::config;
 
 struct LRQstate
 {
-  vw* all;  // feature creation, audit, hash_inv
+  vw* all = nullptr;  // feature creation, audit, hash_inv
   bool lrindices[256];
   size_t orig_size[256];
   std::set<std::string> lrpairs;
-  bool dropout;
-  uint64_t seed;
-  uint64_t initial_seed;
+  bool dropout = false;
+  uint64_t seed = 0;
+  uint64_t initial_seed = 0;
+
+  LRQstate()
+  {
+    std::fill(lrindices, lrindices + 256, false);
+    std::fill(orig_size, orig_size + 256, 0);
+  }
 };
 
 bool valid_int(const char* s)
@@ -167,7 +173,7 @@ base_learner* lrq_setup(VW::setup_base_i& stack_builder)
 {
   options_i& options = *stack_builder.get_options();
   vw& all = *stack_builder.get_all_pointer();
-  auto lrq = scoped_calloc_or_throw<LRQstate>();
+  auto lrq = VW::make_unique<LRQstate>();
   std::vector<std::string> lrq_names;
   option_group_definition new_options("Low Rank Quadratics");
   new_options.add(make_option("lrq", lrq_names).keep().necessary().help("use low rank quadratic features"))
@@ -213,10 +219,14 @@ base_learner* lrq_setup(VW::setup_base_i& stack_builder)
 
   all.wpp = all.wpp * static_cast<uint64_t>(1 + maxk);
   auto base = stack_builder.setup_base_learner();
-  learner<LRQstate, example>& l = init_learner(lrq, as_singleline(base), predict_or_learn<true>,
-      predict_or_learn<false>, 1 + maxk, stack_builder.get_setupfn_name(lrq_setup), base->learn_returns_prediction);
-  l.set_end_pass(reset_seed);
+
+  auto* l = make_reduction_learner(std::move(lrq), as_singleline(base), predict_or_learn<true>, predict_or_learn<false>,
+      stack_builder.get_setupfn_name(lrq_setup))
+                .set_params_per_weight(1 + maxk)
+                .set_learn_returns_prediction(base->learn_returns_prediction)
+                .set_end_pass(reset_seed)
+                .build();
 
   // TODO: leaks memory ?
-  return make_base(l);
+  return make_base(*l);
 }
diff --git a/vowpalwabbit/lrqfa.cc b/vowpalwabbit/lrqfa.cc
index d398984757a..48883bb33dc 100644
--- a/vowpalwabbit/lrqfa.cc
+++ b/vowpalwabbit/lrqfa.cc
@@ -14,11 +14,17 @@ using namespace VW::config;
 
 struct LRQFAstate
 {
-  vw* all;
-  std::string field_name;
-  int k;
+  vw* all = nullptr;
+  std::string field_name = "";
+  int k = 0;
   int field_id[256];
   size_t orig_size[256];
+
+  LRQFAstate()
+  {
+    std::fill(field_id, field_id + 256, 0);
+    std::fill(orig_size, orig_size + 256, 0);
+  }
 };
 
 inline float cheesyrand(uint64_t x)
@@ -143,7 +149,7 @@ VW::LEARNER::base_learner* lrqfa_setup(VW::setup_base_i& stack_builder)
 
   if (!options.add_parse_and_check_necessary(new_options)) return nullptr;
 
-  auto lrq = scoped_calloc_or_throw<LRQFAstate>();
+  auto lrq = VW::make_unique<LRQFAstate>();
   lrq->all = &all;
 
   std::string lrqopt = VW::decode_inline_hex(lrqfa);
@@ -156,9 +162,13 @@ VW::LEARNER::base_learner* lrqfa_setup(VW::setup_base_i& stack_builder)
 
   all.wpp = all.wpp * static_cast<uint64_t>(1 + lrq->k);
   auto base = stack_builder.setup_base_learner();
-  learner<LRQFAstate, example>& l = init_learner(lrq, as_singleline(base), predict_or_learn<true>,
-      predict_or_learn<false>, 1 + lrq->field_name.size() * lrq->k, stack_builder.get_setupfn_name(lrqfa_setup),
-      base->learn_returns_prediction);
+  size_t ws = 1 + lrq->field_name.size() * lrq->k;
+
+  auto* l = make_reduction_learner(std::move(lrq), as_singleline(base), predict_or_learn<true>, predict_or_learn<false>,
+      stack_builder.get_setupfn_name(lrqfa_setup))
+                .set_params_per_weight(ws)
+                .set_learn_returns_prediction(base->learn_returns_prediction)
+                .build();
 
-  return make_base(l);
+  return make_base(*l);
 }
diff --git a/vowpalwabbit/memory_tree.cc b/vowpalwabbit/memory_tree.cc
index 1cb19e34364..358c7b7c58e 100644
--- a/vowpalwabbit/memory_tree.cc
+++ b/vowpalwabbit/memory_tree.cc
@@ -162,24 +162,24 @@ struct node
 // memory_tree
 struct memory_tree
 {
-  vw* all;
+  vw* all = nullptr;
   std::shared_ptr<rand_state> _random_state;
 
   std::vector<node> nodes;  // array of nodes.
   // v_array<node> nodes;         // array of nodes.
   v_array<example*> examples;  // array of example points
 
-  size_t max_leaf_examples;
-  size_t max_nodes;
-  size_t leaf_example_multiplier;
-  size_t max_routers;
-  size_t max_num_labels;
+  size_t max_leaf_examples = 0;
+  size_t max_nodes = 0;
+  size_t leaf_example_multiplier = 0;
+  size_t max_routers = 0;
+  size_t max_num_labels = 0;
   float alpha;  // for cpt type of update.
   uint64_t routers_used;
   int iter;
-  uint32_t dream_repeats;  // number of dream operations per example.
+  uint32_t dream_repeats = 0;  // number of dream operations per example.
 
-  uint32_t total_num_queries;
+  uint32_t total_num_queries = 0;
 
   size_t max_depth;
   size_t max_ex_in_leaf;
@@ -188,35 +188,35 @@ struct memory_tree
   float test_time;       // recording the test time
 
   uint32_t num_mistakes;
-  bool learn_at_leaf;  // indicator for turning on learning the scorer function at the leaf level
+  bool learn_at_leaf = false;  // indicator for turning on learning the scorer function at the leaf level
 
   bool test_mode;
 
-  size_t current_pass;  // for tracking # of passes over the dataset
-  size_t final_pass;
+  size_t current_pass = 0;  // for tracking # of passes over the dataset
+  size_t final_pass = 0;
 
   int top_K;  // commands:
-  bool oas;   // indicator for multi-label classification (oas = 1)
-  int dream_at_update;
+  bool oas = false;  // indicator for multi-label classification (oas = 1)
+  int dream_at_update = 0;
 
-  bool online;  // indicator for running CMT in online fashion
+  bool online = false;  // indicator for running CMT in online fashion
 
-  float F1_score;
-  float hamming_loss;
+  float F1_score = 0.f;
+  float hamming_loss = 0.f;
 
-  example* kprod_ec;
+  example* kprod_ec = nullptr;
 
   memory_tree()
   {
-    alpha = 0.5;
+    alpha = 0.5f;
     routers_used = 0;
     iter = 0;
     num_mistakes = 0;
     test_mode = false;
     max_depth = 0;
     max_ex_in_leaf = 0;
-    construct_time = 0;
-    test_time = 0;
+    construct_time = 0.f;
+    test_time = 0.f;
     top_K = 1;
   }
 
@@ -1202,7 +1202,7 @@ base_learner* memory_tree_setup(VW::setup_base_i& stack_builder)
   options_i& options = *stack_builder.get_options();
   vw& all = *stack_builder.get_all_pointer();
   using namespace memory_tree_ns;
-  auto tree = scoped_calloc_or_throw<memory_tree>();
+  auto tree = VW::make_unique<memory_tree>();
   option_group_definition new_options("Memory Tree");
 
   new_options
@@ -1249,32 +1249,36 @@ base_learner* memory_tree_setup(VW::setup_base_i& stack_builder)
                          << "oas = " << tree->oas << " "
                          << "online =" << tree->online << " " << std::endl;
 
-  size_t num_learners = 0;
+  size_t num_learners;
+  prediction_type_t pred_type;
+  label_type_t label_type;
+  bool oas = tree->oas;
 
   // multi-class classification
-  if (tree->oas == false)
+  if (!oas)
   {
     num_learners = tree->max_nodes + 1;
-    learner<memory_tree, example>& l = init_multiclass_learner(tree, as_singleline(stack_builder.setup_base_learner()),
-        learn, predict, all.example_parser, num_learners, stack_builder.get_setupfn_name(memory_tree_setup));
-    all.example_parser->lbl_parser.label_type = label_type_t::multiclass;
-    // srand(time(0));
-    l.set_save_load(save_load_memory_tree);
-    l.set_end_pass(end_pass);
-
-    return make_base(l);
+    all.example_parser->lbl_parser = MULTICLASS::mc_label;
+    pred_type = prediction_type_t::multiclass;
+    label_type = label_type_t::multiclass;
   }  // multi-label classification
   else
   {
     num_learners = tree->max_nodes + 1 + tree->max_num_labels;
-    learner<memory_tree, example>& l = init_learner(tree, as_singleline(stack_builder.setup_base_learner()), learn,
-        predict, num_learners, prediction_type_t::multilabels, stack_builder.get_setupfn_name(memory_tree_setup));
+    all.example_parser->lbl_parser = MULTILABEL::multilabel;
+    pred_type = prediction_type_t::multilabels;
+    label_type = label_type_t::multilabel;
+  }
 
-    l.set_end_pass(end_pass);
-    l.set_save_load(save_load_memory_tree);
+  auto l = make_reduction_learner(std::move(tree), as_singleline(stack_builder.setup_base_learner()), learn, predict,
+      stack_builder.get_setupfn_name(memory_tree_setup))
+               .set_params_per_weight(num_learners)
+               .set_end_pass(end_pass)
+               .set_save_load(save_load_memory_tree)
+               .set_prediction_type(pred_type)
+               .set_label_type(label_type);
 
-    all.example_parser->lbl_parser = MULTILABEL::multilabel;
+  if (!oas) { l.set_finish_example(MULTICLASS::finish_example<memory_tree&>); }
 
-    return make_base(l);
-  }
+  return make_base(*l.build());
 }