diff --git a/packages/sanity/src/_singletons/core/releases/BundlesMetadataContext.ts b/packages/sanity/src/_singletons/core/releases/BundlesMetadataContext.ts
new file mode 100644
index 00000000000..09c2f0fc4c2
--- /dev/null
+++ b/packages/sanity/src/_singletons/core/releases/BundlesMetadataContext.ts
@@ -0,0 +1,18 @@
+import {createContext} from 'react'
+
+import type {MetadataWrapper} from '../../../core/store/bundles/createBundlesMetadataAggregator'
+
+/**
+ * @internal
+ */
+export interface BundlesMetadataContextValue {
+  state: MetadataWrapper
+  addBundleSlugsToListener: (slugs: string[]) => void
+  removeBundleSlugsFromListener: (slugs: string[]) => void
+}
+
+/**
+ * @internal
+ * @hidden
+ */
+export const BundlesMetadataContext = createContext<BundlesMetadataContextValue | null>(null)
diff --git a/packages/sanity/src/_singletons/index.ts b/packages/sanity/src/_singletons/index.ts
index ca77d8f8c1d..3c10545eef7 100644
--- a/packages/sanity/src/_singletons/index.ts
+++ b/packages/sanity/src/_singletons/index.ts
@@ -66,3 +66,4 @@ export * from './context/VirtualizerScrollInstanceContext'
 export * from './context/WorkspaceContext'
 export * from './context/WorkspacesContext'
 export * from './context/ZIndexContext'
+export * from './core/releases/BundlesMetadataContext'
diff --git a/packages/sanity/src/core/releases/components/BundleMenuButton/BundleMenuButton.tsx b/packages/sanity/src/core/releases/components/BundleMenuButton/BundleMenuButton.tsx
index 67dacb6ba27..4be88630e87 100644
--- a/packages/sanity/src/core/releases/components/BundleMenuButton/BundleMenuButton.tsx
+++ b/packages/sanity/src/core/releases/components/BundleMenuButton/BundleMenuButton.tsx
@@ -9,9 +9,10 @@ import {useBundleOperations} from '../../../store/bundles/useBundleOperations'
 
 type Props = {
   bundle?: BundleDocument
+  documentCount: number
 }
 
-export const BundleMenuButton = ({bundle}: Props) => {
+export const BundleMenuButton = ({bundle, documentCount}: Props) => {
   const {deleteBundle, updateBundle} = useBundleOperations()
   const router = useRouter()
   const isBundleArchived = !!bundle?.archivedAt
@@ -56,8 +57,7 @@ export const BundleMenuButton = ({bundle}: Props) => {
     setIsPerformingOperation(false)
   }
 
-  // TODO: Replace this with the count once it's available. Wait for @jordanl17 change on that.
-  const count = 2
+  const bundleHasDocuments = !!documentCount
 
   return (
     <>
@@ -92,8 +92,10 @@ export const BundleMenuButton = ({bundle}: Props) => {
       {showDiscardDialog && (
         <Dialog
           id="discard-version-dialog"
-          header={`Are you sure you want to delete the ${bundle?.title} release?`}
+          header={`Are you sure you want to delete the '${bundle?.title}' release?`}
           onClose={() => setShowDiscardDialog(false)}
+          // remove body padding if no documents in release
+          padding={bundleHasDocuments}
           footer={{
             confirmButton: {
               tone: 'default',
@@ -103,9 +105,11 @@ export const BundleMenuButton = ({bundle}: Props) => {
             },
           }}
         >
-          <Text muted size={1}>
-            This will also delete {count} document version{count > 1 ? 's' : ''}.
-          </Text>
+          {bundleHasDocuments && (
+            <Text data-testid="confirm-delete-body" muted size={1}>
+              This will also delete {documentCount} document version{documentCount > 1 ? 's' : ''}.
+            </Text>
+          )}
         </Dialog>
       )}
     </>
diff --git a/packages/sanity/src/core/releases/components/BundleMenuButton/__tests__/BundleMenuButton.test.tsx b/packages/sanity/src/core/releases/components/BundleMenuButton/__tests__/BundleMenuButton.test.tsx
index e0a05c6bcd8..0deebe1a9ea 100644
--- a/packages/sanity/src/core/releases/components/BundleMenuButton/__tests__/BundleMenuButton.test.tsx
+++ b/packages/sanity/src/core/releases/components/BundleMenuButton/__tests__/BundleMenuButton.test.tsx
@@ -1,4 +1,4 @@
-import {describe, expect, jest, test} from '@jest/globals'
+import {beforeEach, describe, expect, jest, test} from '@jest/globals'
 import {fireEvent, render, screen} from '@testing-library/react'
 import {act} from 'react'
 import {useRouter} from 'sanity/router'
@@ -21,14 +21,18 @@ jest.mock('sanity/router', () => ({
   useRouter: jest.fn().mockReturnValue({state: {}, navigate: jest.fn()}),
 }))
 
-const renderTest = async (bundle: BundleDocument) => {
+const renderTest = async (bundle: BundleDocument, documentCount: number = 2) => {
   const wrapper = await createTestProvider({
     resources: [releasesUsEnglishLocaleBundle],
   })
-  return render(<BundleMenuButton bundle={bundle} />, {wrapper})
+  return render(<BundleMenuButton bundle={bundle} documentCount={documentCount} />, {wrapper})
 }
 
 describe('BundleMenuButton', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
   test('will archive an unarchived bundle', async () => {
     const activeBundle: BundleDocument = {
       _id: 'activeBundle',
@@ -40,6 +44,8 @@ describe('BundleMenuButton', () => {
       _createdAt: new Date().toISOString(),
       _updatedAt: new Date().toISOString(),
       _rev: '',
+      hue: 'gray',
+      icon: 'cube',
     }
 
     await renderTest(activeBundle)
@@ -67,6 +73,8 @@ describe('BundleMenuButton', () => {
       _createdAt: new Date().toISOString(),
       _updatedAt: new Date().toISOString(),
       _rev: '',
+      hue: 'gray',
+      icon: 'cube',
     }
     await renderTest(archivedBundle)
 
@@ -82,7 +90,7 @@ describe('BundleMenuButton', () => {
     })
   })
 
-  test('will delete a bundle', async () => {
+  test('will delete a bundle with documents', async () => {
     const activeBundle: BundleDocument = {
       _id: 'activeBundle',
       _type: 'bundle',
@@ -93,6 +101,8 @@ describe('BundleMenuButton', () => {
       _createdAt: new Date().toISOString(),
       _updatedAt: new Date().toISOString(),
       _rev: '',
+      hue: 'gray',
+      icon: 'cube',
     }
     await renderTest(activeBundle)
 
@@ -102,6 +112,8 @@ describe('BundleMenuButton', () => {
       fireEvent.click(screen.getByText('Delete'))
     })
     expect(useBundleOperations().deleteBundle).not.toHaveBeenCalled()
+    // TODO: remove not exact once i18n used for strings
+    screen.getByText('This will also delete 2 document versions', {exact: false})
 
     await act(() => {
       fireEvent.click(screen.getByText('Confirm'))
@@ -110,4 +122,37 @@ describe('BundleMenuButton', () => {
     expect(useBundleOperations().deleteBundle).toHaveBeenCalledWith(activeBundle)
     expect(useRouter().navigate).not.toHaveBeenCalled()
   })
+
+  test('will delete a bundle with no documents', async () => {
+    const activeEmptyBundle: BundleDocument = {
+      _id: 'activeEmptyBundle',
+      _type: 'bundle',
+      archivedAt: new Date().toISOString(),
+      title: 'activeEmptyBundle',
+      name: 'activeEmptyBundle',
+      authorId: 'author',
+      _createdAt: new Date().toISOString(),
+      _updatedAt: new Date().toISOString(),
+      _rev: '',
+      hue: 'gray',
+      icon: 'cube',
+    }
+    await renderTest(activeEmptyBundle, 0)
+
+    fireEvent.click(screen.getByLabelText('Release menu'))
+
+    await act(() => {
+      fireEvent.click(screen.getByText('Delete'))
+    })
+    expect(useBundleOperations().deleteBundle).not.toHaveBeenCalled()
+    // confirm dialog body is hidden when no documents in bundle
+    expect(screen.queryByTestId('confirm-delete-body')).toBeNull()
+
+    await act(() => {
+      fireEvent.click(screen.getByText('Confirm'))
+    })
+
+    expect(useBundleOperations().deleteBundle).toHaveBeenCalledWith(activeEmptyBundle)
+    expect(useRouter().navigate).not.toHaveBeenCalled()
+  })
 })
diff --git a/packages/sanity/src/core/releases/components/BundlesTable/BundleHeader.tsx b/packages/sanity/src/core/releases/components/ReleasesTable/ReleaseHeader.tsx
similarity index 59%
rename from packages/sanity/src/core/releases/components/BundlesTable/BundleHeader.tsx
rename to packages/sanity/src/core/releases/components/ReleasesTable/ReleaseHeader.tsx
index b4c01941bb2..f2189840dee 100644
--- a/packages/sanity/src/core/releases/components/BundlesTable/BundleHeader.tsx
+++ b/packages/sanity/src/core/releases/components/ReleasesTable/ReleaseHeader.tsx
@@ -1,16 +1,16 @@
 import {SearchIcon} from '@sanity/icons'
-import {Button, Card, Flex, Stack, TextInput} from '@sanity/ui'
+import {Box, Button, Card, Flex, Stack, Text, TextInput} from '@sanity/ui'
 
 /**
  * @internal
  */
-export interface BundleHeaderProps {
+export interface ReleaseHeaderProps {
   searchDisabled?: boolean
   searchTerm?: string
   setSearchTerm: (value?: string) => void
 }
 
-export function BundleHeader({searchDisabled, searchTerm, setSearchTerm}: BundleHeaderProps) {
+export function ReleaseHeader({searchDisabled, searchTerm, setSearchTerm}: ReleaseHeaderProps) {
   return (
     <Card as="thead" radius={3}>
       <Flex as="tr">
@@ -29,6 +29,22 @@ export function BundleHeader({searchDisabled, searchTerm, setSearchTerm}: Bundle
             clearButton={!!searchTerm}
           />
         </Stack>
+        {/* Number of documents */}
+        <Flex as="th" paddingY={3} sizing="border" style={{width: 90}}>
+          <Box padding={2}>
+            <Text muted size={1} weight="medium">
+              Documents
+            </Text>
+          </Box>
+        </Flex>
+        {/* Created */}
+        <Flex as="th" paddingY={3} sizing="border" style={{width: 120}}>
+          <Button mode="bleed" padding={2} radius={3} space={1} text="Created" />
+        </Flex>
+        {/* Edited */}
+        <Flex as="th" paddingY={3} sizing="border" style={{width: 100}}>
+          <Button mode="bleed" padding={2} radius={3} space={1} text="Edited" />
+        </Flex>
         {/* Published */}
         <Flex
           as="th"
diff --git a/packages/sanity/src/core/releases/components/BundlesTable/BundleRow.tsx b/packages/sanity/src/core/releases/components/ReleasesTable/ReleaseRow.tsx
similarity index 51%
rename from packages/sanity/src/core/releases/components/BundlesTable/BundleRow.tsx
rename to packages/sanity/src/core/releases/components/ReleasesTable/ReleaseRow.tsx
index 7a8130f9ca1..84b3dce3fc6 100644
--- a/packages/sanity/src/core/releases/components/BundlesTable/BundleRow.tsx
+++ b/packages/sanity/src/core/releases/components/ReleasesTable/ReleaseRow.tsx
@@ -2,15 +2,16 @@ import {Box, Card, Flex, Stack, Text} from '@sanity/ui'
 import {useRouter} from 'sanity/router'
 
 import {BundleBadge} from '../../../bundles/components/BundleBadge'
-import {RelativeTime} from '../../../components'
-import {type BundleDocument} from '../../../store/bundles/types'
+import {RelativeTime, UserAvatar} from '../../../components'
 import {BundleMenuButton} from '../BundleMenuButton/BundleMenuButton'
+import {type TableBundle} from './ReleasesTable'
 
-type Props = {
-  bundle: BundleDocument
+type ReleaseRowProps = {
+  bundle: TableBundle
 }
 
-export function BundleRow({bundle}: Props) {
+export function ReleaseRow({bundle}: ReleaseRowProps) {
+  const {documentsMetadata} = bundle
   const router = useRouter()
 
   return (
@@ -38,6 +39,43 @@ export function BundleRow({bundle}: Props) {
           </Flex>
         </Card>
       </Box>
+      {/* # of documents */}
+      <Flex as="td" align="center" paddingX={2} paddingY={3} sizing="border" style={{width: 90}}>
+        <Text muted size={1}>
+          {documentsMetadata.documentCount}
+        </Text>
+      </Flex>
+      {/* Created */}
+      <Flex
+        as="td"
+        align="center"
+        gap={2}
+        paddingX={2}
+        paddingY={3}
+        sizing="border"
+        style={{width: 120}}
+      >
+        {bundle.authorId && <UserAvatar size={0} user={bundle.authorId} />}
+        <Text muted size={1}>
+          <RelativeTime time={bundle._createdAt} useTemporalPhrase minimal />
+        </Text>
+      </Flex>
+      {/* Edited */}
+      <Flex
+        as="td"
+        align="center"
+        gap={2}
+        paddingX={2}
+        paddingY={3}
+        sizing="border"
+        style={{width: 100}}
+      >
+        {documentsMetadata.updatedAt && (
+          <Text muted size={1}>
+            <RelativeTime time={documentsMetadata.updatedAt} useTemporalPhrase minimal />
+          </Text>
+        )}
+      </Flex>
       {/* Published */}
       <Flex as="td" align="center" paddingX={2} paddingY={3} sizing="border" style={{width: 100}}>
         {!!bundle.publishedAt && (
@@ -48,7 +86,7 @@ export function BundleRow({bundle}: Props) {
       </Flex>
       {/* Actions */}
       <Flex as="td" align="center" flex="none" padding={3}>
-        <BundleMenuButton bundle={bundle} />
+        <BundleMenuButton bundle={bundle} documentCount={bundle.documentsMetadata.documentCount} />
       </Flex>
     </Card>
   )
diff --git a/packages/sanity/src/core/releases/components/BundlesTable/BundlesTable.tsx b/packages/sanity/src/core/releases/components/ReleasesTable/ReleasesTable.tsx
similarity index 65%
rename from packages/sanity/src/core/releases/components/BundlesTable/BundlesTable.tsx
rename to packages/sanity/src/core/releases/components/ReleasesTable/ReleasesTable.tsx
index f9ae26b47fb..3485b0fd665 100644
--- a/packages/sanity/src/core/releases/components/BundlesTable/BundlesTable.tsx
+++ b/packages/sanity/src/core/releases/components/ReleasesTable/ReleasesTable.tsx
@@ -3,8 +3,9 @@ import {useMemo} from 'react'
 import {styled} from 'styled-components'
 
 import {type BundleDocument} from '../../../store/bundles/types'
-import {BundleHeader, type BundleHeaderProps} from './BundleHeader'
-import {BundleRow} from './BundleRow'
+import {type BundlesMetadata} from '../../tool/useBundlesMetadata'
+import {ReleaseHeader, type ReleaseHeaderProps} from './ReleaseHeader'
+import {ReleaseRow} from './ReleaseRow'
 
 const RowStack = styled(Stack)({
   '& > *:not(:first-child)': {
@@ -19,11 +20,15 @@ const RowStack = styled(Stack)({
   },
 })
 
-interface BundlesTableProps extends Omit<BundleHeaderProps, 'searchDisabled'> {
-  bundles: BundleDocument[]
+export interface TableBundle extends BundleDocument {
+  documentsMetadata: BundlesMetadata
 }
 
-export function BundlesTable({bundles, searchTerm, setSearchTerm}: BundlesTableProps) {
+interface ReleasesTableProps extends Omit<ReleaseHeaderProps, 'searchDisabled'> {
+  bundles: TableBundle[]
+}
+
+export function ReleasesTable({bundles, searchTerm, setSearchTerm}: ReleasesTableProps) {
   const tableContent = useMemo(() => {
     if (bundles.length === 0) {
       return (
@@ -44,12 +49,12 @@ export function BundlesTable({bundles, searchTerm, setSearchTerm}: BundlesTableP
       )
     }
 
-    return bundles.map((bundle) => <BundleRow key={bundle.name} bundle={bundle} />)
+    return bundles.map((bundle) => <ReleaseRow key={bundle.name} bundle={bundle} />)
   }, [bundles])
 
   return (
     <Stack as="table" space={1}>
-      <BundleHeader
+      <ReleaseHeader
         searchDisabled={!searchTerm && !bundles.length}
         searchTerm={searchTerm}
         setSearchTerm={setSearchTerm}
diff --git a/packages/sanity/src/core/releases/components/BundlesTable/__tests__/BundlesTable.test.tsx b/packages/sanity/src/core/releases/components/ReleasesTable/__tests__/ReleasesTable.test.tsx
similarity index 50%
rename from packages/sanity/src/core/releases/components/BundlesTable/__tests__/BundlesTable.test.tsx
rename to packages/sanity/src/core/releases/components/ReleasesTable/__tests__/ReleasesTable.test.tsx
index c72a36e38dd..9edfb6ccb6d 100644
--- a/packages/sanity/src/core/releases/components/BundlesTable/__tests__/BundlesTable.test.tsx
+++ b/packages/sanity/src/core/releases/components/ReleasesTable/__tests__/ReleasesTable.test.tsx
@@ -3,9 +3,8 @@ import {fireEvent, render, screen, waitFor, within} from '@testing-library/react
 import {useRouter} from 'sanity/router'
 
 import {createTestProvider} from '../../../../../../test/testUtils/TestProvider'
-import {type BundleDocument} from '../../../../store/bundles/types'
 import {useBundleOperations} from '../../../../store/bundles/useBundleOperations'
-import {BundlesTable} from '../BundlesTable'
+import {ReleasesTable, type TableBundle} from '../ReleasesTable'
 
 jest.mock('sanity/router', () => ({
   ...(jest.requireActual('sanity/router') || {}),
@@ -18,46 +17,87 @@ jest.mock('../../../../store/bundles/useBundleOperations', () => ({
 
 const mockSetSearchTerm = jest.fn()
 
-const renderBundlesTable = async (bundles: BundleDocument[]) => {
+const renderReleasesTable = async (bundles: TableBundle[]) => {
   const wrapper = await createTestProvider()
-  return render(<BundlesTable bundles={bundles} setSearchTerm={mockSetSearchTerm} />, {wrapper})
+  return render(<ReleasesTable bundles={bundles} setSearchTerm={mockSetSearchTerm} />, {wrapper})
 }
 
-describe('BundlesTable', () => {
+describe('ReleasesTable', () => {
   it('should render the table headers', async () => {
-    await renderBundlesTable([])
+    await renderReleasesTable([])
 
     screen.getByPlaceholderText('Search releases')
     screen.getByText('Published')
+    screen.getByText('Edited')
+    screen.getByText('Created')
   })
 
   it('should display "No Releases" when there are no bundles', async () => {
-    await renderBundlesTable([])
+    await renderReleasesTable([])
     screen.getByText('No Releases')
   })
 
   it('should render a list of bundles', async () => {
     const bundles = [
-      {title: 'Bundle 1'},
-      {title: 'Bundle 2'},
-      {title: 'Bundle 3'},
-    ] as BundleDocument[]
-
-    await renderBundlesTable(bundles)
+      {
+        title: 'Bundle 1',
+        name: 'bundle-1',
+        _createdAt: new Date().toISOString(),
+        documentsMetadata: {
+          documentCount: 1,
+        },
+      },
+      {
+        title: 'Bundle 2',
+        name: 'bundle-2',
+        _createdAt: new Date().toISOString(),
+        documentsMetadata: {
+          documentCount: 0,
+        },
+      },
+      {
+        title: 'Bundle 3',
+        name: 'bundle-3',
+        _createdAt: new Date().toISOString(),
+        documentsMetadata: {
+          // 24 hours ago
+          updatedAt: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
+          documentCount: 3,
+        },
+      },
+    ] as TableBundle[]
+
+    await renderReleasesTable(bundles)
 
     const bundleRows = screen.getAllByTestId('bundle-row')
     expect(bundleRows).toHaveLength(bundles.length)
-    bundles.forEach((bundle, index) => within(bundleRows[index]).getByText(bundle.title))
+    bundles.forEach((bundle, index) => {
+      within(bundleRows[index]).getByText(bundle.title)
+      within(bundleRows[index]).getByText(bundle.documentsMetadata.documentCount.toString())
+      within(bundleRows[index]).getByText('just now')
+      if (bundle.documentsMetadata.updatedAt) {
+        within(bundleRows[index]).getByText('yesterday')
+      }
+    })
   })
 
   it('should disable search when no bundles in table', async () => {
-    await renderBundlesTable([])
+    await renderReleasesTable([])
 
     expect(screen.getByPlaceholderText('Search releases')).toBeDisabled()
   })
 
   it('should enable and trigger a search when there are bundles in the table', async () => {
-    await renderBundlesTable([{title: 'Bundle 1'}] as BundleDocument[])
+    await renderReleasesTable([
+      {
+        title: 'Bundle 1',
+        name: 'bundle-1',
+        _createdAt: new Date().toISOString(),
+        documentsMetadata: {
+          documentCount: 0,
+        },
+      },
+    ] as TableBundle[])
 
     const searchInput = screen.getByPlaceholderText('Search releases')
     fireEvent.change(searchInput, {target: {value: 'Bundle 1'}})
@@ -65,10 +105,20 @@ describe('BundlesTable', () => {
     expect(mockSetSearchTerm).toHaveBeenCalledWith('Bundle 1')
   })
 
-  describe('A bundle row', () => {
-    it('should navigate to the bundle detail when clicked', async () => {
-      const bundles = [{_id: '123', title: 'Bundle 1', name: 'bundle-1'}] as BundleDocument[]
-      await renderBundlesTable(bundles)
+  describe('A release row', () => {
+    it('should navigate to the release detail when clicked', async () => {
+      const bundles = [
+        {
+          _id: '123',
+          title: 'Bundle 1',
+          name: 'bundle-1',
+          _createdAt: new Date().toISOString(),
+          documentsMetadata: {
+            documentCount: 1,
+          },
+        },
+      ] as TableBundle[]
+      await renderReleasesTable(bundles)
 
       const bundleRow = screen.getAllByTestId('bundle-row')[0]
       fireEvent.click(within(bundleRow).getByText('Bundle 1'))
@@ -77,8 +127,18 @@ describe('BundlesTable', () => {
     })
 
     it('should delete bundle when menu button is clicked', async () => {
-      const bundles = [{_id: '123', title: 'Bundle 1', name: 'bundle-1'}] as BundleDocument[]
-      await renderBundlesTable(bundles)
+      const bundles = [
+        {
+          _id: '123',
+          title: 'Bundle 1',
+          name: 'bundle-1',
+          _createdAt: new Date().toISOString(),
+          documentsMetadata: {
+            documentCount: 1,
+          },
+        },
+      ] as TableBundle[]
+      await renderReleasesTable(bundles)
 
       const bundleRow = screen.getAllByTestId('bundle-row')[0]
       fireEvent.click(within(bundleRow).getByLabelText('Release menu'))
@@ -87,11 +147,7 @@ describe('BundlesTable', () => {
       fireEvent.click(screen.getByText('Confirm'))
 
       await waitFor(() => {
-        expect(useBundleOperations().deleteBundle).toHaveBeenCalledWith({
-          _id: '123',
-          name: 'bundle-1',
-          title: 'Bundle 1',
-        })
+        expect(useBundleOperations().deleteBundle).toHaveBeenCalledWith(bundles[0])
         expect(useRouter().navigate).toHaveBeenCalledWith({bundleName: undefined})
       })
     })
diff --git a/packages/sanity/src/core/releases/contexts/BundlesMetadataProvider.tsx b/packages/sanity/src/core/releases/contexts/BundlesMetadataProvider.tsx
new file mode 100644
index 00000000000..381cbe8e915
--- /dev/null
+++ b/packages/sanity/src/core/releases/contexts/BundlesMetadataProvider.tsx
@@ -0,0 +1,101 @@
+import {useCallback, useContext, useEffect, useMemo, useState} from 'react'
+import {useObservable} from 'react-rx'
+import {useBundlesStore} from 'sanity'
+import {BundlesMetadataContext} from 'sanity/_singletons'
+
+import {type MetadataWrapper} from '../../store/bundles/createBundlesMetadataAggregator'
+import {type BundlesMetadata} from '../tool/useBundlesMetadata'
+
+const DEFAULT_METADATA_STATE: MetadataWrapper = {
+  data: null,
+  error: null,
+  loading: false,
+}
+
+const BundlesMetadataProviderInner = ({children}: {children: React.ReactNode}) => {
+  const [listenerBundleSlugs, setListenerBundleSlugs] = useState<string[]>([])
+  const {getMetadataStateForSlugs$} = useBundlesStore()
+  const [bundlesMetadata, setBundlesMetadata] = useState<Record<string, BundlesMetadata> | null>(
+    null,
+  )
+
+  const memoObservable = useMemo(
+    () => getMetadataStateForSlugs$(listenerBundleSlugs),
+    [getMetadataStateForSlugs$, listenerBundleSlugs],
+  )
+
+  const observedResult = useObservable(memoObservable) || DEFAULT_METADATA_STATE
+
+  // patch metadata in local state
+  useEffect(
+    () =>
+      setBundlesMetadata((prevBundleMetadata) => {
+        if (!observedResult.data) return prevBundleMetadata
+
+        return {...(prevBundleMetadata || {}), ...observedResult.data}
+      }),
+    [observedResult.data],
+  )
+
+  const addBundleSlugsToListener = useCallback((addBundleSlugs: string[]) => {
+    setListenerBundleSlugs((prevSlugs) => [...prevSlugs, ...addBundleSlugs])
+  }, [])
+
+  const removeBundleSlugsFromListener = useCallback((removeBundleSlugs: string[]) => {
+    setListenerBundleSlugs((prevSlugs) => {
+      const {nextSlugs} = prevSlugs.reduce<{removedSlugs: string[]; nextSlugs: string[]}>(
+        (acc, slug) => {
+          const {removedSlugs, nextSlugs: accNextSlugs} = acc
+          /**
+           * In cases where multiple consumers are listening to the same slug
+           * the slug will appear multiple times in listenerBundleSlugs array
+           * removing should only remove 1 instance of the slug and retain all others
+           */
+          if (removeBundleSlugs.includes(slug) && !removedSlugs.includes(slug)) {
+            return {removedSlugs: [...removedSlugs, slug], nextSlugs: accNextSlugs}
+          }
+          return {removedSlugs, nextSlugs: [...accNextSlugs, slug]}
+        },
+        {removedSlugs: [], nextSlugs: []},
+      )
+      return nextSlugs
+    })
+  }, [])
+
+  const context = useMemo<{
+    addBundleSlugsToListener: (slugs: string[]) => void
+    removeBundleSlugsFromListener: (slugs: string[]) => void
+    state: MetadataWrapper
+  }>(
+    () => ({
+      addBundleSlugsToListener,
+      removeBundleSlugsFromListener,
+      state: {...observedResult, data: bundlesMetadata},
+    }),
+    [addBundleSlugsToListener, bundlesMetadata, observedResult, removeBundleSlugsFromListener],
+  )
+
+  return (
+    <BundlesMetadataContext.Provider value={context}>{children}</BundlesMetadataContext.Provider>
+  )
+}
+
+export const BundlesMetadataProvider = ({children}: {children: React.ReactNode}) => {
+  const context = useContext(BundlesMetadataContext)
+
+  // Avoid mounting the provider if it's already provided by a parent
+  if (context) return children
+  return <BundlesMetadataProviderInner>{children}</BundlesMetadataProviderInner>
+}
+
+export const useBundlesMetadataProvider = () => {
+  const contextValue = useContext(BundlesMetadataContext)
+
+  return (
+    contextValue || {
+      state: DEFAULT_METADATA_STATE,
+      addBundleSlugsToListener: () => null,
+      removeBundleSlugsFromListener: () => null,
+    }
+  )
+}
diff --git a/packages/sanity/src/core/releases/plugin/ReleasesStudioLayout.tsx b/packages/sanity/src/core/releases/plugin/ReleasesStudioLayout.tsx
index e98bcbba5bb..b946153f9c5 100644
--- a/packages/sanity/src/core/releases/plugin/ReleasesStudioLayout.tsx
+++ b/packages/sanity/src/core/releases/plugin/ReleasesStudioLayout.tsx
@@ -1,13 +1,18 @@
 import {type LayoutProps} from '../../config'
 import {AddonDatasetProvider} from '../../studio'
+import {BundlesMetadataProvider} from '../contexts/BundlesMetadataProvider'
 
 export function ReleasesStudioLayout(props: LayoutProps) {
   // TODO: Replace for useReleasesEnabled
-  const {enabled, mode} = {enabled: true, mode: 'default'}
+  const {enabled} = {enabled: true}
 
   if (!enabled) {
     return props.renderDefault(props)
   }
 
-  return <AddonDatasetProvider>{props.renderDefault(props)}</AddonDatasetProvider>
+  return (
+    <AddonDatasetProvider>
+      <BundlesMetadataProvider>{props.renderDefault(props)}</BundlesMetadataProvider>
+    </AddonDatasetProvider>
+  )
 }
diff --git a/packages/sanity/src/core/releases/tool/ReleasesOverview.tsx b/packages/sanity/src/core/releases/tool/ReleasesOverview.tsx
index bf182418b2d..d12710a46ac 100644
--- a/packages/sanity/src/core/releases/tool/ReleasesOverview.tsx
+++ b/packages/sanity/src/core/releases/tool/ReleasesOverview.tsx
@@ -6,28 +6,39 @@ import {type MouseEventHandler, useCallback, useEffect, useMemo, useState} from
 import {Button as StudioButton} from '../../../ui-components'
 import {CreateBundleDialog} from '../../bundles/components/dialog/CreateBundleDialog'
 import {LoadingBlock} from '../../components/loadingBlock/LoadingBlock'
-import {useBundles} from '../../store/bundles'
 import {type BundleDocument} from '../../store/bundles/types'
-import {BundlesTable} from '../components/BundlesTable/BundlesTable'
+import {useBundles} from '../../store/bundles/useBundles'
+import {ReleasesTable, type TableBundle} from '../components/ReleasesTable/ReleasesTable'
 import {containsBundles} from '../types/bundle'
+import {useBundlesMetadata} from './useBundlesMetadata'
 
 type Mode = 'open' | 'archived'
 
 const EMPTY_BUNDLE_GROUPS = {open: [], archived: []}
 
 export function ReleasesOverview() {
-  const {data, loading} = useBundles()
-
+  const {data: bundles, loading: loadingBundles} = useBundles()
   const [bundleGroupMode, setBundleGroupMode] = useState<Mode>('open')
   const [isCreateBundleDialogOpen, setIsCreateBundleDialogOpen] = useState(false)
   const [searchTerm, setSearchTerm] = useState<string>()
-
-  const hasBundles = data && containsBundles(data)
+  const bundleSlugs = useMemo(() => bundles?.map((bundle) => bundle.name) || [], [bundles])
+  const {data: bundlesMetadata, loading: loadingBundlesMetadata} = useBundlesMetadata(bundleSlugs)
+  const loading = loadingBundles || loadingBundlesMetadata
+  const hasBundles = bundles && containsBundles(bundles)
   const loadingOrHasBundles = loading || hasBundles
 
+  const tableBundles = useMemo<TableBundle[]>(() => {
+    if (!bundles || !bundlesMetadata) return []
+
+    return bundles.map((bundle) => ({
+      ...bundle,
+      documentsMetadata: bundlesMetadata[bundle.name] || {},
+    }))
+  }, [bundles, bundlesMetadata])
+
   const groupedBundles = useMemo(
     () =>
-      data?.reduce<{open: BundleDocument[]; archived: BundleDocument[]}>((groups, bundle) => {
+      tableBundles.reduce<{open: TableBundle[]; archived: TableBundle[]}>((groups, bundle) => {
         const isBundleArchived =
           bundle.archivedAt ||
           (bundle.publishedAt && isBefore(new Date(bundle.publishedAt), new Date()))
@@ -35,7 +46,7 @@ export function ReleasesOverview() {
 
         return {...groups, [group]: [...groups[group], bundle]}
       }, EMPTY_BUNDLE_GROUPS) || EMPTY_BUNDLE_GROUPS,
-    [data],
+    [tableBundles],
   )
 
   // switch to open mode if on archived mode and there are no archived bundles
@@ -159,7 +170,7 @@ export function ReleasesOverview() {
           {loading ? (
             <LoadingBlock fill data-testid="bundle-table-loader" />
           ) : (
-            <BundlesTable
+            <ReleasesTable
               bundles={filteredBundles}
               searchTerm={searchTerm}
               setSearchTerm={setSearchTerm}
diff --git a/packages/sanity/src/core/releases/tool/__tests__/ReleasesOverview.test.tsx b/packages/sanity/src/core/releases/tool/__tests__/ReleasesOverview.test.tsx
index cc89ef15dc3..2e17bab5ea5 100644
--- a/packages/sanity/src/core/releases/tool/__tests__/ReleasesOverview.test.tsx
+++ b/packages/sanity/src/core/releases/tool/__tests__/ReleasesOverview.test.tsx
@@ -7,31 +7,42 @@ import {useBundles} from '../../../store/bundles'
 import {type BundleDocument} from '../../../store/bundles/types'
 import {releasesUsEnglishLocaleBundle} from '../../i18n'
 import {ReleasesOverview} from '../ReleasesOverview'
+import {type BundlesMetadata, useBundlesMetadata} from '../useBundlesMetadata'
 
-// TODO: move this to test for CreateBundleDialog
-jest.mock('../../../store/bundles/useBundleOperations', () => ({
-  useBundleOperations: jest.fn().mockReturnValue({deleteBundle: jest.fn()}),
+jest.mock('../useBundlesMetadata', () => ({
+  useBundlesMetadata: jest.fn(),
 }))
 
-jest.mock('../../../store/bundles', () => ({
+jest.mock('../../../store/bundles/useBundles', () => ({
   useBundles: jest.fn(),
 }))
 
+jest.mock('sanity', () => ({
+  useCurrentUser: jest.fn().mockReturnValue({id: 'user-id'}),
+}))
+
 jest.mock('sanity/router', () => ({
   ...(jest.requireActual('sanity/router') || {}),
   useRouter: jest.fn().mockReturnValue({state: {}, navigate: jest.fn()}),
 }))
 
-const mockUseBundleStore = useBundles as jest.Mock<typeof useBundles>
+const mockUseBundles = useBundles as jest.Mock<typeof useBundles>
+const mockUseBundlesMetadata = useBundlesMetadata as jest.Mock<typeof useBundlesMetadata>
 
 describe('ReleasesOverview', () => {
   describe('when loading bundles', () => {
     beforeEach(async () => {
-      mockUseBundleStore.mockReturnValue({
-        data: [],
+      mockUseBundles.mockReturnValue({
+        data: null,
         loading: true,
         dispatch: jest.fn(),
       })
+      mockUseBundlesMetadata.mockReturnValue({
+        loading: true,
+        fetching: true,
+        error: null,
+        data: null,
+      })
 
       const wrapper = await createWrapper({
         resources: [releasesUsEnglishLocaleBundle],
@@ -61,11 +72,17 @@ describe('ReleasesOverview', () => {
 
   describe('when no bundles are available', () => {
     beforeEach(async () => {
-      mockUseBundleStore.mockReturnValue({
+      mockUseBundles.mockReturnValue({
         data: [],
         loading: false,
         dispatch: jest.fn(),
       })
+      mockUseBundlesMetadata.mockReturnValue({
+        loading: false,
+        fetching: false,
+        error: null,
+        data: null,
+      })
       const wrapper = await createWrapper()
 
       return render(<ReleasesOverview />, {wrapper})
@@ -91,18 +108,41 @@ describe('ReleasesOverview', () => {
 
   describe('when bundles are loaded', () => {
     const bundles = [
-      {title: 'Bundle 1'},
-      {title: 'Bundle 2'},
-      {title: 'Bundle 3', publishedAt: new Date().toISOString()},
-      {title: 'Bundle 4', archivedAt: new Date().toISOString()},
-    ] as unknown as BundleDocument[]
+      {title: 'Bundle 1', name: 'bundle-1', _createdAt: new Date().toISOString()},
+      {title: 'Bundle 2', name: 'bundle-2', _createdAt: new Date().toISOString()},
+      {
+        title: 'Bundle 3',
+        publishedAt: new Date().toISOString(),
+        name: 'bundle-3',
+        _createdAt: new Date().toISOString(),
+      },
+      {
+        title: 'Bundle 4',
+        archivedAt: new Date().toISOString(),
+        name: 'bundle-4',
+        _createdAt: new Date().toISOString(),
+      },
+    ] as BundleDocument[]
 
     beforeEach(async () => {
-      mockUseBundleStore.mockReturnValue({
+      mockUseBundles.mockReturnValue({
         data: bundles,
         loading: false,
         dispatch: jest.fn(),
       })
+      mockUseBundlesMetadata.mockReturnValue({
+        loading: false,
+        fetching: false,
+        error: null,
+        data: Object.fromEntries(
+          bundles.map((bundle) => [
+            bundle.name,
+            {
+              documentCount: 1,
+            } as BundlesMetadata,
+          ]),
+        ),
+      })
       const wrapper = await createWrapper()
 
       return render(<ReleasesOverview />, {wrapper})
diff --git a/packages/sanity/src/core/releases/tool/detail/ReleaseDetail.tsx b/packages/sanity/src/core/releases/tool/detail/ReleaseDetail.tsx
index 4219f338293..e52baa1d896 100644
--- a/packages/sanity/src/core/releases/tool/detail/ReleaseDetail.tsx
+++ b/packages/sanity/src/core/releases/tool/detail/ReleaseDetail.tsx
@@ -87,12 +87,20 @@ export const ReleaseDetail = () => {
             {showPublishButton && (
               <Button icon={PublishIcon} disabled={isPublishButtonDisabled} text="Publish all" />
             )}
-            <BundleMenuButton bundle={bundle} />
+            <BundleMenuButton bundle={bundle} documentCount={bundleDocuments.length} />
           </Flex>
         </Flex>
       </Card>
     ),
-    [activeScreen, bundle, bundleHasDocuments, isPublishButtonDisabled, router, showPublishButton],
+    [
+      activeScreen,
+      bundle,
+      bundleDocuments.length,
+      bundleHasDocuments,
+      isPublishButtonDisabled,
+      router,
+      showPublishButton,
+    ],
   )
 
   if (loading) {
diff --git a/packages/sanity/src/core/releases/tool/useBundlesMetadata.ts b/packages/sanity/src/core/releases/tool/useBundlesMetadata.ts
new file mode 100644
index 00000000000..8792f9ae41d
--- /dev/null
+++ b/packages/sanity/src/core/releases/tool/useBundlesMetadata.ts
@@ -0,0 +1,52 @@
+import {useEffect, useState} from 'react'
+
+import {useBundlesMetadataProvider} from '../contexts/BundlesMetadataProvider'
+
+export interface BundlesMetadata {
+  /**
+   * The number of documents with the bundle version as a prefix
+   */
+  documentCount: number
+  /**
+   * The last time a document in the bundle was edited
+   */
+  updatedAt: string | null
+}
+
+export const useBundlesMetadata = (bundleSlugs: string[]) => {
+  const {addBundleSlugsToListener, removeBundleSlugsFromListener, state} =
+    useBundlesMetadataProvider()
+  const [responseData, setResponseData] = useState<Record<string, BundlesMetadata> | null>(null)
+
+  useEffect(() => {
+    addBundleSlugsToListener([...new Set(bundleSlugs)])
+
+    return () => removeBundleSlugsFromListener([...new Set(bundleSlugs)])
+  }, [addBundleSlugsToListener, bundleSlugs, removeBundleSlugsFromListener])
+
+  const {data} = state
+
+  useEffect(() => {
+    if (!data) return
+
+    const hasUpdatedMetadata =
+      !responseData || Object.entries(responseData).some(([key, value]) => value !== data[key])
+
+    if (hasUpdatedMetadata) {
+      const nextResponseData = Object.fromEntries(bundleSlugs.map((slug) => [slug, data[slug]]))
+
+      setResponseData(nextResponseData)
+    }
+  }, [bundleSlugs, data, responseData])
+
+  return {
+    error: state.error,
+    // loading is only for initial load
+    // changing listened to bundle slugs will not cause a re-load
+    loading: !responseData,
+    // fetching is true when performing initial load for a given set of bundle metadata
+    // changing listened to bundle slugs will cause a re-fetch
+    fetching: state.loading,
+    data: responseData,
+  }
+}
diff --git a/packages/sanity/src/core/store/_legacy/datastores.ts b/packages/sanity/src/core/store/_legacy/datastores.ts
index 9cbd18a76a6..ca8638506c6 100644
--- a/packages/sanity/src/core/store/_legacy/datastores.ts
+++ b/packages/sanity/src/core/store/_legacy/datastores.ts
@@ -280,21 +280,22 @@ export function useKeyValueStore(): KeyValueStore {
 export function useBundlesStore(): BundlesStore {
   const resourceCache = useResourceCache()
   const workspace = useWorkspace()
-  const {client} = useAddonDataset()
+  const {client: addOnClient} = useAddonDataset()
+  const studioClient = useClient(DEFAULT_STUDIO_CLIENT_OPTIONS)
 
   return useMemo(() => {
     const bundlesStore =
       resourceCache.get<BundlesStore>({
-        dependencies: [workspace, client],
+        dependencies: [workspace, addOnClient],
         namespace: 'BundlesStore',
-      }) || createBundlesStore({client})
+      }) || createBundlesStore({addOnClient, studioClient})
 
     resourceCache.set({
-      dependencies: [workspace, client],
+      dependencies: [workspace, addOnClient],
       namespace: 'BundlesStore',
       value: bundlesStore,
     })
 
     return bundlesStore
-  }, [client, resourceCache, workspace])
+  }, [addOnClient, resourceCache, studioClient, workspace])
 }
diff --git a/packages/sanity/src/core/store/bundles/createBundlesMetadataAggregator.ts b/packages/sanity/src/core/store/bundles/createBundlesMetadataAggregator.ts
new file mode 100644
index 00000000000..39ab13e71d2
--- /dev/null
+++ b/packages/sanity/src/core/store/bundles/createBundlesMetadataAggregator.ts
@@ -0,0 +1,124 @@
+import {
+  bufferTime,
+  catchError,
+  EMPTY,
+  filter,
+  iif,
+  merge,
+  type Observable,
+  of,
+  startWith,
+  switchMap,
+} from 'rxjs'
+import {type SanityClient} from 'sanity'
+
+import {type BundlesMetadata} from '../../releases/tool/useBundlesMetadata'
+
+export type BundlesMetadataMap = Record<string, BundlesMetadata>
+
+export type MetadataWrapper = {data: BundlesMetadataMap | null; error: null; loading: boolean}
+
+const getFetchQuery = (bundleSlugs: string[]) => {
+  // projection key must be string - cover the case that a bundle has a number as first char
+  const getSafeSlug = (slug: string) => `bundle_${slug.replaceAll('-', '_')}`
+
+  return bundleSlugs.reduce(
+    ({subquery: accSubquery, projection: accProjection}, bundleSlug) => {
+      const safeSlug = getSafeSlug(bundleSlug)
+
+      const subquery = `${accSubquery}"${safeSlug}": *[_id in path("${bundleSlug}.*")]{_updatedAt } | order(_updatedAt desc),`
+
+      // conforms to BundlesMetadata
+      const projection = `${accProjection}"${bundleSlug}": {
+              "updatedAt": ${safeSlug}[0]._updatedAt,
+              "documentCount": count(${safeSlug})
+            },`
+
+      return {subquery, projection}
+    },
+    {subquery: '', projection: ''},
+  )
+}
+
+/**
+ * @internal
+ *
+ * An initial fetch is made. This fetch is polled whenever a listener even is emitted
+ * Only bundles that have been mutated are re-fetched
+ *
+ * @returns an Observable that accepts a list of bundle slugs and returns a stream of metadata
+ */
+export const createBundlesMetadataAggregator = (client: SanityClient | null) => {
+  const aggregatorFetch$ = (
+    bundleSlugs: string[],
+    isInitialLoad: boolean = false,
+  ): Observable<MetadataWrapper> => {
+    if (!bundleSlugs?.length || !client) return EMPTY
+
+    const {subquery: queryAllDocumentsInBundleSlugs, projection: projectionToBundleMetadata} =
+      getFetchQuery(bundleSlugs)
+
+    const fetchData$ = client.observable
+      .fetch<BundlesMetadataMap>(
+        `{${queryAllDocumentsInBundleSlugs}}{${projectionToBundleMetadata}}`,
+      )
+      .pipe(
+        switchMap((response) => of({data: response, error: null, loading: false})),
+        catchError((error) => {
+          console.error('Failed to fetch bundle metadata', error)
+          return of({data: null, error, loading: false})
+        }),
+      )
+
+    // initially emit loading empty state if first fetch
+    return iif(
+      () => isInitialLoad,
+      fetchData$.pipe(startWith({loading: true, data: null, error: null})),
+      fetchData$,
+    )
+  }
+
+  const aggregatorListener$ = (bundleSlugs: string[]) => {
+    if (!bundleSlugs?.length || !client) return EMPTY
+
+    return client.observable
+      .listen(
+        `*[defined(_version) && (${bundleSlugs.reduce(
+          (accQuery, bundleSlug, index) =>
+            `${accQuery}${index === 0 ? '' : '||'} _id in path("${bundleSlug}.*")`,
+          '',
+        )})]`,
+        {},
+        {includeResult: true, visibility: 'query', events: ['mutation'], tag: 'bundle-docs.listen'},
+      )
+      .pipe(
+        catchError((error) => {
+          console.error('Failed to listen for bundle metadata', error)
+          return EMPTY
+        }),
+        bufferTime(1_000),
+        filter((entriesArray) => entriesArray.length > 0),
+        switchMap((entriesArray) => {
+          const mutatedBundleSlugs = entriesArray.reduce<string[]>((accBundleSlugs, event) => {
+            if ('type' in event && event.type === 'mutation') {
+              const bundleSlug = event.documentId.split('.')[0]
+              // de-dup mutated bundle slugs
+              if (accBundleSlugs.includes(bundleSlug)) return accBundleSlugs
+
+              return [...accBundleSlugs, bundleSlug]
+            }
+            return accBundleSlugs
+          }, [])
+
+          if (mutatedBundleSlugs.length) {
+            return aggregatorFetch$(mutatedBundleSlugs)
+          }
+
+          return EMPTY
+        }),
+      )
+  }
+
+  return (bundleSlugs: string[]) =>
+    merge(aggregatorFetch$(bundleSlugs, true), aggregatorListener$(bundleSlugs))
+}
diff --git a/packages/sanity/src/core/store/bundles/createBundlesStore.ts b/packages/sanity/src/core/store/bundles/createBundlesStore.ts
index 2d0dae7fd21..89f1b8f0177 100644
--- a/packages/sanity/src/core/store/bundles/createBundlesStore.ts
+++ b/packages/sanity/src/core/store/bundles/createBundlesStore.ts
@@ -20,6 +20,7 @@ import {
   timeout,
 } from 'rxjs'
 
+import {createBundlesMetadataAggregator} from './createBundlesMetadataAggregator'
 import {bundlesReducer, type bundlesReducerAction, type bundlesReducerState} from './reducer'
 import {type BundleDocument, type BundlesStore} from './types'
 
@@ -56,6 +57,7 @@ const INITIAL_STATE: bundlesReducerState = {
 
 const NOOP_BUNDLES_STORE: BundlesStore = {
   state$: EMPTY.pipe(startWith(INITIAL_STATE)),
+  getMetadataStateForSlugs$: () => EMPTY,
   dispatch: () => undefined,
 }
 
@@ -67,8 +69,11 @@ const NOOP_BUNDLES_STORE: BundlesStore = {
  * it will keep listening for the duration of the app's lifecycle. Subsequent subscriptions will be
  * given the latest state upon subscription.
  */
-export function createBundlesStore(context: {client: SanityClient | null}): BundlesStore {
-  const {client} = context
+export function createBundlesStore(context: {
+  addOnClient: SanityClient | null
+  studioClient: SanityClient | null
+}): BundlesStore {
+  const {addOnClient: client, studioClient} = context
 
   // While the comments dataset is initialising, this factory function will be called with an empty
   // `client` value. Return a noop store while the client is unavailable.
@@ -226,8 +231,11 @@ export function createBundlesStore(context: {client: SanityClient | null}): Bund
     shareReplay(1),
   )
 
+  const getMetadataStateForSlugs$ = createBundlesMetadataAggregator(studioClient)
+
   return {
     state$,
+    getMetadataStateForSlugs$,
     dispatch,
   }
 }
diff --git a/packages/sanity/src/core/store/bundles/types.ts b/packages/sanity/src/core/store/bundles/types.ts
index 83cd3e75f96..98afa8f35f3 100644
--- a/packages/sanity/src/core/store/bundles/types.ts
+++ b/packages/sanity/src/core/store/bundles/types.ts
@@ -4,6 +4,7 @@ import {type SanityDocument} from '@sanity/types'
 import {type Dispatch} from 'react'
 import {type Observable} from 'rxjs'
 
+import {type MetadataWrapper} from './createBundlesMetadataAggregator'
 import {type bundlesReducerAction, type bundlesReducerState} from './reducer'
 
 /**
@@ -34,5 +35,6 @@ export function isBundleDocument(doc: unknown): doc is BundleDocument {
  */
 export interface BundlesStore {
   state$: Observable<bundlesReducerState>
+  getMetadataStateForSlugs$: (slugs: string[]) => Observable<MetadataWrapper>
   dispatch: Dispatch<bundlesReducerAction>
 }
diff --git a/packages/sanity/src/core/store/bundles/useBundleOperations.ts b/packages/sanity/src/core/store/bundles/useBundleOperations.ts
index 7214eb5aac5..82055e43a3d 100644
--- a/packages/sanity/src/core/store/bundles/useBundleOperations.ts
+++ b/packages/sanity/src/core/store/bundles/useBundleOperations.ts
@@ -1,6 +1,7 @@
 import {type SanityDocument} from '@sanity/client'
 import {uuid} from '@sanity/uuid'
 import {useCallback} from 'react'
+import {useCurrentUser} from 'sanity'
 
 import {useClient} from '../../hooks'
 import {useAddonDataset} from '../../studio/addonDataset/useAddonDataset'
@@ -11,18 +12,20 @@ import {type BundleDocument} from './types'
 export function useBundleOperations() {
   const {client} = useAddonDataset()
   const studioClient = useClient(DEFAULT_STUDIO_CLIENT_OPTIONS)
+  const currentUser = useCurrentUser()
 
   const handleCreateBundle = useCallback(
     async (bundle: Partial<BundleDocument>) => {
       const document = {
         ...bundle,
         _type: 'bundle',
+        authorId: currentUser?.id,
         _id: bundle._id ?? uuid(),
       } as BundleDocument
       const res = await client?.createIfNotExists(document)
       return res
     },
-    [client],
+    [client, currentUser?.id],
   )
 
   const handleDeleteBundle = useCallback(