diff --git a/http/http_client.hpp b/http/http_client.hpp
index 905700e..491030c 100644
--- a/http/http_client.hpp
+++ b/http/http_client.hpp
@@ -462,6 +462,12 @@
     void sendNext(bool keepAlive, uint32_t connId)
     {
         auto conn = connections[connId];
+
+        // Allow the connection's handler to be deleted
+        // This is needed because of Redfish Aggregation passing an
+        // AsyncResponse shared_ptr to this callback
+        conn->callback = nullptr;
+
         // Reuse the connection to send the next request in the queue
         if (!requestQueue.empty())
         {
diff --git a/http/http_response.hpp b/http/http_response.hpp
index 38bebb5..dd1f37a 100644
--- a/http/http_response.hpp
+++ b/http/http_response.hpp
@@ -122,6 +122,11 @@
         return stringResponse->body();
     }
 
+    std::string_view getHeaderValue(std::string_view key) const
+    {
+        return stringResponse->base()[key];
+    }
+
     void keepAlive(bool k)
     {
         stringResponse->keep_alive(k);
diff --git a/redfish-core/include/redfish_aggregator.hpp b/redfish-core/include/redfish_aggregator.hpp
index 0a5ff57..e0e3521 100644
--- a/redfish-core/include/redfish_aggregator.hpp
+++ b/redfish-core/include/redfish_aggregator.hpp
@@ -1,6 +1,9 @@
 #pragma once
 
+#include <dbus_utility.hpp>
+#include <error_messages.hpp>
 #include <http_client.hpp>
+#include <http_connection.hpp>
 
 namespace redfish
 {
@@ -11,27 +14,13 @@
     NoLocalHandle
 };
 
-// Checks if the provided path is related to one of the resource collections
-// under UpdateService
-static inline bool
-    isUpdateServiceCollection(const std::vector<std::string>& segments)
-{
-    if (segments.size() < 4)
-    {
-        return false;
-    }
-
-    return (segments[2] == "UpdateService") &&
-           ((segments[3] == "FirmwareInventory") ||
-            (segments[3] == "SoftwareInventory"));
-}
-
 class RedfishAggregator
 {
   private:
     const std::string retryPolicyName = "RedfishAggregation";
     const uint32_t retryAttempts = 5;
     const uint32_t retryTimeoutInterval = 0;
+    const std::string id = "Aggregator";
 
     RedfishAggregator()
     {
@@ -243,6 +232,203 @@
                          << result.first->second.encoded_host_and_port();
     }
 
+    enum AggregationType
+    {
+        Collection,
+        Resource,
+    };
+
+    static void
+        startAggregation(AggregationType isCollection,
+                         const crow::Request& thisReq,
+                         const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
+    {
+        // Create a copy of thisReq so we we can still locally process the req
+        std::error_code ec;
+        auto localReq = std::make_shared<crow::Request>(thisReq.req, ec);
+        if (ec)
+        {
+            BMCWEB_LOG_ERROR << "Failed to create copy of request";
+            if (isCollection != AggregationType::Collection)
+            {
+                messages::internalError(asyncResp->res);
+            }
+            return;
+        }
+
+        getSatelliteConfigs(std::bind_front(aggregateAndHandle, isCollection,
+                                            localReq, asyncResp));
+    }
+
+    static void findSatelite(
+        const crow::Request& req,
+        const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+        const std::unordered_map<std::string, boost::urls::url>& satelliteInfo,
+        std::string_view memberName)
+    {
+        // Determine if the resource ID begins with a known prefix
+        for (const auto& satellite : satelliteInfo)
+        {
+            std::string targetPrefix = satellite.first;
+            targetPrefix += "_";
+            if (memberName.starts_with(targetPrefix))
+            {
+                BMCWEB_LOG_DEBUG << "\"" << satellite.first
+                                 << "\" is a known prefix";
+
+                // Remove the known prefix from the request's URI and
+                // then forward to the associated satellite BMC
+                getInstance().forwardRequest(req, asyncResp, satellite.first,
+                                             satelliteInfo);
+                return;
+            }
+        }
+    }
+
+    // Intended to handle an incoming request based on if Redfish Aggregation
+    // is enabled.  Forwards request to satellite BMC if it exists.
+    static void aggregateAndHandle(
+        AggregationType isCollection,
+        const std::shared_ptr<crow::Request>& sharedReq,
+        const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+        const std::unordered_map<std::string, boost::urls::url>& satelliteInfo)
+    {
+        if (sharedReq == nullptr)
+        {
+            return;
+        }
+        const crow::Request& thisReq = *sharedReq;
+        BMCWEB_LOG_DEBUG << "Aggregation is enabled, begin processing of "
+                         << thisReq.target();
+
+        // We previously determined the request is for a collection.  No need to
+        // check again
+        if (isCollection == AggregationType::Collection)
+        {
+            // TODO: This should instead be handled so that we can
+            // aggregate the satellite resource collections
+            BMCWEB_LOG_DEBUG << "Aggregating a collection";
+            return;
+        }
+
+        std::string updateServiceName;
+        std::string memberName;
+        if (crow::utility::readUrlSegments(
+                thisReq.urlView, "redfish", "v1", "UpdateService",
+                std::ref(updateServiceName), std::ref(memberName),
+                crow::utility::OrMorePaths()))
+        {
+            // Must be FirmwareInventory or SoftwareInventory
+            findSatelite(thisReq, asyncResp, satelliteInfo, memberName);
+            return;
+        }
+
+        std::string collectionName;
+        if (crow::utility::readUrlSegments(
+                thisReq.urlView, "redfish", "v1", std::ref(collectionName),
+                std::ref(memberName), crow::utility::OrMorePaths()))
+        {
+            findSatelite(thisReq, asyncResp, satelliteInfo, memberName);
+        }
+    }
+
+    // Attempt to forward a request to the satellite BMC associated with the
+    // prefix.
+    void forwardRequest(
+        const crow::Request& thisReq,
+        const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+        const std::string& prefix,
+        const std::unordered_map<std::string, boost::urls::url>& satelliteInfo)
+    {
+        const auto& sat = satelliteInfo.find(prefix);
+        if (sat == satelliteInfo.end())
+        {
+            // Realistically this shouldn't get called since we perform an
+            // earlier check to make sure the prefix exists
+            BMCWEB_LOG_ERROR << "Unrecognized satellite prefix \"" << prefix
+                             << "\"";
+            return;
+        }
+
+        // We need to strip the prefix from the request's path
+        std::string targetURI(thisReq.target());
+        size_t pos = targetURI.find(prefix + "_");
+        if (pos == std::string::npos)
+        {
+            // If this fails then something went wrong
+            BMCWEB_LOG_ERROR << "Error removing prefix \"" << prefix
+                             << "_\" from request URI";
+            messages::internalError(asyncResp->res);
+            return;
+        }
+        targetURI.erase(pos, prefix.size() + 1);
+
+        std::function<void(crow::Response&)> cb =
+            std::bind_front(processResponse, asyncResp);
+
+        std::string data = thisReq.req.body();
+        crow::HttpClient::getInstance().sendDataWithCallback(
+            data, id, std::string(sat->second.host()),
+            sat->second.port_number(), targetURI, thisReq.fields,
+            thisReq.method(), retryPolicyName, cb);
+    }
+
+    // Processes the response returned by a satellite BMC and loads its
+    // contents into asyncResp
+    static void
+        processResponse(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
+                        crow::Response& resp)
+    {
+        // No processing needed if the request wasn't successful
+        if (resp.resultInt() != 200)
+        {
+            BMCWEB_LOG_DEBUG << "No need to parse satellite response";
+            asyncResp->res.stringResponse = std::move(resp.stringResponse);
+            return;
+        }
+
+        // The resp will not have a json component
+        // We need to create a json from resp's stringResponse
+        if (resp.getHeaderValue("Content-Type") == "application/json")
+        {
+            nlohmann::json jsonVal =
+                nlohmann::json::parse(resp.body(), nullptr, false);
+            if (jsonVal.is_discarded())
+            {
+                BMCWEB_LOG_ERROR << "Error parsing satellite response as JSON";
+                messages::operationFailed(asyncResp->res);
+                return;
+            }
+
+            BMCWEB_LOG_DEBUG << "Successfully parsed satellite response";
+
+            // TODO: For collections we  want to add the satellite responses to
+            // our response rather than just straight overwriting them if our
+            // local handling was successful (i.e. would return a 200).
+
+            asyncResp->res.stringResponse.emplace(
+                boost::beast::http::response<
+                    boost::beast::http::string_body>{});
+            asyncResp->res.result(resp.result());
+            asyncResp->res.jsonValue = std::move(jsonVal);
+
+            BMCWEB_LOG_DEBUG << "Finished writing asyncResp";
+            // TODO: Need to fix the URIs in the response so that they include
+            // the prefix
+        }
+        else
+        {
+            if (!resp.body().empty())
+            {
+                // We received a 200 response without the correct Content-Type
+                // so return an Operation Failed error
+                BMCWEB_LOG_ERROR
+                    << "Satellite response must be of type \"application/json\"";
+                messages::operationFailed(asyncResp->res);
+            }
+        }
+    }
+
   public:
     RedfishAggregator(const RedfishAggregator&) = delete;
     RedfishAggregator& operator=(const RedfishAggregator&) = delete;
@@ -271,6 +457,14 @@
         {
             return Result::LocalHandle;
         }
+        if (readUrlSegments(url, "redfish", "v1", "UpdateService",
+                            "SoftwareInventory") ||
+            readUrlSegments(url, "redfish", "v1", "UpdateService",
+                            "FirmwareInventory"))
+        {
+            startAggregation(AggregationType::Collection, thisReq, asyncResp);
+            return Result::LocalHandle;
+        }
 
         // Is the request for a resource collection?:
         // /redfish/v1/<resource>
@@ -278,6 +472,7 @@
         std::string collectionName;
         if (readUrlSegments(url, "redfish", "v1", std::ref(collectionName)))
         {
+            startAggregation(AggregationType::Collection, thisReq, asyncResp);
             return Result::LocalHandle;
         }
 
@@ -302,10 +497,10 @@
             {
                 BMCWEB_LOG_DEBUG << "Need to forward a request";
 
-                // TODO: Extract the prefix from the request's URI, retrieve
-                // the associated satellite config information, and then
-                // forward the request to that satellite.
-                redfish::messages::internalError(asyncResp->res);
+                // Extract the prefix from the request's URI, retrieve the
+                // associated satellite config information, and then forward the
+                // request to that satellite.
+                startAggregation(AggregationType::Resource, thisReq, asyncResp);
                 return Result::NoLocalHandle;
             }
             return Result::LocalHandle;