@@ -100,11 +100,20 @@ describe('Search MCP protocol', () => {
       expect(read.isError).not.toBe(true)
       expect(mocks.liveRead.mock.lastCall?.[0].input).toMatchObject({
         limit: 8,
-        scaleWindowWithLimit: true,
+        scaledWindow: { documentsInCall: 1 },
       })
       expect(read.content).toEqual([
         { type: 'text', text: expect.stringContaining('Read evidence') },
       ])
+      const batchRead = await client.callTool({
+        name: 'read_document',
+        arguments: { documentIds: [documentId, `${documentId}b`], limit: 8 },
+      })
+      expect(batchRead.isError).not.toBe(true)
+      expect(mocks.liveRead.mock.lastCall?.[0].input).toMatchObject({
+        limit: 8,
+        scaledWindow: { documentsInCall: 2 },
+      })
       const offsetless = await client.callTool({
         name: 'search',
         arguments: {
 
@@ -298,7 +298,7 @@ export function createKnowledgeMcpServer(context: KnowledgeMcpContext): McpServe
                 ...options,
                 documentId: id,
                 organizationId,
-                scaleWindowWithLimit: true,
+                scaledWindow: { documentsInCall: documentId ? 1 : batch.length },
                 resultSecretRegistry: registry,
                 signal,
               },
 
@@ -1210,25 +1210,37 @@ describe('authorized live retrieval', () => {
       return { length: chunk.content.length, next: read.next }
     }
 
+    const scaled = (documentsInCall: number) => ({ scaledWindow: { documentsInCall } })
+
     it('returns a proportionally longer window when a scaling caller asks for more chunks', async () => {
-      const { length, next } = await readWindow({ limit: 8, scaleWindowWithLimit: true })
+      const { length, next } = await readWindow({ limit: 8, ...scaled(1) })
       expect(length).toBe(21_333)
       expect(next).toEqual({ startChunkIndex: 0, startOffset: 21_333 })
     })
 
     it('continues a longer window from where the previous one ended', async () => {
-      const { length, next } = await readWindow({
-        limit: 8,
-        scaleWindowWithLimit: true,
-        startOffset: 21_333,
-      })
+      const { length, next } = await readWindow({ limit: 8, ...scaled(1), startOffset: 21_333 })
       expect(length).toBe(30_000 - 21_333)
       expect(next).toBeNull()
     })
 
     it.each([
-      ['at the default limit', { limit: 3, scaleWindowWithLimit: true }],
-      ['below the default limit', { limit: 1, scaleWindowWithLimit: true }],
+      [5, 1, 13_333],
+      [8, 2, 20_000],
+      [8, 3, 13_333],
+      [8, 4, 10_000],
+    ])(
+      'shares one call budget: limit %i across %i documents reads %i characters each',
+      async (limit, documentsInCall, expected) => {
+        expect((await readWindow({ limit, ...scaled(documentsInCall) })).length).toBe(expected)
+      }
+    )
+
+    it.each([
+      ['at the default limit', { limit: 3, ...scaled(1) }],
+      ['below the default limit', { limit: 1, ...scaled(1) }],
+      ['when the call budget is spread over five documents', { limit: 8, ...scaled(5) }],
+      ['when the call budget is spread over ten documents', { limit: 8, ...scaled(10) }],
       ['for a caller that does not scale', { limit: 8 }],
     ])('keeps the standard window %s', async (_, extra) => {
       expect((await readWindow(extra)).length).toBe(8_000)
 
@@ -291,15 +291,27 @@ const PREVIEW_CHARACTERS = 1800
 const READ_WINDOW_CHARACTERS = 8000
 /** The read limit {@link READ_WINDOW_CHARACTERS} is sized for, which is the default limit. */
 const READ_WINDOW_LIMIT = 3
+/**
+ * Characters the documents of one scaled read call share. It keeps the call's result, with about
+ * a thousand characters of metadata per document, under the 50,000-character size at which MCP
+ * clients such as Claude Code save a tool result to a file rather than show it.
+ */
+const SCALED_READ_CALL_CHARACTERS = 40_000
 
 /**
  * Characters one read returns. A live document is one chunk, so a caller that scales the window
- * gets a longer one when it asks for more chunks than the default; at or below the default, and
- * for every other caller, the window stays the standard page.
+ * gets a longer one when it asks for more chunks than the default, bounded by an even share of
+ * the call's budget across the documents it reads, and never shorter than the standard page. At
+ * or below the default limit, and for every other caller, the window is the standard page.
  */
-function readWindowCharacters(input: Pick<LiveReadInput, 'limit' | 'scaleWindowWithLimit'>) {
-  if (!input.scaleWindowWithLimit || input.limit <= READ_WINDOW_LIMIT) return READ_WINDOW_CHARACTERS
-  return Math.floor((READ_WINDOW_CHARACTERS * input.limit) / READ_WINDOW_LIMIT)
+function readWindowCharacters({
+  limit,
+  scaledWindow,
+}: Pick<LiveReadInput, 'limit' | 'scaledWindow'>) {
+  if (!scaledWindow || limit <= READ_WINDOW_LIMIT) return READ_WINDOW_CHARACTERS
+  const scaled = Math.floor((READ_WINDOW_CHARACTERS * limit) / READ_WINDOW_LIMIT)
+  const share = Math.floor(SCALED_READ_CALL_CHARACTERS / Math.max(1, scaledWindow.documentsInCall))
+  return Math.max(READ_WINDOW_CHARACTERS, Math.min(scaled, share))
 }
 
 /**
@@ -992,8 +1004,11 @@ export type LiveReadInput = ResourceOwner & {
   documentId: string
   filters?: WorkspaceSearchFilters
   limit: number
-  /** Lengthens the window for a limit above the default, as {@link readWindowCharacters} sizes it. */
-  scaleWindowWithLimit?: boolean
+  /**
+   * Lengthens the window for a limit above the default, sharing one call's budget across the
+   * documents it reads, as {@link readWindowCharacters} sizes it.
+   */
+  scaledWindow?: { documentsInCall: number }
   startChunkIndex?: number
   startOffset?: number
   resultSecretRegistry: ResolvedSecretTraceRegistry