diff --git a/src/elements/content-sidebar/ContentSidebar.scss b/src/elements/content-sidebar/ContentSidebar.scss
index b16a8b098f..18290d0127 100644
--- a/src/elements/content-sidebar/ContentSidebar.scss
+++ b/src/elements/content-sidebar/ContentSidebar.scss
@@ -8,6 +8,7 @@ $sidebarDefaultErrorIncreasedWidth: $sidebarContentIncreasedWidth - 16px;
 
 .be {
     &.bcs {
+        position: relative;
         display: flex;
         width: auto;
         min-width: $sidebarTabsWidth;
@@ -17,6 +18,16 @@ $sidebarDefaultErrorIncreasedWidth: $sidebarContentIncreasedWidth - 16px;
         &.bcs-is-wider {
             max-width: $sidebarIncreasedWidth;
         }
+
+        // When resizable, the default min-width is the un-resized sidebar width.
+        // Inline style on the aside element overrides the default max-width to allow grow.
+        &.bcs-is-resizable.bcs-is-open {
+            min-width: $sidebarWidth;
+
+            &.bcs-is-wider {
+                min-width: $sidebarIncreasedWidth;
+            }
+        }
     }
 
     .bcs-loading {
@@ -61,11 +72,20 @@ $sidebarDefaultErrorIncreasedWidth: $sidebarContentIncreasedWidth - 16px;
             min-width: 0;
             max-width: none;
             max-height: 48px;
-            transition: max-height .5s ease-in-out 0s;
+            transition: max-height 0.5s ease-in-out 0s;
 
             &.bcs-is-wider {
                 max-width: none;
             }
+
+            // Neutralize resizable overrides on small screens — sidebar is a bottom sheet here
+            &.bcs-is-resizable.bcs-is-open {
+                min-width: 0;
+
+                &.bcs-is-wider {
+                    min-width: 0;
+                }
+            }
         }
 
         &.bcs-is-open {
diff --git a/src/elements/content-sidebar/Sidebar.js b/src/elements/content-sidebar/Sidebar.js
index 1bdf94f62e..cb196c8552 100644
--- a/src/elements/content-sidebar/Sidebar.js
+++ b/src/elements/content-sidebar/Sidebar.js
@@ -14,8 +14,11 @@ import { withRouter } from 'react-router-dom';
 import type { Location, RouterHistory } from 'react-router-dom';
 import LoadingIndicator from '../../components/loading-indicator/LoadingIndicator';
 import LocalStore from '../../utils/LocalStore';
+import withMediaQuery from '../../components/media-query/withMediaQuery';
+import { VIEW_SIZE_TYPE } from '../../components/media-query/constants';
 import SidebarNav from './SidebarNav';
 import SidebarPanels from './SidebarPanels';
+import SidebarResizeHandle from './SidebarResizeHandle';
 import SidebarUtils from './SidebarUtils';
 // $FlowFixMe TypeScript file
 import ThemingStyles from '../common/theming';
@@ -74,12 +77,15 @@ type Props = {
     /** When true, enables data fetching. When false, defers data fetching. Used to prioritize preview loading. */
     shouldFetchSidebarData?: boolean,
     signSidebarProps: SignSidebarProps,
+    size: $Values<typeof VIEW_SIZE_TYPE>,
     theme?: Theme,
     versionsSidebarProps: VersionsSidebarProps,
+    viewWidth: number,
 };
 
 type State = {
     isDirty: boolean,
+    width: ?number,
 };
 
 export const SIDEBAR_FORCE_KEY: 'bcs.force' = 'bcs.force';
@@ -87,6 +93,13 @@ export const SIDEBAR_FORCE_VALUE_CLOSED: 'closed' = 'closed';
 export const SIDEBAR_FORCE_VALUE_OPEN: 'open' = 'open';
 export const SIDEBAR_SELECTED_PANEL_KEY: 'sidebar-selected-panel' = 'sidebar-selected-panel';
 
+// Default widths mirror the hardcoded SCSS values ($sidebarTabsWidth + $sidebarContent[Increased]Width).
+// When the resizable feature flag is on, these become the minimum drag-to-resize widths.
+const SIDEBAR_DEFAULT_WIDTH = 400;
+const SIDEBAR_DEFAULT_WIDTH_WIDER = 440;
+// Cap dragged width at this fraction of the current viewport width.
+const SIDEBAR_MAX_WIDTH_RATIO = 0.5;
+
 class Sidebar extends React.Component<Props, State> {
     static defaultProps = {
         annotatorState: {},
@@ -111,11 +124,24 @@ class Sidebar extends React.Component<Props, State> {
 
         this.state = {
             isDirty: this.getLocationState('open') || false,
+            width: null,
         };
 
         this.setForcedByLocation();
     }
 
+    /**
+     * Default sidebar width based on whether the "wider" (Box AI) variant is active.
+     * Mirrors the SCSS fallback so flipping the flag on doesn't change the rendered width at rest.
+     */
+    getDefaultWidth(hasNativeBoxAISidebar: boolean, hasCustomBoxAISidebar: boolean): number {
+        return hasNativeBoxAISidebar || hasCustomBoxAISidebar ? SIDEBAR_DEFAULT_WIDTH_WIDER : SIDEBAR_DEFAULT_WIDTH;
+    }
+
+    handleResize = (width: number): void => {
+        this.setState({ width });
+    };
+
     componentDidMount() {
         const { file, api, metadataSidebarProps, docGenSidebarProps, onOpenChange = noop }: Props = this.props;
         // if docgen feature is enabled, load metadata to check whether file is a docgen template
@@ -304,6 +330,7 @@ class Sidebar extends React.Component<Props, State> {
             customSidebarPanels = [],
             detailsSidebarProps,
             docGenSidebarProps,
+            features,
             file,
             fileId,
             getPreview,
@@ -317,9 +344,12 @@ class Sidebar extends React.Component<Props, State> {
             onAnnotationSelect,
             onVersionChange,
             signSidebarProps,
+            size,
             theme,
             versionsSidebarProps,
+            viewWidth,
         }: Props = this.props;
+        const { width }: State = this.state;
         const isOpen = this.isOpen();
 
         const hasCustomBoxAISidebar = customSidebarPanels.some(panel => panel.id === SIDEBAR_VIEW_BOXAI);
@@ -331,14 +361,34 @@ class Sidebar extends React.Component<Props, State> {
         const hasMetadata = SidebarUtils.shouldRenderMetadataSidebar(this.props, metadataEditors);
         const hasSkills = SidebarUtils.shouldRenderSkillsSidebar(this.props, file);
         const onVersionHistoryClick = hasVersions ? this.handleVersionHistoryClick : this.props.onVersionHistoryClick;
+
+        const isViewportWideEnoughToResize = size === VIEW_SIZE_TYPE.large || size === VIEW_SIZE_TYPE.xlarge;
+        const isResizable =
+            isFeatureEnabled(features, 'contentSidebar.resizable.enabled') && isViewportWideEnoughToResize;
+        const minWidth = this.getDefaultWidth(hasNativeBoxAISidebar, hasCustomBoxAISidebar);
+        const maxWidth = Math.max(minWidth, Math.round(viewWidth * SIDEBAR_MAX_WIDTH_RATIO));
+        const currentWidth = width != null ? Math.min(Math.max(width, minWidth), maxWidth) : minWidth;
+        // Only force inline width once the user has actually dragged — otherwise leave the SCSS defaults in place.
+        const shouldApplyInlineWidth = isResizable && isOpen && width != null;
+        const inlineStyle = shouldApplyInlineWidth ? { width: currentWidth, maxWidth: currentWidth } : undefined;
+
         const styleClassName = classNames('be bcs', className, {
             'bcs-is-open': isOpen,
+            'bcs-is-resizable': isResizable,
             'bcs-is-wider': hasNativeBoxAISidebar || hasCustomBoxAISidebar,
         });
         const defaultPanel = this.getDefaultPanel();
 
         return (
-            <aside id={this.id} className={styleClassName} data-testid="preview-sidebar">
+            <aside id={this.id} className={styleClassName} data-testid="preview-sidebar" style={inlineStyle}>
+                {isResizable && isOpen && !isLoading && (
+                    <SidebarResizeHandle
+                        maxWidth={maxWidth}
+                        minWidth={minWidth}
+                        onResize={this.handleResize}
+                        width={currentWidth}
+                    />
+                )}
                 <ThemingStyles theme={theme} />
                 {isLoading ? (
                     <div className="bcs-loading">
@@ -404,4 +454,4 @@ class Sidebar extends React.Component<Props, State> {
 }
 
 export { Sidebar as SidebarComponent };
-export default flow([withCurrentUser, withFeatureConsumer, withRouter])(Sidebar);
+export default flow([withCurrentUser, withFeatureConsumer, withMediaQuery, withRouter])(Sidebar);
diff --git a/src/elements/content-sidebar/SidebarContent.scss b/src/elements/content-sidebar/SidebarContent.scss
index 21481c20d7..c0a370855f 100644
--- a/src/elements/content-sidebar/SidebarContent.scss
+++ b/src/elements/content-sidebar/SidebarContent.scss
@@ -63,6 +63,15 @@ $sidebarScrollContentIncreasedWidth: $sidebarScrollContentWidth + 40px;
     }
 }
 
+// When resizable, let .bcs-content and its scroll children fill the resized aside
+.bcs-is-resizable .bcs-content {
+    width: 100%;
+
+    .bcs-scroll-content {
+        width: 100%;
+    }
+}
+
 @include breakpoint($medium-screen) {
     .bcs-content,
     .bcs-is-wider .bcs-content {
diff --git a/src/elements/content-sidebar/SidebarResizeHandle.js b/src/elements/content-sidebar/SidebarResizeHandle.js
new file mode 100644
index 0000000000..34d7f6bf3a
--- /dev/null
+++ b/src/elements/content-sidebar/SidebarResizeHandle.js
@@ -0,0 +1,82 @@
+/**
+ * @flow
+ * @file Sidebar Resize Handle — drag-to-resize grip on the left edge of the sidebar.
+ * @author Box
+ */
+
+import * as React from 'react';
+import './SidebarResizeHandle.scss';
+
+type Props = {
+    maxWidth: number,
+    minWidth: number,
+    onResize: (width: number) => void,
+    width: number,
+};
+
+const clamp = (value: number, min: number, max: number): number => Math.min(Math.max(value, min), max);
+
+const SidebarResizeHandle = ({ maxWidth, minWidth, onResize, width }: Props) => {
+    const startXRef = React.useRef<number>(0);
+    const startWidthRef = React.useRef<number>(width);
+    const [isDragging, setIsDragging] = React.useState(false);
+
+    const handlePointerMove = React.useCallback(
+        (event: PointerEvent) => {
+            // Sidebar lives on the RIGHT edge of the viewport, and the handle is on its LEFT edge.
+            // Dragging LEFT (smaller clientX) should GROW the sidebar.
+            const deltaX = startXRef.current - event.clientX;
+            const nextWidth = clamp(startWidthRef.current + deltaX, minWidth, maxWidth);
+            onResize(nextWidth);
+        },
+        [maxWidth, minWidth, onResize],
+    );
+
+    const handlePointerUp = React.useCallback(
+        (event: PointerEvent) => {
+            setIsDragging(false);
+            const { target } = event;
+            // Flow lib types pointer-capture methods as `(string)`; the real DOM API takes a number.
+            // Flow's Element doesn't declare `hasPointerCapture` either, so cast for that one call.
+            const pointerId = ((event.pointerId: any): string);
+            if (target instanceof Element && (target: any).hasPointerCapture(pointerId)) {
+                target.releasePointerCapture(pointerId);
+            }
+            window.removeEventListener('pointermove', handlePointerMove);
+            window.removeEventListener('pointerup', handlePointerUp);
+        },
+        [handlePointerMove],
+    );
+
+    const handlePointerDown = (event: SyntheticPointerEvent<HTMLDivElement>) => {
+        event.preventDefault();
+        startXRef.current = event.clientX;
+        startWidthRef.current = width;
+        setIsDragging(true);
+        // Flow lib types setPointerCapture as `(string)`; the real DOM API takes a number.
+        // jsdom doesn't implement setPointerCapture, so guard the call.
+        if (typeof event.currentTarget.setPointerCapture === 'function') {
+            event.currentTarget.setPointerCapture(((event.pointerId: any): string));
+        }
+        window.addEventListener('pointermove', handlePointerMove);
+        window.addEventListener('pointerup', handlePointerUp);
+    };
+
+    React.useEffect(() => {
+        return () => {
+            window.removeEventListener('pointermove', handlePointerMove);
+            window.removeEventListener('pointerup', handlePointerUp);
+        };
+    }, [handlePointerMove, handlePointerUp]);
+
+    return (
+        <div
+            aria-hidden="true"
+            className={`bcs-resize-handle${isDragging ? ' bcs-resize-handle-is-dragging' : ''}`}
+            data-testid="sidebar-resize-handle"
+            onPointerDown={handlePointerDown}
+        />
+    );
+};
+
+export default SidebarResizeHandle;
diff --git a/src/elements/content-sidebar/SidebarResizeHandle.scss b/src/elements/content-sidebar/SidebarResizeHandle.scss
new file mode 100644
index 0000000000..b9d85fb72d
--- /dev/null
+++ b/src/elements/content-sidebar/SidebarResizeHandle.scss
@@ -0,0 +1,18 @@
+@import '../common/variables';
+
+.bcs-resize-handle {
+    position: absolute;
+    top: 0;
+    left: 0;
+    z-index: 1;
+    width: 6px;
+    height: 100%;
+    cursor: col-resize;
+    background-color: transparent;
+    transition: background-color 0.15s ease;
+
+    &:hover,
+    &.bcs-resize-handle-is-dragging {
+        background-color: $bdl-box-blue;
+    }
+}
diff --git a/src/elements/content-sidebar/__tests__/Sidebar.test.js b/src/elements/content-sidebar/__tests__/Sidebar.test.js
index a4fd65fead..1ac875996e 100644
--- a/src/elements/content-sidebar/__tests__/Sidebar.test.js
+++ b/src/elements/content-sidebar/__tests__/Sidebar.test.js
@@ -473,6 +473,95 @@ describe('elements/content-sidebar/Sidebar', () => {
         });
     });
 
+    describe('resizable', () => {
+        const resizableProps = {
+            features: { contentSidebar: { resizable: { enabled: true } } },
+            size: 'large',
+            viewWidth: 1600,
+        };
+
+        test('renders the resize handle and bcs-is-resizable class when feature is on and viewport is large', () => {
+            LocalStore.mockImplementationOnce(() => ({
+                getItem: jest.fn(() => SIDEBAR_FORCE_VALUE_OPEN),
+                setItem: jest.fn(),
+            }));
+            const wrapper = getWrapper(resizableProps);
+
+            expect(wrapper.hasClass('bcs-is-resizable')).toBe(true);
+            expect(wrapper.find('SidebarResizeHandle').exists()).toBe(true);
+        });
+
+        test('does not render the resize handle when the feature flag is off', () => {
+            LocalStore.mockImplementationOnce(() => ({
+                getItem: jest.fn(() => SIDEBAR_FORCE_VALUE_OPEN),
+                setItem: jest.fn(),
+            }));
+            const wrapper = getWrapper({
+                ...resizableProps,
+                features: { contentSidebar: { resizable: { enabled: false } } },
+            });
+
+            expect(wrapper.hasClass('bcs-is-resizable')).toBe(false);
+            expect(wrapper.find('SidebarResizeHandle').exists()).toBe(false);
+        });
+
+        test.each(['small', 'medium'])(
+            'does not render the resize handle on %s viewports even when the flag is on',
+            size => {
+                LocalStore.mockImplementationOnce(() => ({
+                    getItem: jest.fn(() => SIDEBAR_FORCE_VALUE_OPEN),
+                    setItem: jest.fn(),
+                }));
+                const wrapper = getWrapper({ ...resizableProps, size });
+
+                expect(wrapper.hasClass('bcs-is-resizable')).toBe(false);
+                expect(wrapper.find('SidebarResizeHandle').exists()).toBe(false);
+            },
+        );
+
+        test('does not render the resize handle when the sidebar is closed', () => {
+            LocalStore.mockImplementationOnce(() => ({
+                getItem: jest.fn(() => SIDEBAR_FORCE_VALUE_CLOSED),
+                setItem: jest.fn(),
+            }));
+            const wrapper = getWrapper(resizableProps);
+
+            expect(wrapper.find('SidebarResizeHandle').exists()).toBe(false);
+        });
+
+        test('does not apply inline width until the user has dragged', () => {
+            LocalStore.mockImplementationOnce(() => ({
+                getItem: jest.fn(() => SIDEBAR_FORCE_VALUE_OPEN),
+                setItem: jest.fn(),
+            }));
+            const wrapper = getWrapper(resizableProps);
+
+            expect(wrapper.find('aside').prop('style')).toBeUndefined();
+        });
+
+        test('applies inline width once handleResize has been called', () => {
+            LocalStore.mockImplementationOnce(() => ({
+                getItem: jest.fn(() => SIDEBAR_FORCE_VALUE_OPEN),
+                setItem: jest.fn(),
+            }));
+            const wrapper = getWrapper(resizableProps);
+            wrapper.instance().handleResize(550);
+            wrapper.update();
+
+            expect(wrapper.find('aside').prop('style')).toEqual({ width: 550, maxWidth: 550 });
+        });
+
+        test('caps maxWidth at 50% of the viewport width', () => {
+            LocalStore.mockImplementationOnce(() => ({
+                getItem: jest.fn(() => SIDEBAR_FORCE_VALUE_OPEN),
+                setItem: jest.fn(),
+            }));
+            const wrapper = getWrapper({ ...resizableProps, viewWidth: 1200 });
+
+            expect(wrapper.find('SidebarResizeHandle').prop('maxWidth')).toBe(600);
+        });
+    });
+
     describe('on panel change', () => {
         const mockSetItem = jest.fn();
         const mockPanelName = 'activity';
diff --git a/src/elements/content-sidebar/__tests__/SidebarResizeHandle.test.js b/src/elements/content-sidebar/__tests__/SidebarResizeHandle.test.js
new file mode 100644
index 0000000000..85629ea81c
--- /dev/null
+++ b/src/elements/content-sidebar/__tests__/SidebarResizeHandle.test.js
@@ -0,0 +1,118 @@
+import * as React from 'react';
+import { act, fireEvent, render, screen } from '../../../test-utils/testing-library';
+import SidebarResizeHandle from '../SidebarResizeHandle';
+
+describe('elements/content-sidebar/SidebarResizeHandle', () => {
+    const defaultProps = {
+        maxWidth: 800,
+        minWidth: 400,
+        onResize: jest.fn(),
+        width: 400,
+    };
+
+    // pointerdown is wired via React's synthetic system → use fireEvent.
+    // pointermove / pointerup are attached via raw window.addEventListener → dispatch a plain Event.
+    const dispatchWindowPointer = (type, init) => {
+        const event = new Event(type, { bubbles: true });
+        Object.assign(event, init);
+        window.dispatchEvent(event);
+    };
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('renders a decorative aria-hidden handle', () => {
+        render(<SidebarResizeHandle {...defaultProps} />);
+        const handle = screen.getByTestId('sidebar-resize-handle');
+        expect(handle).toHaveAttribute('aria-hidden', 'true');
+        expect(handle).toHaveClass('bcs-resize-handle');
+    });
+
+    test('calls onResize with growing width when dragging left from the handle', () => {
+        const onResize = jest.fn();
+        render(<SidebarResizeHandle {...defaultProps} onResize={onResize} width={400} />);
+        const handle = screen.getByTestId('sidebar-resize-handle');
+
+        // Pointer down at clientX=1000, then move left to clientX=950 (delta=50, sidebar grows by 50)
+        fireEvent(
+            handle,
+            Object.assign(new MouseEvent('pointerdown', { bubbles: true, clientX: 1000 }), { pointerId: 1 }),
+        );
+        dispatchWindowPointer('pointermove', { clientX: 950, pointerId: 1 });
+
+        expect(onResize).toHaveBeenCalledWith(450);
+    });
+
+    test('calls onResize with shrinking width when dragging right from the handle', () => {
+        const onResize = jest.fn();
+        render(<SidebarResizeHandle {...defaultProps} onResize={onResize} width={600} />);
+        const handle = screen.getByTestId('sidebar-resize-handle');
+
+        // Pointer down at clientX=1000, then move right to clientX=1080 (delta=-80, sidebar shrinks)
+        fireEvent(
+            handle,
+            Object.assign(new MouseEvent('pointerdown', { bubbles: true, clientX: 1000 }), { pointerId: 1 }),
+        );
+        dispatchWindowPointer('pointermove', { clientX: 1080, pointerId: 1 });
+
+        expect(onResize).toHaveBeenCalledWith(520);
+    });
+
+    test('clamps to minWidth when the drag would go below it', () => {
+        const onResize = jest.fn();
+        render(<SidebarResizeHandle {...defaultProps} minWidth={400} maxWidth={800} onResize={onResize} width={420} />);
+        const handle = screen.getByTestId('sidebar-resize-handle');
+
+        // Pointer down at 1000, drag right by 200 → would be width=220, clamps to minWidth=400
+        fireEvent(
+            handle,
+            Object.assign(new MouseEvent('pointerdown', { bubbles: true, clientX: 1000 }), { pointerId: 1 }),
+        );
+        dispatchWindowPointer('pointermove', { clientX: 1200, pointerId: 1 });
+
+        expect(onResize).toHaveBeenCalledWith(400);
+    });
+
+    test('clamps to maxWidth when the drag would exceed it', () => {
+        const onResize = jest.fn();
+        render(<SidebarResizeHandle {...defaultProps} minWidth={400} maxWidth={800} onResize={onResize} width={780} />);
+        const handle = screen.getByTestId('sidebar-resize-handle');
+
+        // Pointer down at 1000, drag left by 200 → would be width=980, clamps to maxWidth=800
+        fireEvent(
+            handle,
+            Object.assign(new MouseEvent('pointerdown', { bubbles: true, clientX: 1000 }), { pointerId: 1 }),
+        );
+        dispatchWindowPointer('pointermove', { clientX: 800, pointerId: 1 });
+
+        expect(onResize).toHaveBeenCalledWith(800);
+    });
+
+    test('toggles the dragging class while a drag is in progress', () => {
+        render(<SidebarResizeHandle {...defaultProps} />);
+        const handle = screen.getByTestId('sidebar-resize-handle');
+
+        expect(handle).not.toHaveClass('bcs-resize-handle-is-dragging');
+
+        fireEvent(
+            handle,
+            Object.assign(new MouseEvent('pointerdown', { bubbles: true, clientX: 1000 }), { pointerId: 1 }),
+        );
+        expect(handle).toHaveClass('bcs-resize-handle-is-dragging');
+
+        act(() => {
+            dispatchWindowPointer('pointerup', { clientX: 1000, pointerId: 1 });
+        });
+        expect(handle).not.toHaveClass('bcs-resize-handle-is-dragging');
+    });
+
+    test('removes window pointer listeners on unmount', () => {
+        const removeSpy = jest.spyOn(window, 'removeEventListener');
+        const { unmount } = render(<SidebarResizeHandle {...defaultProps} />);
+        unmount();
+        expect(removeSpy).toHaveBeenCalledWith('pointermove', expect.any(Function));
+        expect(removeSpy).toHaveBeenCalledWith('pointerup', expect.any(Function));
+        removeSpy.mockRestore();
+    });
+});
diff --git a/src/elements/content-sidebar/activity-feed/activity-feed/ActivityFeed.scss b/src/elements/content-sidebar/activity-feed/activity-feed/ActivityFeed.scss
index 3f0bcd7433..b4c244903c 100644
--- a/src/elements/content-sidebar/activity-feed/activity-feed/ActivityFeed.scss
+++ b/src/elements/content-sidebar/activity-feed/activity-feed/ActivityFeed.scss
@@ -161,6 +161,11 @@
     width: $sidebarContentIncreasedWidth;
 }
 
+// When resizable, the activity feed fills the parent (which is itself fluid via inline width on .bcs)
+.bcs-is-resizable .bcs-activity-feed {
+    width: 100%;
+}
+
 @include breakpoint($medium-screen) {
     .be .bcs-activity-feed {
         width: 100%;