diff --git a/src/content/reference/react/Fragment.md b/src/content/reference/react/Fragment.md
index aa72b08a0ba..e473dcb572f 100644
--- a/src/content/reference/react/Fragment.md
+++ b/src/content/reference/react/Fragment.md
@@ -4,7 +4,9 @@ title: <Fragment> (<>...</>)
 
 <Intro>
 
-`<Fragment>`, often used via `<>...</>` syntax, lets you group elements without a wrapper node.
+`<Fragment>`, often used via `<>...</>` syntax, lets you group elements without a wrapper node. 
+
+<Experimental> Fragments can also accept refs, which enable interacting with underlying DOM nodes without adding wrapper elements. See reference and usage below.</Experimental>
 
 ```js
 <>
@@ -25,9 +27,37 @@ title: <Fragment> (<>...</>)
 
 Wrap elements in `<Fragment>` to group them together in situations where you need a single element. Grouping elements in `Fragment` has no effect on the resulting DOM; it is the same as if the elements were not grouped. The empty JSX tag `<></>` is shorthand for `<Fragment></Fragment>` in most cases.
 
+### <ExperimentalBadge /> FragmentInstance {/*fragmentinstance*/}
+
+When you pass a ref to a fragment, React provides a `FragmentInstance` object with methods for interacting with the DOM nodes wrapped by the fragment:
+
+**Event handling methods:**
+- `addEventListener(type, listener, options?)`: Adds an event listener to all first-level DOM children of the Fragment
+- `removeEventListener(type, listener, options?)`: Removes an event listener from all first-level DOM children of the Fragment  
+- `dispatchEvent(event)`: Dispatches an event to a virtual child of the Fragment to call any added listeners and bubble to the DOM parent.
+
+**Layout methods:**
+- `compareDocumentPosition(otherNode)`: Compares the document position of the Fragment with another node
+  - If the Fragment has children, the native `compareDocumentPosition` value is returned. 
+  - Empty Fragments will attempt to compare positioning within the React tree and include `NODE.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC`
+  - Elements that have a different relationship in the React tree and DOM tree due to portaling or other insertions are `NODE.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC`
+- `getClientRects()`: Returns a flat array of `ClientRect` objects representing the bounding rectangles of all DOM nodes
+- `getRootNode()`: Returns the root node containing the Fragment's DOM nodes
+
+**Focus management methods:**
+- `focus(options?)`: Focuses the first focusable DOM node in the Fragment
+- `focusLast(options?)`: Focuses the last focusable DOM node in the Fragment
+- `blur()`: Removes focus if `document.activeElement` is within the Fragment
+
+**Observer methods:**
+- `observeUsing(observer)`: Starts observing the Fragment's DOM children with an IntersectionObserver or ResizeObserver
+- `unobserveUsing(observer)`: Stops observing the Fragment's DOM children with the specified observer
+
+
 #### Props {/*props*/}
 
 - **optional** `key`: Fragments declared with the explicit `<Fragment>` syntax may have [keys.](/learn/rendering-lists#keeping-list-items-in-order-with-key)
+- <ExperimentalBadge />  **optional** `ref`: A ref object or callback function. React will forward the ref to a `FragmentInstance` object that provides methods for interacting with the DOM nodes wrapped by the Fragment.
 
 #### Caveats {/*caveats*/}
 
@@ -35,6 +65,8 @@ Wrap elements in `<Fragment>` to group them together in situations where you nee
 
 - React does not [reset state](/learn/preserving-and-resetting-state) when you go from rendering `<><Child /></>` to `[<Child />]` or back, or when you go from rendering `<><Child /></>` to `<Child />` and back. This only works a single level deep: for example, going from `<><><Child /></></>` to `<Child />` resets the state. See the precise semantics [here.](https://gist.github.com/clemmy/b3ef00f9507909429d8aa0d3ee4f986b)
 
+- <ExperimentalBadge /> If you want to pass `ref` to a Fragment, you can't use the `<>...</>` syntax. You have to explicitly import `Fragment` from `'react'` and render `<Fragment ref={yourRef}>...</Fragment>`.
+
 ---
 
 ## Usage {/*usage*/}
@@ -208,3 +240,100 @@ function PostBody({ body }) {
 ```
 
 </Sandpack>
+
+---
+
+### <ExperimentalBadge /> Using Fragment refs for DOM interaction {/*using-fragment-refs-for-dom-interaction*/}
+
+Fragment refs allow you to interact with the DOM nodes wrapped by a Fragment without adding extra wrapper elements. This is useful for event handling, visibility tracking, focus management, and replacing deprecated patterns like `ReactDOM.findDOMNode()`.
+
+```js {11-12,16-18}
+import { Fragment, useRef, useEffect } from 'react';
+
+function ClickableWrapper({ children, onClick }) {
+  const fragmentRef = useRef(null);
+
+  useEffect(() => {
+    const handleClick = (event) => {
+      onClick(event);
+    };
+    
+    fragmentRef.current.addEventListener('click', handleClick);
+    return () => fragmentRef.current.removeEventListener('click', handleClick);
+  }, [onClick]);
+
+  return (
+    <Fragment ref={fragmentRef}>
+      {children}
+    </Fragment>
+  );
+}
+```
+---
+
+### <ExperimentalBadge /> Tracking visibility with Fragment refs {/*tracking-visibility-with-fragment-refs*/}
+
+Fragment refs are particularly useful for visibility tracking and intersection observation. This enables you to monitor when content becomes visible without requiring the child components to expose refs:
+
+```js {19,21,31-34}
+import { Fragment, useRef, useEffect } from 'react';
+
+function VisibilityObserver({ threshold = 0.5, onVisibilityChange, children }) {
+  const fragmentRef = useRef(null);
+
+  useEffect(() => {
+    const observer = new IntersectionObserver(
+      (entries) => {
+        onVisibilityChange(entries.some(entry => entry.isIntersecting))
+      },
+      { threshold }
+    );
+    
+    fragmentRef.current.observeUsing(observer);
+    return () => fragmentRef.current.unobserveUsing(observer);
+  }, [threshold, onVisibilityChange]);
+
+  return (
+    <Fragment ref={fragmentRef}>
+      {children}
+    </Fragment>
+  );
+}
+
+function MyComponent() {
+  const handleVisibilityChange = (isVisible) => {
+    console.log('Component is', isVisible ? 'visible' : 'hidden');
+  };
+
+  return (
+    <VisibilityObserver onVisibilityChange={handleVisibilityChange}>
+      <SomeThirdPartyComponent />
+      <AnotherComponent />
+    </VisibilityObserver>
+  );
+}
+```
+
+This pattern replaces effect-based visibility logging, which can be unreliable due to component lifecycle issues and Activity unmounting/remounting.
+
+---
+
+### <ExperimentalBadge /> Focus management with Fragment refs {/*focus-management-with-fragment-refs*/}
+
+Fragment refs provide focus management methods that work across all DOM nodes within the Fragment:
+
+```js
+import { Fragment, useRef } from 'react';
+
+function Focus({ children }) {
+  const fragmentRef = useRef(null);
+
+  return (
+    <Fragment ref={(fragmentInstance) => fragmentInstance?.focus()}>
+      {children}
+    </Fragment>
+  );
+}
+```
+
+The `focus()` method focuses the first focusable element within the Fragment, while `focusLast()` focuses the last focusable element.
