@@ -41,6 +41,7 @@
     _event_options,
     _EventDefaults,
     _fill_event_defaults,
+    _merge_groups,
 )
 from .capture_send import _CAPTURE_V1_PATH
 from .client import (
@@ -409,7 +410,6 @@ def _normalize_uuid(self, msg: dict[str, Any]) -> str:
     def _prepare_event(
         self,
         msg: dict[str, Any],
-        disable_geoip: Optional[bool],
         property_allowlist=None,
     ) -> tuple[Optional[dict[str, Any]], Optional[str]]:
         if self.disabled or not self._accepting:
@@ -432,13 +432,7 @@ def _prepare_event(
         properties["$lib"] = "posthog-python"
         properties["$lib_version"] = VERSION
 
-        if disable_geoip is None:
-            disable_geoip = self.disable_geoip
-        if disable_geoip:
-            properties["$geoip_disable"] = True
         msg["options"] = msg.get("options") or {}
-        if self.is_server:
-            msg["properties"]["$is_server"] = True
         if property_allowlist is not None:
             msg["properties"] = {
                 key: value
@@ -481,7 +475,11 @@ def _event_defaults(
         context_options: Optional[dict[str, Any]] = None,
         derived_options: Optional[dict[str, Any]] = None,
         property_allowlist=None,
+        disable_geoip: Optional[bool] = None,
+        system_properties: Optional[dict[str, Any]] = None,
     ) -> _EventDefaults:
+        if disable_geoip is None:
+            disable_geoip = self.disable_geoip
         return _build_event_defaults(
             super_properties=self.super_properties,
             super_options=self.super_options,
@@ -490,20 +488,23 @@ def _event_defaults(
             context_options=context_options,
             derived_options=derived_options,
             property_allowlist=property_allowlist,
+            is_server=self.is_server,
+            disable_geoip=disable_geoip,
+            system_properties=system_properties,
         )
 
     def _build_capture_event(
         self, event: str, kwargs: OptionalCaptureArgs
-    ) -> tuple[dict[str, Any], Optional[bool], Any, _EventDefaults]:
-        properties = {**(kwargs.get("properties") or {}), **system_context()}
+    ) -> tuple[dict[str, Any], Any, _EventDefaults]:
+        properties = dict(kwargs.get("properties") or {})
         if self.capture_trace_context:
             properties = {**_get_current_otel_span_properties(), **properties}
         properties = _add_context_session_id(properties)
 
         distinct_id, personless = _get_identity_state(kwargs.get("distinct_id"))
         groups = kwargs.get("groups")
         if groups:
-            properties["$groups"] = groups
+            _merge_groups(properties, groups)
 
         flags_snapshot = kwargs.get("flags")
         send_feature_flags = kwargs.get("send_feature_flags")
@@ -526,13 +527,14 @@ def _build_capture_event(
                 "uuid": kwargs.get("uuid"),
                 "options": _event_options(kwargs.get("options")),
             },
-            kwargs.get("disable_geoip"),
             kwargs.get("_property_allowlist"),
             self._event_defaults(
                 context_properties=_context_tag_defaults(),
                 context_options=_get_context_options(),
                 derived_options=_personless_options(personless),
                 property_allowlist=kwargs.get("_property_allowlist"),
+                disable_geoip=kwargs.get("disable_geoip"),
+                system_properties=system_context(),
             ),
         )
 
@@ -541,12 +543,8 @@ def capture(
     ) -> Optional[str]:
         """Queue an event without blocking for network delivery."""
         try:
-            msg, disable_geoip, property_allowlist, defaults = (
-                self._build_capture_event(event, kwargs)
-            )
-            prepared, sent_uuid = self._prepare_event(
-                msg, disable_geoip, property_allowlist
-            )
+            msg, property_allowlist, defaults = self._build_capture_event(event, kwargs)
+            prepared, sent_uuid = self._prepare_event(msg, property_allowlist)
             if prepared is None or sent_uuid is None:
                 return None
             if not self.send:
@@ -588,12 +586,8 @@ async def capture_immediate(
         self._immediate_callers[current] = self._immediate_callers.get(current, 0) + 1
         error_batch: list[dict[str, Any]] = []
         try:
-            msg, disable_geoip, property_allowlist, defaults = (
-                self._build_capture_event(event, kwargs)
-            )
-            prepared, sent_uuid = self._prepare_event(
-                msg, disable_geoip, property_allowlist
-            )
+            msg, property_allowlist, defaults = self._build_capture_event(event, kwargs)
+            prepared, sent_uuid = self._prepare_event(msg, property_allowlist)
             if prepared is None or sent_uuid is None:
                 return None
             processed = await self._process_event(prepared, defaults)
@@ -771,12 +765,14 @@ def _enqueue_built_event(
         disable_geoip: Optional[bool],
         context_options: Optional[dict[str, Any]] = None,
     ) -> Optional[str]:
-        prepared, sent_uuid = self._prepare_event(msg, disable_geoip)
+        prepared, sent_uuid = self._prepare_event(msg)
         if prepared is None or sent_uuid is None:
             return None
         if not self.send:
             return sent_uuid
-        defaults = self._event_defaults(context_options=context_options)
+        defaults = self._event_defaults(
+            context_options=context_options, disable_geoip=disable_geoip
+        )
         if not self._enqueue_prepared_event(prepared, defaults):
             return None
         return sent_uuid
 
@@ -113,13 +113,26 @@ def _build_event_defaults(
     context_options: Optional[Mapping[str, Any]] = None,
     derived_options: Optional[Mapping[str, Any]] = None,
     property_allowlist: Optional[Collection[str]] = None,
+    is_server: bool = False,
+    disable_geoip: bool = False,
+    system_properties: Optional[Mapping[str, Any]] = None,
 ) -> _EventDefaults:
     """Order the layers: context, then global, then values the SDK derives."""
-    # An explicit `$release_id` in the event or in super properties wins over
-    # the environment value.
-    release = {"$release_id": release_id} if release_id is not None else {}
+    # A value in the event, the context or super properties wins over every
+    # value the SDK adds, including `$is_server` and `$geoip_disable`.
+    sdk_properties = dict(system_properties or {})
+    if release_id is not None:
+        sdk_properties["$release_id"] = release_id
+    if is_server:
+        sdk_properties["$is_server"] = True
+    if disable_geoip:
+        sdk_properties["$geoip_disable"] = True
     return _EventDefaults(
-        property_layers=(context_properties or {}, super_properties or {}, release),
+        property_layers=(
+            context_properties or {},
+            super_properties or {},
+            sdk_properties,
+        ),
         option_layers=(
             context_options or {},
             _event_options(super_options),
@@ -168,6 +181,15 @@ def _fill_event_defaults(
     msg["options"] = options
 
 
+def _merge_groups(properties: dict[str, Any], groups: Mapping[str, Any]) -> None:
+    """Merge typed ``groups`` into the ``$groups`` property; ``groups`` wins key by key."""
+    existing = properties.get("$groups")
+    if isinstance(existing, dict):
+        properties["$groups"] = {**existing, **groups}
+    else:
+        properties["$groups"] = dict(groups)
+
+
 def _v1_timestamp(timestamp: Any) -> str:
     """Return a UTC RFC3339 timestamp string.
 
 
@@ -39,6 +39,7 @@
     _canonical_event_uuid,
     _event_options,
     _fill_event_defaults,
+    _merge_groups,
 )
 from posthog.capture_send import (
     _CAPTURE_AI_V1_PATH,
@@ -812,10 +813,13 @@ def __init__(
                 accepts a Project Secret API Key.
             disabled: If True, disable captures and API requests. Useful in tests.
             disable_geoip: Whether to disable server-side GeoIP enrichment.
-                Defaults to True.
+                Defaults to True. Events get ``$geoip_disable`` only when the
+                event, context tags and ``super_properties`` leave it unset.
             is_server: Whether events are emitted from a server-side runtime.
                 Defaults to True; set to False when using the SDK as a client/CLI
-                so the device OS is attributed to the person normally.
+                so the device OS is attributed to the person normally. Events
+                get ``$is_server`` only when the event, context tags and
+                ``super_properties`` leave it unset.
             historical_migration: Mark events as historical migration imports.
             feature_flags_request_timeout_seconds: Timeout in seconds for feature
                 flag and remote config requests.
@@ -849,8 +853,10 @@ def __init__(
                 False.
             before_send: Optional callback that can modify or drop events before
                 upload. Return ``None`` to drop an event. Context tags,
-                context options, ``super_properties`` and ``super_options``
-                fill in before it runs, so it can change or remove them.
+                context options, ``super_properties``, ``super_options`` and
+                the values the SDK adds, such as ``$is_server``,
+                ``$geoip_disable`` and ``$os``, fill in before it runs, so it
+                can change or remove them.
             flag_fallback_cache_url: Optional feature flag fallback cache URL,
                 such as ``memory://local/?ttl=300&size=10000`` or a Redis URL.
             enable_local_evaluation: Whether to poll feature flag definitions for
@@ -1694,14 +1700,17 @@ def capture(
             uuid: A unique identifier for the event. If provided, it must be a
                 valid UUID string or uuid.UUID instance; invalid values are
                 ignored and replaced with a newly generated UUID.
-            groups: A dictionary of group information.
+            groups: A dictionary of group information. It merges into a
+                ``$groups`` property and wins key by key.
             flags: A FeatureFlagEvaluations snapshot from evaluate_flags(). The
                 exact values from the snapshot are attached with no extra /flags
                 request.
             send_feature_flags: Deprecated. Prefer flags=... from
                 evaluate_flags(). When truthy, evaluates flags during capture and
                 attaches them to the event.
-            disable_geoip: Whether to disable GeoIP for this event.
+            disable_geoip: Whether to disable GeoIP for this event. A
+                ``$geoip_disable`` property in the event, context tags or
+                ``super_properties`` wins.
             options: Capture options for this event, such as
                 ``{"process_person_profile": False}``. Sent as given, for
                 PostHog to validate. They override context options and
@@ -1788,7 +1797,7 @@ def _capture(
         # applied to the fully-enriched properties dict just before enqueueing.
         property_allowlist = kwargs.get("_property_allowlist", None)
 
-        properties = {**(properties or {}), **system_context()}
+        properties = dict(properties or {})
 
         if self.capture_trace_context:
             properties = {**_get_current_otel_span_properties(), **properties}
@@ -1807,7 +1816,7 @@ def _capture(
         }
 
         if groups:
-            properties["$groups"] = groups
+            _merge_groups(properties, groups)
 
         extra_properties: dict[str, Any] = {}
 
@@ -1908,6 +1917,7 @@ def _capture(
             context_properties=_context_tag_defaults(),
             context_options=_context_get_context_options(),
             derived_options=_personless_options(personless),
+            system_properties=system_context(),
         )
 
     def _parse_send_feature_flags(self, send_feature_flags) -> SendFeatureFlagsOptions:
@@ -2499,6 +2509,7 @@ def _enqueue(
         context_properties=None,
         context_options=None,
         derived_options=None,
+        system_properties=None,
     ):
         # type: (...) -> Optional[str]
         """Push a new `msg` onto a lane's queue (analytics when unspecified), return the event uuid or None."""
@@ -2532,16 +2543,8 @@ def _enqueue(
         if disable_geoip is None:
             disable_geoip = self.disable_geoip
 
-        if disable_geoip:
-            msg["properties"]["$geoip_disable"] = True
-
         msg["options"] = msg.get("options") or {}
 
-        # Super properties fill only keys the event left unset, so they cannot
-        # override this SDK's server classification.
-        if self.is_server:
-            msg["properties"]["$is_server"] = True
-
         _fill_event_defaults(
             msg,
             _build_event_defaults(
@@ -2552,6 +2555,9 @@ def _enqueue(
                 context_options=context_options,
                 derived_options=derived_options,
                 property_allowlist=property_allowlist,
+                is_server=self.is_server,
+                disable_geoip=disable_geoip,
+                system_properties=system_properties,
             ),
         )
 
 
@@ -10,6 +10,8 @@
 from datetime import datetime, timezone
 from typing import Any, Dict, List
 
+from posthog.capture_event import _merge_groups
+
 from .constants import (
     POSTHOG_MCP_ANALYTICS_SOURCE,
     PostHogMCPAnalyticsEvent,
@@ -63,9 +65,9 @@ def _build_capture_event(event: Event) -> PostHogCaptureEvent:
     _add_session_id(event, properties)
     _add_conversation_id(event, properties)
     _add_person_processing(event, properties)
-    _add_groups(event, properties)
     _add_common_properties(event, properties)
     _add_custom_properties(event, properties)
+    _add_groups(event, properties)
     _add_server_build(event, properties)
 
     event_name = (
@@ -92,9 +94,10 @@ def _add_conversation_id(event: Event, properties: Dict[str, Any]) -> None:
 
 
 def _add_groups(event: Event, properties: Dict[str, Any]) -> None:
+    """Merge the typed groups over a custom ``$groups`` property, key by key."""
     groups = event.get("groups")
     if groups:
-        properties["$groups"] = groups
+        _merge_groups(properties, groups)
 
 
 def _add_person_processing(event: Event, properties: Dict[str, Any]) -> None:
 
@@ -925,14 +925,15 @@ def test_identity_enables_person_processing_and_set():
         "identify_actor_given_id": "user_1",
         "identify_actor_data": {"email": "a@b.com"},
         "groups": {"organization": "org_1"},
+        "properties": {"$groups": {"organization": "custom", "project": "p1"}},
         "timestamp": datetime.now(timezone.utc),
     }
     [capture] = build_posthog_capture_events(event)
     props = capture["properties"]
     assert capture["distinct_id"] == "user_1"
     assert "$process_person_profile" not in props
     assert props["$set"] == {"email": "a@b.com"}
-    assert props["$groups"] == {"organization": "org_1"}
+    assert props["$groups"] == {"organization": "org_1", "project": "p1"}
 
 
 def test_listed_tool_names_only_on_tools_list():
 
@@ -420,20 +420,6 @@ def test_capture_omits_is_server_when_disabled(self):
             self.assertEqual(msg["properties"]["$lib"], "posthog-python")
             self.assertNotIn("$is_server", msg["properties"])
 
-    def test_is_server_not_overridden_by_super_properties(self):
-        with patch_capture_send("client") as mock_post:
-            client = Client(
-                FAKE_TEST_API_KEY,
-                on_error=self.set_fail,
-                sync_mode=True,
-                super_properties={"$is_server": False},
-            )
-            client.capture("python test event", distinct_id="distinct_id")
-            self.assertFalse(self.failed)
-
-            msg = sent_batch(mock_post)[0]
-            self.assertEqual(msg["properties"]["$is_server"], True)
-
     def test_basic_capture_with_uuid(self):
         with patch_capture_send("client") as mock_post:
             client = Client(FAKE_TEST_API_KEY, on_error=self.set_fail, sync_mode=True)