diff --git a/immer/extra/archive/box/archive.hpp b/immer/extra/archive/box/archive.hpp
index 3e387376..df290500 100644
--- a/immer/extra/archive/box/archive.hpp
+++ b/immer/extra/archive/box/archive.hpp
@@ -10,6 +10,8 @@
 
 #include <cereal/cereal.hpp>
 
+#include <boost/hana/functional/id.hpp>
+
 namespace immer::archive::box {
 
 template <typename T, typename MemoryPolicy>
@@ -115,25 +117,48 @@ save_to_archive(immer::box<T, MemoryPolicy> box,
     return {std::move(archive), id};
 }
 
-template <typename T, typename MemoryPolicy>
+template <typename T,
+          typename MemoryPolicy,
+          typename Archive    = archive_load<T, MemoryPolicy>,
+          typename TransformF = boost::hana::id_t>
 class loader
 {
 public:
-    explicit loader(archive_load<T, MemoryPolicy> ar)
+    explicit loader(Archive ar)
+        requires std::is_same_v<TransformF, boost::hana::id_t>
+        : ar_{std::move(ar)}
+    {
+    }
+
+    explicit loader(Archive ar, TransformF transform)
         : ar_{std::move(ar)}
+        , transform_{std::move(transform)}
     {
     }
 
-    immer::box<T, MemoryPolicy> load(container_id id) const
+    immer::box<T, MemoryPolicy> load(container_id id)
     {
         if (id.value >= ar_.boxes.size()) {
             throw invalid_container_id{id};
         }
-        return ar_.boxes[id.value];
+        if constexpr (std::is_same_v<TransformF, boost::hana::id_t>) {
+            return ar_.boxes[id.value];
+        } else {
+            if (auto* b = boxes.find(id)) {
+                return *b;
+            }
+            const auto& old_box = ar_.boxes[id.value];
+            auto new_box =
+                immer::box<T, MemoryPolicy>{transform_(old_box.get())};
+            boxes = std::move(boxes).set(id, new_box);
+            return new_box;
+        }
     }
 
 private:
-    const archive_load<T, MemoryPolicy> ar_;
+    const Archive ar_;
+    const TransformF transform_;
+    immer::map<container_id, immer::box<T, MemoryPolicy>> boxes;
 };
 
 template <typename T, typename MemoryPolicy>
@@ -166,8 +191,12 @@ struct container_traits<immer::box<T, MemoryPolicy>>
 {
     using save_archive_t = box::archive_save<T, MemoryPolicy>;
     using load_archive_t = box::archive_load<T, MemoryPolicy>;
-    using loader_t       = box::loader<T, MemoryPolicy>;
-    using container_id   = immer::archive::container_id;
+
+    template <typename Archive    = load_archive_t,
+              typename TransformF = boost::hana::id_t>
+    using loader_t = box::loader<T, MemoryPolicy, Archive, TransformF>;
+
+    using container_id = immer::archive::container_id;
 
     template <class F>
     static auto transform(F&& func)
diff --git a/immer/extra/archive/cereal/immer_box.hpp b/immer/extra/archive/cereal/immer_box.hpp
new file mode 100644
index 00000000..438da399
--- /dev/null
+++ b/immer/extra/archive/cereal/immer_box.hpp
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <cereal/cereal.hpp>
+#include <immer/box.hpp>
+
+namespace cereal {
+
+template <typename Archive, typename T, typename MemoryPolicy>
+void CEREAL_LOAD_FUNCTION_NAME(Archive& ar, immer::box<T, MemoryPolicy>& m)
+{
+    T x;
+    ar(x);
+    m = x;
+}
+
+template <typename Archive, typename T, typename MemoryPolicy>
+void CEREAL_SAVE_FUNCTION_NAME(Archive& ar,
+                               const immer::box<T, MemoryPolicy>& m)
+{
+    ar(m.get());
+}
+
+} // namespace cereal
diff --git a/immer/extra/archive/champ/champ.hpp b/immer/extra/archive/champ/champ.hpp
index ed02e1d2..d6e81933 100644
--- a/immer/extra/archive/champ/champ.hpp
+++ b/immer/extra/archive/champ/champ.hpp
@@ -44,7 +44,9 @@ class hash_validation_failed_exception : public archive_exception
     }
 };
 
-template <class Container>
+template <class Container,
+          typename Archive    = container_archive_load<Container>,
+          typename TransformF = boost::hana::id_t>
 class container_loader
 {
     using champ_t = std::decay_t<decltype(std::declval<Container>().impl())>;
@@ -61,12 +63,19 @@ class container_loader
     };
 
 public:
-    explicit container_loader(container_archive_load<Container> archive)
+    explicit container_loader(Archive archive)
+        requires std::is_same_v<TransformF, boost::hana::id_t>
         : archive_{std::move(archive)}
         , nodes_{archive_.nodes}
     {
     }
 
+    explicit container_loader(Archive archive, TransformF transform)
+        : archive_{std::move(archive)}
+        , nodes_{archive_.nodes, std::move(transform)}
+    {
+    }
+
     Container load(node_id root_id)
     {
         if (root_id.value >= archive_.nodes.size()) {
@@ -106,15 +115,20 @@ class container_loader
     }
 
 private:
-    const container_archive_load<Container> archive_;
+    const Archive archive_;
     nodes_loader<typename node_t::value_t,
                  typename traits::Hash,
                  typename traits::Equal,
                  typename traits::MemoryPolicy,
-                 traits::bits>
+                 traits::bits,
+                 TransformF>
         nodes_;
 };
 
+template <class Container>
+container_loader(container_archive_load<Container> archive)
+    -> container_loader<Container>;
+
 template <class Container>
 std::pair<container_archive_save<Container>, node_id>
 save_to_archive(Container container, container_archive_save<Container> archive)
diff --git a/immer/extra/archive/champ/load.hpp b/immer/extra/archive/champ/load.hpp
index 391bb32d..ed6909b4 100644
--- a/immer/extra/archive/champ/load.hpp
+++ b/immer/extra/archive/champ/load.hpp
@@ -6,7 +6,9 @@
 
 #include <immer/flex_vector.hpp>
 
+#include <boost/hana/functional/id.hpp>
 #include <boost/range/adaptor/indexed.hpp>
+
 #include <spdlog/spdlog.h>
 
 namespace immer::archive {
@@ -54,7 +56,8 @@ template <class T,
           typename Hash                  = std::hash<T>,
           typename Equal                 = std::equal_to<T>,
           typename MemoryPolicy          = immer::default_memory_policy,
-          immer::detail::hamts::bits_t B = immer::default_bits>
+          immer::detail::hamts::bits_t B = immer::default_bits,
+          typename TransformF            = boost::hana::id_t>
 class nodes_loader
 {
 public:
@@ -66,7 +69,14 @@ class nodes_loader
     using values_t = immer::flex_vector<immer::array<T>>;
 
     explicit nodes_loader(nodes_load<T, B> archive)
+        requires std::is_same_v<TransformF, boost::hana::id_t>
+        : archive_{std::move(archive)}
+    {
+    }
+
+    explicit nodes_loader(nodes_load<T, B> archive, TransformF transform)
         : archive_{std::move(archive)}
+        , transform_{std::move(transform)}
     {
     }
 
@@ -219,6 +229,7 @@ class nodes_loader
 
 private:
     const nodes_load<T, B> archive_;
+    const TransformF transform_;
     immer::map<node_id, std::pair<node_ptr, values_t>> collisions_;
     immer::map<node_id, std::pair<node_ptr, values_t>> inners_;
 };
diff --git a/immer/extra/archive/champ/traits.hpp b/immer/extra/archive/champ/traits.hpp
index 0f4b24a4..295ea396 100644
--- a/immer/extra/archive/champ/traits.hpp
+++ b/immer/extra/archive/champ/traits.hpp
@@ -4,6 +4,8 @@
 #include <immer/extra/archive/champ/champ.hpp>
 #include <immer/extra/archive/traits.hpp>
 
+#include <boost/hana/functional/id.hpp>
+
 namespace immer::archive {
 
 template <class Container>
@@ -13,8 +15,12 @@ struct champ_traits
         immer::archive::champ::container_archive_save<Container>;
     using load_archive_t =
         immer::archive::champ::container_archive_load<Container>;
-    using loader_t     = immer::archive::champ::container_loader<Container>;
     using container_id = immer::archive::node_id;
+
+    template <typename Archive    = load_archive_t,
+              typename TransformF = boost::hana::id_t>
+    using loader_t =
+        immer::archive::champ::container_loader<Container, Archive, TransformF>;
 };
 
 template <typename K,
diff --git a/immer/extra/archive/json/json_with_archive.hpp b/immer/extra/archive/json/json_with_archive.hpp
index 6af7cfab..7d69ba32 100644
--- a/immer/extra/archive/json/json_with_archive.hpp
+++ b/immer/extra/archive/json/json_with_archive.hpp
@@ -16,6 +16,9 @@ namespace immer::archive {
 
 namespace detail {
 
+template <class T>
+class QQ;
+
 namespace hana = boost::hana;
 
 /**
@@ -85,32 +88,63 @@ struct archives_save
     }
 };
 
-template <class Container>
+template <class Container,
+          class Archive = typename container_traits<Container>::load_archive_t,
+          class TransformF       = boost::hana::id_t,
+          class OldContainerType = boost::hana::id_t>
 struct archive_type_load
 {
-    using archive_t = typename container_traits<Container>::load_archive_t;
+    using container_t     = Container;
+    using old_container_t = OldContainerType;
 
-    archive_t archive = {};
-    std::optional<typename container_traits<Container>::loader_t> loader;
+    Archive archive = {};
+    TransformF transform;
+    std::optional<typename container_traits<
+        Container>::template loader_t<Archive, TransformF>>
+        loader;
 
     archive_type_load() = default;
 
-    explicit archive_type_load(archive_t archive_)
+    explicit archive_type_load(Archive archive_)
+        requires std::is_same_v<TransformF, boost::hana::id_t>
         : archive{std::move(archive_)}
     {
     }
 
+    explicit archive_type_load(Archive archive_, TransformF transform_)
+        : archive{std::move(archive_)}
+        , transform{std::move(transform_)}
+    {
+    }
+
     archive_type_load(const archive_type_load& other)
         : archive{other.archive}
+        , transform{other.transform}
     {
     }
 
     archive_type_load& operator=(const archive_type_load& other)
     {
-        archive = other.archive;
+        archive   = other.archive;
+        transform = other.transform;
         return *this;
     }
 
+    template <class Func>
+    auto with_transform(Func&& func) const
+    {
+        using value_type = typename Container::value_type;
+        using new_value_type =
+            std::decay_t<decltype(func(std::declval<value_type>()))>;
+        using NewContainer =
+            std::decay_t<decltype(container_traits<Container>::transform(
+                func))>;
+        using TransF = std::function<new_value_type(const value_type&)>;
+        // the transform function must be filled in later
+        return archive_type_load<NewContainer, Archive, TransF, Container>{
+            archive, TransF{}};
+    }
+
     friend bool operator==(const archive_type_load& left,
                            const archive_type_load& right)
     {
@@ -157,7 +191,29 @@ struct archives_load
 
         auto& load = storage[hana::type_c<Container>];
         if (!load.loader) {
-            load.loader.emplace(load.archive);
+            load.loader.emplace(load.archive, load.transform);
+        }
+        return *load.loader;
+    }
+
+    template <class OldContainer>
+    auto& get_loader_by_old_container()
+    {
+        constexpr auto find_key = [](const auto& storage) {
+            return hana::find_if(
+                       hana::keys(storage),
+                       [&](auto key) {
+                           using type1 = typename std::decay_t<
+                               decltype(storage[key])>::old_container_t;
+                           return hana::type_c<type1> ==
+                                  hana::type_c<OldContainer>;
+                       })
+                .value();
+        };
+        using Key  = decltype(find_key(storage));
+        auto& load = storage[Key{}];
+        if (!load.loader) {
+            load.loader.emplace(load.archive, load.transform);
         }
         return *load.loader;
     }
@@ -247,36 +303,28 @@ struct archives_load
 
         // Return a pair where second is an optional. Optional is already
         // populated if no transformation is required.
-        const auto transform_pair_initial = [fake_convert_container,
-                                             &conversion_map](
-                                                const auto& pair) {
-            using Contains =
-                decltype(hana::contains(conversion_map, hana::first(pair)));
-            constexpr bool contains = hana::value<Contains>();
-            if constexpr (contains) {
-                // Look up the conversion function by the type from the original
-                // archive.
-                const auto& func = inject_argument(
-                    fake_convert_container, conversion_map[hana::first(pair)]);
-
-                using Container = typename decltype(+hana::first(pair))::type;
-                using NewContainer = std::decay_t<
-                    decltype(container_traits<Container>::transform(func))>;
-                const auto old_key = hana::first(pair);
-                return hana::make_pair(
-                    hana::type_c<NewContainer>,
-                    hana::make_tuple(
-                        old_key,
-                        std::optional<archive_type_load<NewContainer>>{}));
-            } else {
-                // If the conversion map doesn't mention the current type, we
-                // leave it as is.
-                return hana::make_pair(
-                    hana::first(pair),
-                    hana::make_tuple(hana::first(pair),
-                                     std::make_optional(hana::second(pair))));
-            }
-        };
+        const auto transform_pair_initial =
+            [fake_convert_container, &conversion_map, this](const auto& pair) {
+                using Contains =
+                    decltype(hana::contains(conversion_map, hana::first(pair)));
+                constexpr bool contains = hana::value<Contains>();
+                if constexpr (contains) {
+                    // Look up the conversion function by the type from the
+                    // original archive.
+                    const auto& func =
+                        inject_argument(fake_convert_container,
+                                        conversion_map[hana::first(pair)]);
+                    auto type_load =
+                        storage[hana::first(pair)].with_transform(func);
+                    using NewContainer = decltype(type_load)::container_t;
+                    return hana::make_pair(hana::type_c<NewContainer>,
+                                           std::move(type_load));
+                } else {
+                    // If the conversion map doesn't mention the current type,
+                    // we leave it as is.
+                    return pair;
+                }
+            };
 
         // Each archive is wrapped in optional to know if it's already been
         // converted or not, since the order is unknown and depends on the
@@ -285,76 +333,54 @@ struct archives_load
         // This temporary storage is a map from type to
         // (old_key, optional<archive_type_load>). Some optionals are already
         // populated, if no transformation is required.
-        auto optional_storage = hana::fold_left(
+        auto optional_storage_ = hana::fold_left(
             storage,
             hana::make_map(),
             [transform_pair_initial](auto map, auto pair) {
                 return hana::insert(map, transform_pair_initial(pair));
             });
-        const auto process =
-            [this](auto old_key, auto& optional_archive, const auto& func) {
-                if (optional_archive) {
-                    // The archive has already been processed, do nothing
-                    return;
-                }
-                const auto& archive = storage[old_key].archive;
-                // Each archive defines the transform_archive function that
-                // transforms its leaves with the given function.
-                optional_archive.emplace(transform_archive(archive, func));
-            };
+        auto optional_storage =
+            std::make_shared<std::decay_t<decltype(optional_storage_)>>(
+                optional_storage_);
 
         // The get_loader function accepts a new container type as an argument
         // (after transformation, if any) and returns a reference to a loader
         // that is able to load such container types.
-        const auto get_loader = [&optional_storage, &conversion_map, process](
-                                    const auto& convert_container,
-                                    auto new_container_type) -> auto& {
-            auto& s              = optional_storage[new_container_type];
-            auto& st             = hana::at_c<1>(s);
-            const auto old_key   = hana::at_c<0>(s);
-            const auto& old_func = conversion_map[old_key];
-            auto func            = inject_argument(convert_container, old_func);
-            process(old_key, st, func);
-
-            auto& type_load = *st;
+        const auto get_loader =
+            [optional_storage](auto new_container_type) -> auto& {
+            auto& type_load = (*optional_storage)[new_container_type];
             if (!type_load.loader) {
-                type_load.loader.emplace(type_load.archive);
+                type_load.loader.emplace(type_load.archive,
+                                         type_load.transform);
             }
             return *type_load.loader;
         };
 
         const auto convert_container =
-            hana::fix([&get_id, get_loader](
-                          auto self, auto new_type, const auto& old_container) {
+            [get_id, get_loader](auto new_type, const auto& old_container) {
                 const auto id = get_id(old_container);
-                auto& loader  = get_loader(self, new_type);
+                auto& loader  = get_loader(new_type);
                 return loader.load(id);
-            });
+            };
 
         // Call `process` for each type
-        hana::for_each(hana::keys(optional_storage), [&](auto key) {
-            auto& s            = optional_storage[key];
-            auto& st           = hana::at_c<1>(s);
-            const auto old_key = hana::at_c<0>(s);
+        hana::for_each(hana::keys(*optional_storage), [&](auto key) {
+            auto& st       = (*optional_storage)[key];
+            using TypeLoad = std::decay_t<decltype(st)>;
+            const auto old_key =
+                hana::type_c<typename TypeLoad::old_container_t>;
             constexpr auto needs_conversion =
                 hana::value<decltype(hana::contains(conversion_map,
                                                     old_key))>();
             if constexpr (needs_conversion) {
                 const auto& old_func = conversion_map[old_key];
-                auto func = inject_argument(convert_container, old_func);
-                process(old_key, st, func);
+                auto func    = inject_argument(convert_container, old_func);
+                st.transform = std::move(func);
             }
         });
 
         // By now, all optionals have been emplaced.
-        auto new_storage = hana::fold_left(
-            optional_storage, hana::make_map(), [](auto map, auto pair) {
-                // Extract from std::optional
-                return hana::insert(
-                    map,
-                    hana::make_pair(hana::first(pair),
-                                    hana::at_c<1>(hana::second(pair)).value()));
-            });
+        auto new_storage = *optional_storage;
         using NewStorage = decltype(new_storage);
         return archives_load<NewStorage, Names>{std::move(new_storage)};
     }
@@ -589,6 +615,20 @@ T from_json_with_archive_with_conversion(const std::string& input,
     return from_json_with_archive_with_conversion<T, OldType>(is, map);
 }
 
+template <class Storage, class Names, class Container>
+auto get_container_id(const detail::archives_save<Storage, Names>& archives,
+                      const Container& container)
+{
+    const auto& old_archive =
+        archives.template get_save_archive<std::decay_t<Container>>();
+    const auto [new_archive, id] = save_to_archive(container, old_archive);
+    if (!(new_archive == old_archive)) {
+        throw std::logic_error{
+            "Expecting that the container has already been archived"};
+    }
+    return id;
+}
+
 /**
  * Given an archives_save and a map of transformations, produce a new type of
  * load archive with those transformations applied
@@ -599,19 +639,35 @@ inline auto transform_save_archive(
     const ConversionMap& conversion_map)
 {
     const auto old_load_archives = to_load_archives(old_archives);
-    const auto get_id = [&old_archives](const auto& immer_container) {
-        using Container = std::decay_t<decltype(immer_container)>;
-        const auto& old_archive =
-            old_archives.template get_save_archive<Container>();
-        const auto [new_archive, id] =
-            save_to_archive(immer_container, old_archive);
-        if (!(new_archive == old_archive)) {
-            throw std::logic_error{
-                "Expecting that the container has already been archived"};
-        }
-        return id;
+    // NOTE: We have to copy old_archives here because the get_id function will
+    // be called later, as the conversion process is lazy.
+    const auto get_id = [old_archives](const auto& immer_container) {
+        return get_container_id(old_archives, immer_container);
     };
     return old_load_archives.transform_recursive(conversion_map, get_id);
 }
 
+/**
+ * Given an old save archives and a new (transformed) load archives, effectively
+ * convert the given container.
+ */
+template <class SaveStorage,
+          class SaveNames,
+          class LoadStorage,
+          class LoadNames,
+          class Container>
+auto convert_container(
+    const detail::archives_save<SaveStorage, SaveNames>& old_save_archives,
+    detail::archives_load<LoadStorage, LoadNames>& new_load_archives,
+    const Container& container)
+{
+    const auto container_id = get_container_id(old_save_archives, container);
+    auto& loader =
+        new_load_archives
+            .template get_loader_by_old_container<std::decay_t<Container>>();
+    auto result = loader.load(container_id);
+    // return std::make_pair(std::move(result), std::move(new_load_archives));
+    return result;
+}
+
 } // namespace immer::archive
diff --git a/immer/extra/archive/rbts/load.hpp b/immer/extra/archive/rbts/load.hpp
index e9da42fe..ad48ce5a 100644
--- a/immer/extra/archive/rbts/load.hpp
+++ b/immer/extra/archive/rbts/load.hpp
@@ -81,7 +81,9 @@ class same_depth_children_exception : public archive_exception
 template <class T,
           typename MemoryPolicy,
           immer::detail::rbts::bits_t B,
-          immer::detail::rbts::bits_t BL>
+          immer::detail::rbts::bits_t BL,
+          class Archive    = archive_load<T>,
+          class TransformF = boost::hana::id_t>
 class loader
 {
 public:
@@ -91,8 +93,15 @@ class loader
     using node_ptr    = node_ptr<node_t>;
     using nodes_set_t = immer::set<node_id>;
 
-    explicit loader(archive_load<T> ar)
+    explicit loader(Archive ar)
+        requires std::is_same_v<TransformF, boost::hana::id_t>
+        : ar_{std::move(ar)}
+    {
+    }
+
+    explicit loader(Archive ar, TransformF transform)
         : ar_{std::move(ar)}
+        , transform_{std::move(transform)}
     {
     }
 
@@ -169,8 +178,12 @@ class loader
 
         auto leaf = node_ptr{n ? node_t::make_leaf_n(n) : rbtree::empty_tail(),
                              [n](auto* ptr) { node_t::delete_leaf(ptr, n); }};
+        auto values = std::vector<T>{};
+        for (const auto& item : node_info->data) {
+            values.push_back(transform_(item));
+        }
         immer::detail::uninitialized_copy(
-            node_info->data.begin(), node_info->data.end(), leaf.get()->leaf());
+            values.begin(), values.end(), leaf.get()->leaf());
         leaves_        = std::move(leaves_).set(id, leaf);
         loaded_leaves_ = std::move(loaded_leaves_).set(leaf.get(), id);
         return leaf;
@@ -462,7 +475,8 @@ class loader
     }
 
 private:
-    const archive_load<T> ar_;
+    const Archive ar_;
+    const TransformF transform_;
     immer::map<node_id, node_ptr> leaves_;
     immer::map<node_id, node_ptr> inners_;
     immer::map<node_t*, node_id> loaded_leaves_;
@@ -474,19 +488,27 @@ class loader
 template <typename T,
           typename MemoryPolicy,
           immer::detail::rbts::bits_t B,
-          immer::detail::rbts::bits_t BL>
+          immer::detail::rbts::bits_t BL,
+          class Archive    = archive_load<T>,
+          class TransformF = boost::hana::id_t>
 class vector_loader
 {
 public:
-    explicit vector_loader(archive_load<T> ar)
+    explicit vector_loader(Archive ar)
+        requires std::is_same_v<TransformF, boost::hana::id_t>
         : loader{std::move(ar)}
     {
     }
 
+    explicit vector_loader(Archive ar, TransformF transform)
+        : loader{std::move(ar), std::move(transform)}
+    {
+    }
+
     auto load(container_id id) { return loader.load_vector(id); }
 
 private:
-    loader<T, MemoryPolicy, B, BL> loader;
+    loader<T, MemoryPolicy, B, BL, Archive, TransformF> loader;
 };
 
 template <typename T,
@@ -503,19 +525,21 @@ make_loader_for(const immer::vector<T, MemoryPolicy, B, BL>&,
 template <typename T,
           typename MemoryPolicy,
           immer::detail::rbts::bits_t B,
-          immer::detail::rbts::bits_t BL>
+          immer::detail::rbts::bits_t BL,
+          class Archive    = archive_load<T>,
+          class TransformF = boost::hana::id_t>
 class flex_vector_loader
 {
 public:
-    explicit flex_vector_loader(archive_load<T> ar)
-        : loader{std::move(ar)}
+    explicit flex_vector_loader(Archive ar, TransformF transform = {})
+        : loader{std::move(ar), std::move(transform)}
     {
     }
 
     auto load(container_id id) { return loader.load_flex_vector(id); }
 
 private:
-    loader<T, MemoryPolicy, B, BL> loader;
+    loader<T, MemoryPolicy, B, BL, Archive, TransformF> loader;
 };
 
 template <typename T,
diff --git a/immer/extra/archive/rbts/traits.hpp b/immer/extra/archive/rbts/traits.hpp
index c2678ae0..85474b10 100644
--- a/immer/extra/archive/rbts/traits.hpp
+++ b/immer/extra/archive/rbts/traits.hpp
@@ -14,9 +14,13 @@ struct container_traits<immer::vector<T, MemoryPolicy, B, BL>>
 {
     using save_archive_t = rbts::archive_save<T, MemoryPolicy, B, BL>;
     using load_archive_t = rbts::archive_load<T>;
-    using loader_t       = rbts::vector_loader<T, MemoryPolicy, B, BL>;
     using container_id   = immer::archive::container_id;
 
+    template <typename Archive    = load_archive_t,
+              typename TransformF = boost::hana::id_t>
+    using loader_t =
+        rbts::vector_loader<T, MemoryPolicy, B, BL, Archive, TransformF>;
+
     // This function is used to determine the type of the container after
     // applying some transformation.
     template <class F>
@@ -35,9 +39,12 @@ struct container_traits<immer::flex_vector<T, MemoryPolicy, B, BL>>
 {
     using save_archive_t = rbts::archive_save<T, MemoryPolicy, B, BL>;
     using load_archive_t = rbts::archive_load<T>;
-    using loader_t       = rbts::flex_vector_loader<T, MemoryPolicy, B, BL>;
     using container_id   = immer::archive::container_id;
 
+    template <typename Archive    = load_archive_t,
+              typename TransformF = boost::hana::id_t>
+    using loader_t = rbts::flex_vector_loader<T, MemoryPolicy, B, BL>;
+
     template <class F>
     static auto transform(F&& func)
     {
diff --git a/test/extra/archive/test_circular_dependency_conversion.cpp b/test/extra/archive/test_circular_dependency_conversion.cpp
index 0034ee44..682e5a84 100644
--- a/test/extra/archive/test_circular_dependency_conversion.cpp
+++ b/test/extra/archive/test_circular_dependency_conversion.cpp
@@ -4,6 +4,8 @@
 
 #include "utils.hpp"
 
+#include <immer/extra/archive/cereal/immer_box.hpp>
+
 #define DEFINE_OPERATIONS(name)                                                \
     bool operator==(const name& left, const name& right)                       \
     {                                                                          \
@@ -32,8 +34,9 @@ struct two_boxed
 {
     BOOST_HANA_DEFINE_STRUCT(two_boxed, (immer::box<value_two>, two));
 
-    two_boxed() = default;
-    two_boxed(value_two val);
+    two_boxed()                 = default;
+    two_boxed(const two_boxed&) = default;
+    explicit two_boxed(value_two val);
 };
 
 struct value_one
@@ -47,6 +50,7 @@ struct value_one
 
 struct value_two
 {
+    int number = {};
     vector_one<value_one> ones;
 };
 
@@ -57,7 +61,7 @@ two_boxed::two_boxed(value_two val)
 
 } // namespace model
 
-BOOST_HANA_ADAPT_STRUCT(model::value_two, ones);
+BOOST_HANA_ADAPT_STRUCT(model::value_two, number, ones);
 
 namespace model {
 DEFINE_OPERATIONS(two_boxed);
@@ -73,8 +77,9 @@ struct two_boxed
 {
     BOOST_HANA_DEFINE_STRUCT(two_boxed, (immer::box<value_two>, two));
 
-    two_boxed() = default;
-    two_boxed(value_two val);
+    two_boxed()                 = default;
+    two_boxed(const two_boxed&) = default;
+    explicit two_boxed(immer::box<value_two> two_);
 };
 
 struct value_one
@@ -88,17 +93,18 @@ struct value_one
 
 struct value_two
 {
+    int number = {};
     vector_one<value_one> ones;
 };
 
-two_boxed::two_boxed(value_two val)
-    : two{val}
+two_boxed::two_boxed(immer::box<value_two> two_)
+    : two{std::move(two_)}
 {
 }
 
 } // namespace format
 
-BOOST_HANA_ADAPT_STRUCT(format::value_two, ones);
+BOOST_HANA_ADAPT_STRUCT(format::value_two, number, ones);
 
 namespace format {
 DEFINE_OPERATIONS(two_boxed);
@@ -106,10 +112,13 @@ DEFINE_OPERATIONS(value_one);
 DEFINE_OPERATIONS(value_two);
 } // namespace format
 
-TEST_CASE("Test circular dependency archives", "[.broken]")
+TEST_CASE("Test circular dependency archives")
 {
-    const auto two1  = model::two_boxed{};
+    const auto two1  = model::two_boxed{model::value_two{
+         .number = 456,
+    }};
     const auto two2  = model::two_boxed{model::value_two{
+         .number = 123,
          .ones =
              {
                 model::value_one{
@@ -123,9 +132,7 @@ TEST_CASE("Test circular dependency archives", "[.broken]")
 
     const auto names = immer::archive::get_archives_for_types(
         hana::tuple_t<model::value_one, model::value_two, model::two_boxed>,
-        hana::make_map(
-
-            ));
+        hana::make_map());
     const auto [json_str, model_archives] =
         immer::archive::to_json_with_auto_archive(value, names);
     // REQUIRE(json_str == "");
@@ -139,8 +146,9 @@ TEST_CASE("Test circular dependency archives", "[.broken]")
             hana::type_c<vector_one<model::two_boxed>>,
             [](model::two_boxed old, const auto& convert_container) {
                 SPDLOG_INFO("converting model::two_boxed");
-                return format::two_boxed{convert_container(
-                    hana::type_c<immer::box<format::value_two>>, old.two)};
+                const auto new_box = convert_container(
+                    hana::type_c<immer::box<format::value_two>>, old.two);
+                return format::two_boxed{new_box};
             }),
         hana::make_pair(
             hana::type_c<immer::box<model::value_two>>,
@@ -148,7 +156,10 @@ TEST_CASE("Test circular dependency archives", "[.broken]")
                 SPDLOG_INFO("converting model::value_two");
                 auto ones = convert_container(
                     hana::type_c<vector_one<format::value_one>>, old.ones);
-                return format::value_two{ones};
+                return format::value_two{
+                    .number = old.number,
+                    .ones   = ones,
+                };
             }),
         hana::make_pair(
             hana::type_c<vector_one<model::value_one>>,
@@ -160,7 +171,40 @@ TEST_CASE("Test circular dependency archives", "[.broken]")
             })
 
     );
-    const auto format_load_archives =
+    auto format_load_archives =
         immer::archive::transform_save_archive(model_archives, map);
     (void) format_load_archives;
+
+    const auto format_twos = immer::archive::convert_container(
+        model_archives, format_load_archives, value.twos);
+
+    SECTION("Same thing twice, same result")
+    {
+        const auto format_twos_2 = immer::archive::convert_container(
+            model_archives, format_load_archives, value.twos);
+        REQUIRE(format_twos.identity() == format_twos_2.identity());
+    }
+
+    // Confirm there is internal sharing happening
+    REQUIRE(value.twos[0].two == value.twos[1].two.get().ones[0].twos[0].two);
+    REQUIRE(value.twos[0].two.impl() ==
+            value.twos[1].two.get().ones[0].twos[0].two.impl());
+
+    REQUIRE(value.twos[0].two.get().number == format_twos[0].two.get().number);
+
+    REQUIRE(format_twos[0].two == format_twos[1].two.get().ones[0].twos[0].two);
+    REQUIRE(format_twos[0].two.impl() ==
+            format_twos[1].two.get().ones[0].twos[0].two.impl());
+
+    {
+        const auto format_names = immer::archive::get_archives_for_types(
+            hana::tuple_t<format::value_one,
+                          format::value_two,
+                          format::two_boxed>,
+            hana::make_map());
+        const auto [loaded_json_str, model_archives] =
+            immer::archive::to_json_with_auto_archive(format_twos,
+                                                      format_names);
+        REQUIRE(test::to_json(value.twos) == test::to_json(format_twos));
+    }
 }