@@ -1696,14 +1696,17 @@ def build_entities(domain, candidates):
         # The percentage rate registers only win as the control when the direct power register is
         # absent. When both a power register and its percentage equivalent exist, the power register
         # is the primary control and the percentage is left at 100% (reset by enable_default_options).
-        if has_charge_power_percent and not has_charge_rate:
-            self.set_arg("charge_rate_percent", build_entities("number", ["inverter_charge_power_percentage", "charge_power_rate"]))
-        else:
-            self.set_arg("charge_rate_percent", None)
-        if has_discharge_power_percent and not has_discharge_rate:
-            self.set_arg("discharge_rate_percent", build_entities("number", ["inverter_discharge_power_percentage", "discharge_power_rate"]))
-        else:
-            self.set_arg("discharge_rate_percent", None)
+        # Decided for each device on its own registers: a fleet can mix a unit with a power register
+        # and a 3-phase one with only the percentage, and each then gets the control it has (#5359).
+        def build_percent_entities(power_register, candidates):
+            """Per-device percentage rate entity IDs for the devices with no power register, or None if none qualify."""
+            entities = [None if power_register in register_names_by_device.get(device, set()) else first_existing_entity("number", device, candidates) for device in batteries]
+            if all(entity is None for entity in entities):
+                return None
+            return entities
+
+        self.set_arg("charge_rate_percent", build_percent_entities("battery_charge_power", ["inverter_charge_power_percentage", "charge_power_rate"]))
+        self.set_arg("discharge_rate_percent", build_percent_entities("battery_discharge_power", ["inverter_discharge_power_percentage", "discharge_power_rate"]))
 
         self.set_arg("givtcp_rest", None)
 
@@ -1800,9 +1803,10 @@ def _register_features(self, device):
         The register features async_automatic_config() sniffs for, as this one device reports them.
 
         The same substrings as its sniffing loop, but scoped to this device's own settings rather
-        than ORed across the fleet: automatic_config() gates pause_mode, pause_start_time/end_time,
-        discharge_target_soc and the percentage rate controls for every device on what ANY device
-        reports, while a discovery record describes only its own device (spec D10).
+        than ORed across the fleet: automatic_config() gates pause_mode, pause_start_time/end_time
+        and discharge_target_soc for every device on what ANY device reports, while a discovery
+        record describes only its own device (spec D10). The percentage rate controls are bound
+        per device by both (#5359).
         """
         features = {"charge_rate": False, "discharge_rate": False, "charge_power_percent": False, "discharge_power_percent": False, "pause_start_time": False, "discharge_target_soc": False, "pause_battery": False}
         for register in self.settings.get(device, {}).values():
 
@@ -2120,12 +2120,30 @@ def adjust_reserve(self, reserve):
         else:
             self.base.log("Inverter {} Current reserve is {}%, already at target".format(self.id, dp0(current_reserve)))
 
+    def rate_controls(self, rate_arg):
+        """
+        Which of a rate's two controls this inverter uses: (watts, percent) for "charge_rate" or "discharge_rate".
+
+        Asked of this inverter's own entry rather than of whether the setting exists at all: a fleet can mix
+        inverters with a power register and ones with only the percentage (GivEnergy 3-phase), leaving each
+        setting bound for some inverters and empty for the rest (#5359). An inverter bound to neither keeps
+        the answer the setting's presence used to give, so a missing entity is still reported when written.
+        """
+        percent_arg = rate_arg + "_percent"
+        has_watts = rate_arg in self.base.args
+        has_percent = percent_arg in self.base.args
+        bound_watts = bool(has_watts and self.base.get_arg(rate_arg, indirect=False, index=self.id))
+        bound_percent = bool(has_percent and self.base.get_arg(percent_arg, indirect=False, index=self.id))
+        if bound_watts != bound_percent:
+            return bound_watts, bound_percent
+        return has_watts, has_percent
+
     def get_current_discharge_rate(self):
         """
         Get the current discharge rate in watts
         """
 
-        if "discharge_rate_percent" in self.base.args:
+        if self.rate_controls("discharge_rate")[1]:
             current_rate = int(self.base.get_arg("discharge_rate_percent", index=self.id, default=100.0, required_unit="%") * self.battery_rate_max_raw / 100)
         else:
             current_rate = self.base.get_arg("discharge_rate", index=self.id, default=self.battery_rate_max_raw, required_unit="W")
@@ -2142,7 +2160,7 @@ def get_current_charge_rate(self):
         """
         Get the current charge rate in watts
         """
-        if "charge_rate_percent" in self.base.args:
+        if self.rate_controls("charge_rate")[1]:
             current_rate = self.base.get_arg("charge_rate_percent", index=self.id, default=100.0, required_unit="%") * self.battery_rate_max_raw / 100
         else:
             current_rate = self.base.get_arg("charge_rate", index=self.id, default=self.battery_rate_max_raw, required_unit="W")
@@ -2205,7 +2223,8 @@ def adjust_charge_rate(self, new_rate, notify=True):
         fuzzy, fuzzy_below = self.rate_tolerances(self.battery_rate_max_charge)
         if not within_fuzzy(current_rate, new_rate, fuzzy, fuzzy_below):
             self.base.log("Inverter {} current charge rate is {}W and new target is {}W".format(self.id, current_rate, new_rate))
-            if "charge_rate" in self.base.args:
+            write_watts, write_percent = self.rate_controls("charge_rate")
+            if write_watts:
                 self.write_and_poll_value(
                     "charge_rate",
                     self.base.get_arg("charge_rate", indirect=False, index=self.id, required_unit="W"),
@@ -2214,7 +2233,7 @@ def adjust_charge_rate(self, new_rate, notify=True):
                     required_unit="W",
                     fuzzy_below=fuzzy_below,
                 )
-            if "charge_rate_percent" in self.base.args:
+            if write_percent:
                 self.write_and_poll_value("charge_rate_percent", self.base.get_arg("charge_rate_percent", indirect=False, index=self.id, required_unit="%"), min(int(new_rate / self.battery_rate_max_raw * 100), 100), fuzzy=5, required_unit="%")
 
             if notify and self.base.set_inverter_notify:
@@ -2254,7 +2273,8 @@ def adjust_discharge_rate(self, new_rate, notify=True):
         fuzzy, fuzzy_below = self.rate_tolerances(self.battery_rate_max_discharge)
         if not within_fuzzy(current_rate, new_rate, fuzzy, fuzzy_below):
             self.base.log("Inverter {} current discharge rate is {}W and new target is {}W".format(self.id, current_rate, new_rate))
-            if "discharge_rate" in self.base.args:
+            write_watts, write_percent = self.rate_controls("discharge_rate")
+            if write_watts:
                 self.write_and_poll_value(
                     "discharge_rate",
                     self.base.get_arg("discharge_rate", indirect=False, index=self.id),
@@ -2263,7 +2283,7 @@ def adjust_discharge_rate(self, new_rate, notify=True):
                     required_unit="W",
                     fuzzy_below=fuzzy_below,
                 )
-            if "discharge_rate_percent" in self.base.args:
+            if write_percent:
                 self.write_and_poll_value("discharge_rate_percent", self.base.get_arg("discharge_rate_percent", indirect=False, index=self.id, required_unit="%"), min(int(new_rate / self.battery_rate_max_raw * 100), 100), fuzzy=5, required_unit="%")
 
             if notify and self.base.set_inverter_notify:
 
@@ -6095,8 +6095,9 @@ def _test_discovery_record_two_devices(my_predbat):
     """
     Two inverters give two records whose entity ids differ by device, each describing its own device
     (spec D10). automatic_config()'s "any device has it" gate binds the pause and discharge-target
-    entities on the second device although it has no such registers, and withholds its percentage
-    rate controls because the first device has a power register; the record does neither.
+    entities on the second device although it has no such registers; the record does not. The
+    percentage rate controls are bound per device by both: the second device has no power register,
+    so it gets its percentage rate while the first keeps its power register (#5359).
     """
     devices = {"ems": None, "gateway": None, "battery": ["battery001", "battery002"], "pv": [], "battery_meters": {"battery001": [1001], "battery002": [1002]}}
     settings = {
@@ -6115,9 +6116,11 @@ def _test_discovery_record_two_devices(my_predbat):
     assert not (_entity_ids(records[0]) & _entity_ids(records[1])), "the two records must not share an entity"
     captured = capture_automatic_config(ge)
     _agree_at(records[0], captured, 0)
-    _agree_at(records[1], captured, 1, missing=("pause_mode", "pause_start_time", "pause_end_time", "discharge_target_soc"), allowed_extra=("charge_rate_percent", "discharge_rate_percent"))
+    _agree_at(records[1], captured, 1, missing=("pause_mode", "pause_start_time", "pause_end_time", "discharge_target_soc"))
     assert captured["pause_mode"][1] == "select.predbat_gecloud_battery002_pause_battery", "automatic_config's fleet gate binds pause on the second device"
-    assert captured["charge_rate_percent"] is None, "automatic_config's fleet gate withholds the percentage rates"
+    assert captured["charge_rate_percent"] == [None, "number.predbat_gecloud_battery002_inverter_charge_power_percentage"], "the percentage charge rate is bound for the device with no power register only"
+    assert captured["discharge_rate_percent"] == [None, "number.predbat_gecloud_battery002_inverter_discharge_power_percentage"], "the percentage discharge rate likewise"
+    assert captured["charge_rate"][1] is None and captured["charge_rate"][0] is not None, "the power register is bound for the device that has it only"
     second = records[1]["entities"]
     assert second["reserve"]["entity_id"] == "number.predbat_gecloud_battery002_battery_reserve_percent", "the per-device candidate choice"
     assert second["scheduled_charge_enable"]["entity_id"] == "switch.predbat_gecloud_battery002_enable_ac_charge"
 
@@ -1109,6 +1109,71 @@ def test_custom_inverter_def_drops_rate_step(test_name, my_predbat, ha):
     return failed
 
 
+def test_rate_control_is_per_inverter(test_name, my_predbat, ha):
+    """
+    An inverter reads and writes its rate through the control its own entry is bound to, whichever settings exist
+    for the fleet: a GE Cloud fleet mixing a unit with a power register and a 3-phase one with only the percentage
+    binds each setting for one inverter and leaves it empty for the other (#5359). It also means the 3-phase unit's
+    percentage entity is bound, so its grid_charge_only mark is seen in a mixed fleet (#5082).
+
+    Building an Inverter writes args and publishes entities on the shared fixture, so both are restored whole (#5079).
+    """
+    failed = False
+    print("Test: {}".format(test_name))
+    saved_args = copy.deepcopy(my_predbat.args)
+    saved_items = copy.deepcopy(ha.dummy_items)
+    try:
+        my_predbat.args["inverter_type"] = ["GEC"]
+        # this inverter's entry in each setting, the rate it should read, the entities a new rate is written to
+        for watts_entity, percent_entity, expect_read, expect_writes in (
+            ("number.rate_watts", None, 1500, ["number.rate_watts"]),
+            (None, "number.rate_percent", 1300, ["number.rate_percent"]),
+            ("number.rate_watts", "number.rate_percent", 1300, ["number.rate_watts", "number.rate_percent"]),
+        ):
+            for rate_arg, read_rate, adjust_rate in (("charge_rate", "get_current_charge_rate", "adjust_charge_rate"), ("discharge_rate", "get_current_discharge_rate", "adjust_discharge_rate")):
+                for name in ("charge_rate", "charge_rate_percent", "discharge_rate", "discharge_rate_percent"):
+                    my_predbat.args.pop(name, None)
+                # Both settings exist for the fleet; only this inverter's entries differ
+                my_predbat.args[rate_arg] = [watts_entity]
+                my_predbat.args[rate_arg + "_percent"] = [percent_entity]
+                ha.dummy_items["number.rate_watts"] = 1500
+                ha.dummy_items["number.rate_percent"] = {"state": 50, "unit_of_measurement": "%", "grid_charge_only": True}
+                inv = Inverter(my_predbat, 0, quiet=True)
+                inv.battery_rate_max_raw = 2600
+                inv.battery_rate_max_charge = inv.battery_rate_max_discharge = 2600 / MINUTE_WATT
+                got = getattr(inv, read_rate)()
+                if got != expect_read:
+                    print("ERROR: {} {} watts {} percent {} expected to read {} got {}".format(test_name, rate_arg, watts_entity, percent_entity, expect_read, got))
+                    failed = True
+                written = []
+                call_service = ha.call_service
+
+                def recording_call_service(service, **kwargs):
+                    """Record which entity a rate write went to."""
+                    if service == "number/set_value":
+                        written.append(kwargs.get("entity_id"))
+                    return call_service(service, **kwargs)
+
+                ha.call_service = recording_call_service
+                try:
+                    getattr(inv, adjust_rate)(0)
+                finally:
+                    ha.call_service = call_service
+                if sorted(set(written)) != sorted(expect_writes):
+                    print("ERROR: {} {} watts {} percent {} expected writes to {} got {}".format(test_name, rate_arg, watts_entity, percent_entity, expect_writes, written))
+                    failed = True
+                # The mark on the percentage charge rate is seen whenever this inverter is bound to it
+                if rate_arg == "charge_rate" and inv.inv_support_discharge_freeze is not (percent_entity is None):
+                    print("ERROR: {} watts {} percent {} Freeze Export support is {}".format(test_name, watts_entity, percent_entity, inv.inv_support_discharge_freeze))
+                    failed = True
+    finally:
+        my_predbat.args.clear()
+        my_predbat.args.update(saved_args)
+        ha.dummy_items.clear()
+        ha.dummy_items.update(saved_items)
+    return failed
+
+
 def test_grid_charge_only_disables_discharge_freeze(test_name, my_predbat, ha):
     """
     A charge rate entity marked grid_charge_only turns Freeze Export support off for that inverter: the GivEnergy
@@ -5538,6 +5603,7 @@ def run_inverter_tests(my_predbat_dummy):
     failed |= test_custom_inverter_def_drops_rate_step("custom_inverter_def_drops_rate_step", my_predbat, ha)
     failed |= test_rate_step_from_charge_rate_entity("rate_step_from_charge_rate_entity", my_predbat, ha)
     failed |= test_grid_charge_only_disables_discharge_freeze("grid_charge_only_disables_discharge_freeze", my_predbat, ha)
+    failed |= test_rate_control_is_per_inverter("rate_control_is_per_inverter", my_predbat, ha)
     failed |= test_rate_write_quantised("rate_write_quantised_charge", ha, inv, 2600, 1300, 1, 1206)
     failed |= test_rate_write_quantised("rate_write_quantised_charge_settled", ha, inv, 1206, 1300, 0, 1206)
     failed |= test_rate_write_quantised("rate_write_quantised_charge_next_step", ha, inv, 1206, 1350, 1, 1341)
 
@@ -173,9 +173,11 @@ This is being worked on by the author of GivTCP, e.g. see [GivTCP issue: unable
     - Set geserial to your inverter serial number
 - If you set **ge_cloud_automatic** to `true` in `apps.yaml` then Predbat will auto-configure itself to use the appropriate GE Cloud controls and will ignore any inverter and battery controls set in `apps.yaml`
 - Make sure that the 'discharge down to' registers are set to 4% and charge and discharge slots 2, 3 and 4 are disabled in the portal by setting the start and end times to 00:00 (if you have them).
-- Freeze Export is not available on GivEnergy 3-phase inverters, whether controlled through GE Cloud or through the Predbat hub.
-  These inverters have no battery pause setting and their charge rate only limits charging from the grid, so solar would carry on charging the battery during a Freeze Export slot.
-  Predbat detects this, logs that Freeze Export is not supported and stops planning it; forced export is not affected.
+- Predbat does not use Freeze Export on GivEnergy 3-phase inverters, whether controlled through GE Cloud or through the Predbat hub.
+  On the 3-phase hybrid there is no battery pause setting and the charge rate only limits charging from the grid, so solar carries on charging the battery during a Freeze Export slot.
+  The AC-coupled 3-phase model is treated the same way as a precaution; it has not been checked and may in fact be able to hold.
+  Predbat detects these inverters, logs that Freeze Export is not supported and stops planning it; forced export is not affected.
+  If any inverter in a multi-inverter system does not support Freeze Export then it is turned off for all of them.
 - If you have set **ge_cloud_automatic** to `true` and the GE Cloud does not return accurate **load_today** energy information, you can [override the GE Cloud load data](apps-yaml.md) by creating a custom template sensor and setting **ge_cloud_load_today_ignore** to true in `apps.yaml`.
 - The charge/export slot start and end times are stored by GivEnergy in the timezone set on your GivEnergy account. Predbat reads this timezone from the GivEnergy account details and translates the slot times into
   the Predbat **timezone** setting, so the times shown on the Predbat select entities may differ from those shown in the GivEnergy portal if the two timezones do not match.