diff --git a/control/json/actions/net_target_decrease.cpp b/control/json/actions/net_target_decrease.cpp
new file mode 100644
index 0000000..4664238
--- /dev/null
+++ b/control/json/actions/net_target_decrease.cpp
@@ -0,0 +1,151 @@
+/**
+ * Copyright © 2021 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "net_target_decrease.hpp"
+
+#include "../manager.hpp"
+#include "../zone.hpp"
+#include "action.hpp"
+#include "group.hpp"
+
+#include <fmt/format.h>
+
+#include <nlohmann/json.hpp>
+#include <phosphor-logging/log.hpp>
+
+#include <algorithm>
+#include <variant>
+
+namespace phosphor::fan::control::json
+{
+
+using json = nlohmann::json;
+using namespace phosphor::logging;
+
+NetTargetDecrease::NetTargetDecrease(const json& jsonObj) : ActionBase(jsonObj)
+{
+    setState(jsonObj);
+    setDelta(jsonObj);
+}
+
+void NetTargetDecrease::run(Zone& zone, const Group& group)
+{
+    auto netDelta = zone.getDecDelta();
+    for (const auto& member : group.getMembers())
+    {
+        try
+        {
+            auto value = Manager::getObjValueVariant(
+                member, group.getInterface(), group.getProperty());
+            if (std::holds_alternative<int64_t>(value) ||
+                std::holds_alternative<double>(value))
+            {
+                if (value >= _state)
+                {
+                    // No decrease allowed for this group
+                    netDelta = 0;
+                    break;
+                }
+                else
+                {
+                    // Decrease factor is the difference in configured state to
+                    // the current value's state
+                    uint64_t deltaFactor = 0;
+                    if (auto dblPtr = std::get_if<double>(&value))
+                    {
+                        deltaFactor = static_cast<uint64_t>(
+                            std::get<double>(_state) - *dblPtr);
+                    }
+                    else
+                    {
+                        deltaFactor =
+                            static_cast<uint64_t>(std::get<int64_t>(_state) -
+                                                  std::get<int64_t>(value));
+                    }
+
+                    // Multiply the decrease factor by the configured delta to
+                    // get the net decrease delta for the given group member.
+                    // The lowest net decrease delta of the entire group is the
+                    // decrease requested.
+                    if (netDelta == 0)
+                    {
+                        netDelta = deltaFactor * _delta;
+                    }
+                    else
+                    {
+                        netDelta = std::min(netDelta, deltaFactor * _delta);
+                    }
+                }
+            }
+            else if (std::holds_alternative<bool>(value) ||
+                     std::holds_alternative<std::string>(value))
+            {
+                // Where a group of booleans or strings equal the state
+                // provided, request a decrease of the configured delta
+                if (_state == value)
+                {
+                    if (netDelta == 0)
+                    {
+                        netDelta = _delta;
+                    }
+                    else
+                    {
+                        netDelta = std::min(netDelta, _delta);
+                    }
+                }
+            }
+            else
+            {
+                // Unsupported group member type for this action
+                log<level::ERR>(
+                    fmt::format("Action {}: Unsupported group member type "
+                                "given. [object = {} : {} : {}]",
+                                ActionBase::getName(), member,
+                                group.getInterface(), group.getProperty())
+                        .c_str());
+            }
+        }
+        catch (const std::out_of_range& oore)
+        {
+            // Property value not found, netDelta unchanged
+        }
+    }
+    // Update group's decrease allowed state
+    zone.setDecreaseAllow(group.getName(), !(netDelta == 0));
+    // Request target decrease to occur on decrease interval
+    zone.requestDecrease(netDelta);
+}
+
+void NetTargetDecrease::setState(const json& jsonObj)
+{
+    if (!jsonObj.contains("state"))
+    {
+        throw ActionParseError{ActionBase::getName(),
+                               "Missing required state value"};
+    }
+    _state = getJsonValue(jsonObj["state"]);
+}
+
+void NetTargetDecrease::setDelta(const json& jsonObj)
+{
+    if (!jsonObj.contains("delta"))
+    {
+        throw ActionParseError{ActionBase::getName(),
+                               "Missing required delta value"};
+    }
+    _delta = jsonObj["delta"].get<uint64_t>();
+}
+
+} // namespace phosphor::fan::control::json
diff --git a/control/json/actions/net_target_decrease.hpp b/control/json/actions/net_target_decrease.hpp
new file mode 100644
index 0000000..cc09705
--- /dev/null
+++ b/control/json/actions/net_target_decrease.hpp
@@ -0,0 +1,108 @@
+/**
+ * Copyright © 2021 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include "../zone.hpp"
+#include "action.hpp"
+#include "group.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <optional>
+
+namespace phosphor::fan::control::json
+{
+
+using json = nlohmann::json;
+
+/**
+ * @class NetTargetDecrease - Action to determine the net target decrease to
+ * request
+ *
+ * Calculates the net target decrease to be requested based on the value of each
+ * property given within a group. The net target decrease is the minimum delta
+ * determined from all of the properties of the group. This net target decrease
+ * is the decrease change that's requested to the current target of a zone.
+ */
+class NetTargetDecrease :
+    public ActionBase,
+    public ActionRegister<NetTargetDecrease>
+{
+  public:
+    /* Name of this action */
+    static constexpr auto name = "set_net_decrease_speed";
+
+    NetTargetDecrease() = delete;
+    NetTargetDecrease(const NetTargetDecrease&) = delete;
+    NetTargetDecrease(NetTargetDecrease&&) = delete;
+    NetTargetDecrease& operator=(const NetTargetDecrease&) = delete;
+    NetTargetDecrease& operator=(NetTargetDecrease&&) = delete;
+    ~NetTargetDecrease() = default;
+
+    /**
+     * @brief Determine/Set the net target decrease
+     *
+     * @param[in] jsonObj - JSON configuration of this action
+     */
+    explicit NetTargetDecrease(const json& jsonObj);
+
+    /**
+     * @brief Run the action
+     *
+     * Determines the net target decrease delta to be requested based on the
+     * property values of the group of dbus objects and requests this target
+     * decrease on the zone. The property values of the group is compared to
+     * the configured state value to determine if an decrease delta should be
+     * requested. For boolean & string values, the configured delta is
+     * requested when a property of the group equals the configured state. For
+     * integer & double values, the configured delta is multiplied by the
+     * difference in property value and the configured state resulting in a net
+     * target decrease for each group member. After all members of the group of
+     * dbus objects are processed, the minimum net target decrease calculated is
+     * requested on the zone.
+     *
+     * @param[in] zone - Zone to run the action on
+     * @param[in] group - Group of dbus objects the action runs against
+     */
+    void run(Zone& zone, const Group& group) override;
+
+  private:
+    /* State the members must be at to decrease the target */
+    PropertyVariantType _state;
+
+    /* Decrease delta for this action */
+    uint64_t _delta;
+
+    /**
+     * @brief Parse and set the state
+     *
+     * @param[in] jsonObj - JSON object for the action
+     *
+     * Sets the state to compare members to
+     */
+    void setState(const json& jsonObj);
+
+    /**
+     * @brief Parse and set the delta
+     *
+     * @param[in] jsonObj - JSON object for the action
+     *
+     * Sets the decrease delta to use when running the action
+     */
+    void setDelta(const json& jsonObj);
+};
+
+} // namespace phosphor::fan::control::json