diff --git a/packages/client/src/promise/generated/types.ts b/packages/client/src/promise/generated/types.ts
index c0bbf1cb451b..5b3526d2c636 100644
--- a/packages/client/src/promise/generated/types.ts
+++ b/packages/client/src/promise/generated/types.ts
@@ -2349,6 +2349,7 @@ export type ConfigEntry =
         experimental?: {
           portable_shell_scanner?: boolean
           todo?: boolean
+          precompute_compaction?: boolean
           subagent_depth?: number
           location_idle_timeout?: string | false
           policies?: Array<{
diff --git a/packages/core/src/config/normalize.ts b/packages/core/src/config/normalize.ts
index 4ef02b96e5e3..ab5204471870 100644
--- a/packages/core/src/config/normalize.ts
+++ b/packages/core/src/config/normalize.ts
@@ -476,6 +476,15 @@ function normalizeExperimental(
         )
         if (value !== undefined) result.todo = value
       }
+      if (own(experimental, "precompute_compaction")) {
+        const value = decodeEncoded(
+          ConfigExperimental.Info.fields.precompute_compaction,
+          experimental.precompute_compaction,
+          ["experimental", "precompute_compaction"],
+          diagnostics,
+        )
+        if (value !== undefined) result.precompute_compaction = value
+      }
       if (own(experimental, "subagent_depth")) {
         const value = decodeEncoded(
           ConfigExperimental.Info.fields.subagent_depth,
diff --git a/packages/core/src/config/plugin/compaction.ts b/packages/core/src/config/plugin/compaction.ts
index 7080d88836c5..c183aafd624d 100644
--- a/packages/core/src/config/plugin/compaction.ts
+++ b/packages/core/src/config/plugin/compaction.ts
@@ -13,6 +13,7 @@ export const Plugin = define({
     const compaction = yield* SessionCompaction.Service
     const loaded = yield* ConfigEntryObserver.observe(config, ctx.event, compaction.reload())
     yield* compaction.transform((editor) => {
+      editor.configure({ precompute: Config.latest(loaded.entries, "experimental")?.precompute_compaction === true })
       for (const entry of loaded.entries) {
         if (entry.type !== "document" || !entry.info.compaction) continue
         editor.configure({
diff --git a/packages/core/src/session/compaction.ts b/packages/core/src/session/compaction.ts
index 7b305d8d661f..a6b7f5d05cbb 100644
--- a/packages/core/src/session/compaction.ts
+++ b/packages/core/src/session/compaction.ts
@@ -18,7 +18,7 @@ import type { StreamOptions } from "@opencode/ai/route"
 import type { SessionCompactionResult } from "@opencode/plugin/effect/session"
 import type { SessionError } from "@opencode/schema/session-error"
 import { makeLocationNode } from "@opencode/util/effect/app-node"
-import { Context, Effect, Layer, Result, Stream } from "effect"
+import { Context, Effect, Exit, Fiber, Layer, Result, Scope, Stream } from "effect"
 import { Agent } from "../agent.js"
 import { Bus } from "../bus.js"
 import { Database } from "../database/database.js"
@@ -44,6 +44,8 @@ export type Settings = {
   buffer?: number
   /** Tokens of recent conversation kept verbatim beside the summary. */
   keep: number
+  /** Summarize in the background as the context nears the threshold, so automatic compaction can swap it in. */
+  precompute: boolean
 }
 
 export type Editor = {
@@ -64,6 +66,11 @@ export type Outcome =
 
 export interface Interface extends State.Transformable<Editor> {
   readonly compact: (trigger: Trigger) => Effect.Effect<Outcome>
+  /**
+   * Starts a background summary when the context nears the threshold. Never waits for it. Loads `context` only when
+   * background summaries are on.
+   */
+  readonly precompute: <E>(context: Effect.Effect<SessionContext.Loaded, E>) => Effect.Effect<void, E>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/SessionCompaction") {}
@@ -88,6 +95,26 @@ type Streamed = {
   readonly text: string
 }
 
+/** A summary run off the critical path: it covers only `messages`, streams no deltas, and bills into `usage`. */
+type Background = {
+  readonly messages: ReadonlyArray<SessionMessage.Info>
+  readonly usage: (usage: SessionUsage.Recorded) => void
+}
+
+/** A background summary of everything before `keepID`, held until automatic compaction is due. */
+type Precomputed = {
+  readonly firstID: SessionMessage.ID | undefined
+  readonly keepID: SessionMessage.ID
+  readonly model: SessionContext.Loaded["model"]["ref"]
+  readonly initial: string
+  /** The longest tail since `keepID` that compaction still accepts beside this summary. */
+  readonly tailLimit: number
+  /** Background summaries that failed since the last compaction, this one included once it has. */
+  readonly failures: number
+  readonly usage: SessionUsage.Recorded[]
+  readonly fiber: Fiber.Fiber<Result, Failure>
+}
+
 const NOTHING_TO_COMPACT: Failure = { error: { type: "compaction.unavailable", message: "Nothing to compact yet" } }
 /** After each "too long" rejection, the next attempt aims at this share of the first rejected request's size. */
 const SHRINK_STEPS = [0.7, 0.5, 0.35]
@@ -105,6 +132,18 @@ const UNKNOWN_WINDOW = 200_000
 const SUMMARY_OUTPUT_FLOOR = 32_000
 const IMAGE_TOKEN_ESTIMATE = 1_500
 const PDF_TOKEN_ESTIMATE = 2_000
+/** Share of the compaction ceiling at which a background summary starts. */
+const PRECOMPUTE_RATIO = 0.85
+/** Measured prompt tokens below which a background summary is not worth its cost. */
+const PRECOMPUTE_MIN_TOKENS = 64_000
+/**
+ * The most text a swapped-in summary keeps verbatim beside it: twice `keep`, at least 30k, at most a quarter of the
+ * budget. A longer tail would leave the context near the threshold, so compaction summarizes from scratch instead.
+ */
+const PRECOMPUTED_TAIL_MIN = 30_000
+const PRECOMPUTED_TAIL_SHARE = 0.25
+/** Failed background summaries after which no new one starts until the next compaction. */
+const PRECOMPUTE_MAX_FAILURES = 2
 
 const SUMMARY_TEMPLATE = `You MUST use this format for your response (you may omit sections that aren't applicable). Do not include the <template> tags in your response.
 <template>
@@ -197,9 +236,12 @@ export const layer = Layer.effect(
     const db = (yield* Database.Service).db
     const requests = yield* SessionModelRequest.Service
 
+    const scope = yield* Scope.Scope
+    const precomputed = new Map<SessionContext.Loaded["session"]["id"], Precomputed>()
+
     const state = State.create<Settings, Editor>({
       name: "session-compaction",
-      initial: () => ({ auto: true, keep: 15_000 }),
+      initial: () => ({ auto: true, keep: 15_000, precompute: false }),
       editor: (settings) => ({
         configure: (update) => {
           Object.assign(settings, update)
@@ -207,15 +249,12 @@ export const layer = Layer.effect(
       }),
     })
 
-    const compact = Effect.fn("SessionCompaction.compact")(function* (trigger: Trigger): Effect.fn.Return<Outcome> {
-      const settings = state.get()
-      const context = trigger.context
-
-      // Only the user compacts when automatic compaction is off, overflow included.
-      if (trigger.reason !== "manual" && !settings.auto) return { status: "skipped" }
-      if (trigger.reason === "auto" && !due(context, calculateCeiling(context.model.limit, settings.buffer)))
-        return { status: "skipped" }
-      const native = context.model.compaction?.type === "native"
+    /** The model that writes the summary, and the request size it aims for. */
+    const selectModel = Effect.fnUntraced(function* (
+      context: SessionContext.Loaded,
+      buffer: number | undefined,
+      native: boolean,
+    ) {
       const agent = native ? undefined : yield* agents.get(Agent.ID.make("compaction"))
       const model =
         (agent?.model &&
@@ -223,19 +262,43 @@ export const layer = Layer.effect(
             .resolve({ ...context.session, model: agent.model }, catalog.available)
             .pipe(Effect.orElseSucceed(() => undefined)))) ??
         context.model
-      const ceiling = calculateCeiling(model.limit, settings.buffer)
+      const ceiling = calculateCeiling(model.limit, buffer)
       // An unknown window never triggers auto compaction, but the compaction request still needs a size to aim for.
       const cap = Number.isFinite(ceiling)
         ? ceiling
-        : calculateCeiling({ ...model.limit, context: UNKNOWN_WINDOW }, settings.buffer)
+        : calculateCeiling({ ...model.limit, context: UNKNOWN_WINDOW }, buffer)
+      return { context: model === context.model ? context : { ...context, model }, cap }
+    })
+
+    const compact = Effect.fn("SessionCompaction.compact")(function* (trigger: Trigger): Effect.fn.Return<Outcome> {
+      const settings = state.get()
+      const context = trigger.context
+
+      // Only the user compacts when automatic compaction is off, overflow included.
+      if (trigger.reason !== "manual" && !settings.auto) return { status: "skipped" }
+      if (trigger.reason === "auto" && !due(context, calculateCeiling(context.model.limit, settings.buffer)))
+        return { status: "skipped" }
+      const held = precomputed.get(context.session.id)
+      precomputed.delete(context.session.id)
+      const native = context.model.compaction?.type === "native"
+      const model = yield* selectModel(context, settings.buffer, native)
       // The provider just rejected this context, so the estimate ran low; the first attempt already aims below it.
       const budget =
-        trigger.reason === "overflow" ? Math.min(cap, Math.floor(estimateContext(context) * SHRINK_STEPS[0])) : cap
-
-      const selected = model === context.model ? trigger : { ...trigger, context: { ...context, model } }
-      const compaction = native
-        ? compactNatively(selected, budget, settings.keep)
-        : summarize(selected, budget, settings.keep)
+        trigger.reason === "overflow"
+          ? Math.min(model.cap, Math.floor(estimateContext(context) * SHRINK_STEPS[0]))
+          : model.cap
+
+      const selected = model.context === context ? trigger : { ...trigger, context: model.context }
+      // The runner opened the manual compaction's message when it delivered the `/compact` item. An automatic one
+      // opens here, before any wait, so a background summary still being written shows as a running compaction.
+      if (trigger.reason !== "manual")
+        yield* bus.publish(SessionEvent.Compaction.Started, { sessionID: context.session.id, reason: "auto" })
+      const swapped = held ? yield* usePrecomputed(selected, held, budget, settings) : undefined
+      const compaction = swapped
+        ? Effect.succeed(swapped)
+        : native
+          ? compactNatively(selected, budget, settings.keep)
+          : summarize(selected, budget, settings.keep)
       return yield* compaction.pipe(
         Effect.matchEffect({
           onSuccess: (result) => publish(selected, result),
@@ -244,6 +307,94 @@ export const layer = Layer.effect(
       )
     })
 
+    /**
+     * Once the context passes `PRECOMPUTE_RATIO` of the ceiling, summarizes everything before the latest response in
+     * the background. That is the prefix the provider just processed, so the summary request reads it from the prompt
+     * cache. The summary is held, not applied: swapping it in now would rewrite the prefix and throw away the cache
+     * for every step until compaction is actually due. One summary is held per Session until compaction takes it, or
+     * until it fails or falls too far behind, when a newer response replaces it.
+     */
+    const precompute = Effect.fn("SessionCompaction.precompute")(function* <E>(
+      load: Effect.Effect<SessionContext.Loaded, E>,
+    ) {
+      const settings = state.get()
+      if (!settings.precompute || !settings.auto) return
+      const context = yield* load
+      if (context.model.compaction?.type === "native") return
+      const ceiling = calculateCeiling(context.model.limit, settings.buffer)
+      if (!Number.isFinite(ceiling) || due(context, ceiling)) return
+      if (estimateContext(context) < ceiling * PRECOMPUTE_RATIO) return
+
+      const anchorIndex = context.messages.findLastIndex((message) => hasMeasuredPrompt(message, context.model.ref))
+      const anchor = context.messages[anchorIndex]
+      if (anchorIndex <= 0 || anchor?.type !== "assistant" || !anchor.tokens) return
+      if (anchor.tokens.input + anchor.tokens.cache.read + anchor.tokens.cache.write < PRECOMPUTE_MIN_TOKENS) return
+
+      const sessionID = context.session.id
+      const existing = precomputed.get(sessionID)
+      const exit = existing?.fiber.pollUnsafe()
+      const failed = exit !== undefined && Exit.isFailure(exit)
+      const failures = (existing?.failures ?? 0) + (failed ? 1 : 0)
+      if (existing) {
+        const index = heldIndex(existing, context)
+        if (index >= 0 && !failed && tailTokens(context, index) <= existing.tailLimit) return
+        // Summarizing up to the same response again would repeat the same request.
+        if (index >= 0 && (existing.keepID === anchor.id || failures >= PRECOMPUTE_MAX_FAILURES)) return
+        yield* Fiber.interrupt(existing.fiber)
+        precomputed.delete(sessionID)
+      }
+      // After a model switch nothing is cached for the new model yet; wait until its first response has written it.
+      if (anchor.model.id !== context.model.ref.id || anchor.model.variant !== context.model.ref.variant) return
+
+      const model = yield* selectModel(context, settings.buffer, false)
+      const usage: SessionUsage.Recorded[] = []
+      const fiber = yield* summarize({ reason: "auto", context: model.context }, model.cap, settings.keep, {
+        messages: context.messages.slice(0, anchorIndex),
+        usage: (recorded) => usage.push(recorded),
+      }).pipe(Effect.forkIn(scope))
+      precomputed.set(sessionID, {
+        firstID: context.messages[0]?.id,
+        keepID: anchor.id,
+        model: context.model.ref,
+        initial: context.initial,
+        tailLimit: tailLimit(settings.keep, model.cap),
+        failures,
+        usage,
+        fiber,
+      })
+    })
+
+    /**
+     * The held summary plus everything since it, kept verbatim, when it still describes this conversation and that
+     * tail is short. Waits for a summary still being written. Undefined, after stopping the background work, when it
+     * cannot be used; compaction then summarizes as usual.
+     */
+    const usePrecomputed = Effect.fnUntraced(function* (
+      trigger: Trigger,
+      held: Precomputed,
+      budget: number,
+      settings: Settings,
+    ): Effect.fn.Return<Result | undefined> {
+      const context = trigger.context
+      const index = heldIndex(held, context)
+      const usable =
+        settings.precompute &&
+        trigger.reason !== "overflow" &&
+        context.model.compaction?.type !== "native" &&
+        index >= 0 &&
+        tailTokens(context, index) <= tailLimit(settings.keep, budget)
+      if (!usable) {
+        yield* Fiber.interrupt(held.fiber)
+        return undefined
+      }
+
+      const exit = yield* Fiber.await(held.fiber).pipe(Effect.onInterrupt(() => Fiber.interrupt(held.fiber)))
+      if (Exit.isFailure(exit)) return undefined
+      // Background calls were billed as they finished; the compaction's message still shows what it cost.
+      held.usage.forEach((usage) => addSpent(context.session.id, usage))
+      return { ...exit.value, metadata: { keepID: held.keepID, ...exit.value.metadata } }
+    })
+
     const due = (context: SessionContext.Loaded, ceiling: number) => {
       const messages = context.messages
       // A compaction just completed; let the runner rebuild the request from it first.
@@ -279,16 +430,20 @@ export const layer = Layer.effect(
       trigger: Trigger,
       budget: number,
       keep: number,
+      background?: Background,
     ): Effect.fn.Return<Result, Failure> {
       const context = trigger.context
-      const split = splitConversation(context.messages, keep)
+      const messages = background?.messages ?? context.messages
+      const split = splitConversation(messages, keep)
       if (split === undefined) return yield* Effect.fail(NOTHING_TO_COMPACT)
+      // A background summary covers all of its messages; what follows them is kept when it is swapped in.
+      const keepID = background ? undefined : split.keepID
 
-      const previous = previousCompaction(context.messages)
+      const previous = previousCompaction(messages)
       const prompt = buildPrompt(previous !== undefined, previous?.summary.includes(LEGACY_HEADING) ?? false)
       const headings = SUMMARY_TEMPLATE.split("\n").filter((line) => line.startsWith("##"))
       const filled = (text: string) => text.split("\n").some((line) => headings.includes(line.trim()))
-      const prepared = yield* prepare(context, context.messages, budget)
+      const prepared = yield* prepare(context, messages, budget)
 
       // Hooks saw the request without the summary prompt, so it is appended here. A reply that ignores the
       // template gets one reminder before it counts as a failure.
@@ -298,14 +453,14 @@ export const layer = Layer.effect(
             LLMRequest.update(request, { messages: [...request.messages, Message.user(prompt)] }),
             context.model.limit,
           )
-          const reply = yield* stream(context, prompted, prepared.options)
+          const reply = yield* stream(context, prompted, prepared.options, background)
           if (filled(reply.text)) return reply
 
           const nudged = fitOutput(
             LLMRequest.update(prompted, { messages: [...prompted.messages, Message.user(NUDGE)] }),
             context.model.limit,
           )
-          const retry = yield* stream(context, nudged, prepared.options)
+          const retry = yield* stream(context, nudged, prepared.options, background)
           if (filled(retry.text)) return retry
           return yield* Effect.fail<Failure>({
             error: {
@@ -324,13 +479,17 @@ export const layer = Layer.effect(
       // for the tail would leave them in neither the summary nor the tail. Where 15% of the window is under
       // `RESERVE_MIN`, the ceiling equals `summaryRoom`, so automatic compaction always takes this fallback.
       const fit = trigger.reason === "overflow" ? budget : Math.max(budget, summaryRoom(context.model.limit))
-      const result = yield* deliver(trigger, prepared, budget - overhead, send, {
-        fit: fit - overhead,
-        history: withoutTail(prepared.request, split.keepID),
-      })
-      if (!split.keepID) return result
+      const result = yield* deliver(
+        trigger,
+        prepared,
+        budget - overhead,
+        send,
+        { fit: fit - overhead, history: withoutTail(prepared.request, keepID) },
+        background,
+      )
+      if (!keepID) return result
       // A compaction hook may choose its own kept range.
-      return { ...result, metadata: { keepID: split.keepID, ...result.metadata } }
+      return { ...result, metadata: { keepID, ...result.metadata } }
     })
 
     /**
@@ -402,13 +561,10 @@ export const layer = Layer.effect(
       target: number,
       send: (request: LLMRequest) => Effect.Effect<Result, AIError | Failure>,
       shrink: { readonly fit: number; readonly history: LLMRequest } = { fit: target, history: prepared.request },
+      background?: Background,
     ): Effect.fn.Return<Result, Failure> {
       const context = trigger.context
-      // The runner opened the manual compaction's message when it delivered the `/compact` item.
-      if (trigger.reason !== "manual") {
-        yield* bus.publish(SessionEvent.Compaction.Started, { sessionID: context.session.id, reason: "auto" })
-      }
-      if (prepared.event.result) return yield* fromHook(context, prepared.event.result)
+      if (prepared.event.result) return yield* fromHook(context, prepared.event.result, background)
 
       const policy = yield* SessionRunnerRetry.policy(context.session.id)
       let rejections = 0
@@ -527,7 +683,12 @@ export const layer = Layer.effect(
       })
     }
 
-    const stream = (context: SessionContext.Loaded, request: LLMRequest, options: StreamOptions) => {
+    const stream = (
+      context: SessionContext.Loaded,
+      request: LLMRequest,
+      options: StreamOptions,
+      background?: Background,
+    ) => {
       const sessionID = context.session.id
       const unusable = (error: SessionError.Error) => Effect.fail<Failure>({ error })
 
@@ -546,13 +707,15 @@ export const layer = Layer.effect(
             }
 
             if (LLMEvent.is.textDelta(event)) {
-              return bus
-                .publish(SessionEvent.Compaction.Delta, { sessionID, text: event.text })
-                .pipe(Effect.as({ ...streamed, text: streamed.text + event.text }))
+              const next = { ...streamed, text: streamed.text + event.text }
+              if (background) return Effect.succeed(next)
+              return bus.publish(SessionEvent.Compaction.Delta, { sessionID, text: event.text }).pipe(Effect.as(next))
             }
 
             if (LLMEvent.is.stepFinish(event)) {
-              return spend(sessionID, SessionUsage.record(event.usage, context.model.cost)).pipe(Effect.as(streamed))
+              return spend(sessionID, SessionUsage.record(event.usage, context.model.cost), background?.usage).pipe(
+                Effect.as(streamed),
+              )
             }
 
             if (!LLMEvent.is.finish(event)) return Effect.succeed(streamed)
@@ -613,12 +776,12 @@ export const layer = Layer.effect(
     }
 
     /** A request hook supplied the summary itself, so no model call happens. */
-    const fromHook = (context: SessionContext.Loaded, supplied: SessionCompactionResult) => {
+    const fromHook = (context: SessionContext.Loaded, supplied: SessionCompactionResult, background?: Background) => {
       const usage = supplied.tokens && {
         tokens: supplied.tokens,
         cost: SessionUsage.calculateCost(context.model.cost, supplied.tokens),
       }
-      return spend(context.session.id, usage).pipe(
+      return spend(context.session.id, usage, background?.usage).pipe(
         Effect.as<Result>({
           text: supplied.summary,
           native: supplied.native,
@@ -629,14 +792,22 @@ export const layer = Layer.effect(
 
     /**
      * Each model call is billed as soon as it finishes, so failed and interrupted compactions are billed too. The
-     * compaction's message shows the total across all of its calls. A session never runs two compactions at once.
+     * compaction's message shows the total across all of its calls. A session never runs two compactions at once;
+     * a background summary keeps its own total until a compaction takes it.
      */
     const spent = new Map<SessionContext.Loaded["session"]["id"], SessionUsage.Recorded>()
-    const spend = (sessionID: SessionContext.Loaded["session"]["id"], usage: SessionUsage.Recorded | undefined) =>
+    const addSpent = (sessionID: SessionContext.Loaded["session"]["id"], usage: SessionUsage.Recorded) => {
+      const total = spent.get(sessionID)
+      spent.set(sessionID, total ? SessionUsage.add(total, usage) : usage)
+    }
+    const spend = (
+      sessionID: SessionContext.Loaded["session"]["id"],
+      usage: SessionUsage.Recorded | undefined,
+      record = (recorded: SessionUsage.Recorded) => addSpent(sessionID, recorded),
+    ) =>
       Effect.gen(function* () {
         if (!usage) return
-        const total = spent.get(sessionID)
-        spent.set(sessionID, total ? SessionUsage.add(total, usage) : usage)
+        record(usage)
         yield* bus.publish(SessionEvent.UsageRecorded, { sessionID, source: "compaction", ...usage })
       })
 
@@ -688,6 +859,7 @@ export const layer = Layer.effect(
           ),
           Effect.ensuring(Effect.sync(() => spent.delete(trigger.context.session.id))),
         ),
+      precompute,
     })
   }),
 )
@@ -698,6 +870,24 @@ export const node = makeLocationNode({
   deps: [Agent.node, Bus.node, Database.node, llmClient, Model.node, SessionModelRequest.node, SessionRunnerModel.node],
 })
 
+/**
+ * Where the messages kept beside a held summary start, or -1 when the summary no longer describes this
+ * conversation: a compaction or revert since replaced its start, or the model or instructions changed.
+ */
+const heldIndex = (held: Precomputed, context: SessionContext.Loaded) => {
+  if (held.firstID !== context.messages[0]?.id || held.initial !== context.initial) return -1
+  if (held.model.providerID !== context.model.ref.providerID || held.model.id !== context.model.ref.id) return -1
+  if (held.model.variant !== context.model.ref.variant) return -1
+  return context.messages.findIndex((message) => message.id === held.keepID)
+}
+
+/** Estimated text a swapped-in summary keeps verbatim: every message from `index` on. */
+const tailTokens = (context: SessionContext.Loaded, index: number) =>
+  Token.estimate(context.messages.slice(index).map(SessionRecentText.messageToText).filter(Boolean).join("\n\n"))
+
+const tailLimit = (keep: number, budget: number) =>
+  Math.min(Math.max(keep * 2, PRECOMPUTED_TAIL_MIN), Math.floor(budget * PRECOMPUTED_TAIL_SHARE))
+
 /** History loads from the latest completed compaction, so a previous one is always the first message. */
 const previousCompaction = (messages: ReadonlyArray<SessionMessage.Info>) => {
   const [first] = messages
diff --git a/packages/core/src/session/runner/llm.ts b/packages/core/src/session/runner/llm.ts
index 17a0bd9be1b0..728a736531ff 100644
--- a/packages/core/src/session/runner/llm.ts
+++ b/packages/core/src/session/runner/llm.ts
@@ -217,6 +217,7 @@ const layer = Layer.effect(
           assistantMessageID = SessionMessage.ID.create()
           continue
         }
+        yield* compaction.precompute(Effect.succeed(loaded))
         const stepLimitReached = loaded.agent.info.steps !== undefined && step >= loaded.agent.info.steps
         const transcript = SessionModelRequest.baseTranscript({
           agent: loaded.agent.info,
@@ -265,7 +266,14 @@ const layer = Layer.effect(
           ),
         })
         const completed = yield* SessionStep.Outcome.$match(outcome, {
-          Completed: (outcome) => Effect.succeed(outcome.needsContinuation),
+          Completed: Effect.fnUntraced(function* (outcome) {
+            // The Session is about to go idle, which leaves the background summary time to finish.
+            if (!outcome.needsContinuation)
+              yield* compaction.precompute(
+                store.context(sessionID).pipe(Effect.map((messages) => ({ ...loaded, messages }))),
+              )
+            return outcome.needsContinuation
+          }),
           Retry: (outcome) =>
             retry.wait({
               decision: outcome.decision,
diff --git a/packages/core/test/config/normalization.test.ts b/packages/core/test/config/normalization.test.ts
index 7725b7ff43e1..4ef921b1f503 100644
--- a/packages/core/test/config/normalization.test.ts
+++ b/packages/core/test/config/normalization.test.ts
@@ -525,6 +525,7 @@ describe("ConfigNormalize", () => {
         experimental: {
           portable_shell_scanner: true,
           todo: true,
+          precompute_compaction: true,
           subagent_depth: 0,
           location_idle_timeout: "2 hours",
           policies: [{ action: "provider.use", resource: "custom", effect: "allow" }],
@@ -534,6 +535,7 @@ describe("ConfigNormalize", () => {
       experimental: {
         portable_shell_scanner: true,
         todo: true,
+        precompute_compaction: true,
         subagent_depth: 0,
         location_idle_timeout: "7200000 millis",
       },
diff --git a/packages/core/test/session-compaction.test.ts b/packages/core/test/session-compaction.test.ts
index 85eb563db4cc..52f9e248f14a 100644
--- a/packages/core/test/session-compaction.test.ts
+++ b/packages/core/test/session-compaction.test.ts
@@ -23,16 +23,19 @@ import { Project } from "@opencode/core/project"
 import { ProjectTable } from "@opencode/core/project/sql"
 import { App } from "@opencode/core/app"
 import { Agent } from "@opencode/core/agent"
+import { Model } from "@opencode/core/model"
 import { Provider } from "@opencode/core/provider"
 import { AbsolutePath } from "@opencode/core/schema"
 import { Money } from "@opencode/schema/money"
 import { Skill } from "@opencode/schema/skill"
 import { Shell } from "@opencode/schema/shell"
-import { DateTime, Effect, Fiber, Layer, Schema, Stream } from "effect"
+import { DateTime, Deferred, Effect, Fiber, Layer, Schema, Stream } from "effect"
 import { asc, eq } from "drizzle-orm"
 import { testEffect } from "./lib/effect"
 
 let requests: LLMRequest[] = []
+/** Runs before a request's response streams; tests hold it back to keep a background summary in flight. */
+let beforeResponse: Effect.Effect<void> = Effect.void
 const model = LanguageModel.make({
   id: "summary-model",
   provider: "test",
@@ -51,23 +54,28 @@ const cost = [
 const client = Layer.mock(LLMClient.Service)({
   stream: (request: LLMRequest) => {
     requests.push(request)
-    return Stream.make(
-      LLMEvent.textDelta({ id: "summary", text: "## Objective\n- manual summary" }),
-      LLMEvent.stepFinish({
-        index: 0,
-        reason: { normalized: "stop" },
-        usage: {
-          inputTokens: 15,
-          outputTokens: 6,
-          nonCachedInputTokens: 10,
-          cacheReadInputTokens: 3,
-          cacheWriteInputTokens: 2,
-          reasoningTokens: 2,
-        },
-      }),
-      LLMEvent.finish({
-        reason: { normalized: "stop" },
-      }),
+    return Stream.fromEffect(beforeResponse).pipe(
+      Stream.drain,
+      Stream.concat(
+        Stream.make(
+          LLMEvent.textDelta({ id: "summary", text: "## Objective\n- manual summary" }),
+          LLMEvent.stepFinish({
+            index: 0,
+            reason: { normalized: "stop" },
+            usage: {
+              inputTokens: 15,
+              outputTokens: 6,
+              nonCachedInputTokens: 10,
+              cacheReadInputTokens: 3,
+              cacheWriteInputTokens: 2,
+              reasoningTokens: 2,
+            },
+          }),
+          LLMEvent.finish({
+            reason: { normalized: "stop" },
+          }),
+        ),
+      ),
     )
   },
   generate: () => Effect.die("unused"),
@@ -856,3 +864,230 @@ it.effect("forked session compaction reuses the fork root prompt cache key", ()
     expect(requests[0]?.promptCacheKey).toBe(rootID)
   }),
 )
+
+const measured = (text: string, input: number) =>
+  Schema.decodeUnknownSync(SessionMessage.Assistant)({
+    id: SessionMessage.ID.create(),
+    type: "assistant",
+    agent: Agent.defaultID,
+    model: { id: "summary-model", providerID: "test" },
+    content: [{ type: "text", text }],
+    tokens: { input, output: 100, reasoning: 0, cache: { read: 0, write: 0 } },
+    time: { created: 0, completed: 1 },
+  })
+
+/**
+ * A 200k window compacts at 170k and starts a background summary at 85% of that, 144.5k. `near` ends past that
+ * point; `due` continues it past the threshold.
+ */
+const precomputeHistory = () => {
+  const near = [textUser("First question"), measured("First answer", 80_000), textUser("Second question")]
+  const anchor = measured("Second answer", 156_000)
+  const due = [...near, anchor, textUser("Third question"), measured("Third answer", 182_000)]
+  return { near: [...near, anchor], due, anchor }
+}
+
+const enablePrecompute = Effect.gen(function* () {
+  const compaction = yield* SessionCompaction.Service
+  yield* compaction.transform((editor) => editor.configure({ precompute: true }))
+  return compaction
+})
+
+it.effect("background summaries stay off unless enabled", () =>
+  Effect.gen(function* () {
+    requests = []
+    const compaction = yield* SessionCompaction.Service
+    const session = yield* insertSession(Session.ID.make("ses_precompute_off"))
+    const history = precomputeHistory()
+
+    yield* compaction.precompute(Effect.succeed(loaded(session, history.near)))
+    expect(yield* compaction.compact({ reason: "auto", context: loaded(session, history.due) })).toEqual({
+      status: "completed",
+    })
+    expect(requests).toHaveLength(1)
+    expect(JSON.stringify(requests[0].messages)).toContain("Third answer")
+  }),
+)
+
+it.effect("automatic compaction swaps in the background summary without another model call", () =>
+  Effect.gen(function* () {
+    requests = []
+    const db = (yield* Database.Service).db
+    const store = yield* SessionStore.Service
+    const compaction = yield* enablePrecompute
+    const sessionID = Session.ID.make("ses_precompute_swap")
+    const session = yield* insertSession(sessionID)
+    const history = precomputeHistory()
+    yield* storeMessages(sessionID, history.due)
+
+    yield* compaction.precompute(Effect.succeed(loaded(session, history.near)))
+    expect(yield* compaction.compact({ reason: "auto", context: loaded(session, history.due) })).toEqual({
+      status: "completed",
+    })
+
+    // The one request summarized the prefix the latest response was generated from.
+    expect(requests).toHaveLength(1)
+    expect(JSON.stringify(requests[0].messages)).toContain("Second question")
+    expect(JSON.stringify(requests[0].messages)).not.toContain("Second answer")
+    expect(yield* store.context(sessionID)).toMatchObject([
+      {
+        type: "compaction",
+        reason: "auto",
+        summary: "## Objective\n- manual summary",
+        metadata: {
+          keepID: history.anchor.id,
+          recent: "[Assistant]: Second answer\n\n[User]: Third question\n\n[Assistant]: Third answer",
+        },
+        tokens: { input: 10, output: 4, reasoning: 2, cache: { read: 3, write: 2 } },
+      },
+    ])
+    // The background call is billed once, when it finishes, and the compaction ends after it.
+    const types = (yield* db
+      .select({ type: EventTable.type })
+      .from(EventTable)
+      .where(eq(EventTable.aggregate_id, sessionID))
+      .orderBy(asc(EventTable.seq))
+      .all()
+      .pipe(Effect.orDie)).map((row) => row.type)
+    expect(types.at(-1)).toBe(Bus.versionedType(SessionEvent.Compaction.Ended.type, 1))
+    expect(types.toSorted()).toEqual(
+      [
+        Bus.versionedType(SessionEvent.UsageRecorded.type, 1),
+        Bus.versionedType(SessionEvent.Compaction.Started.type, 1),
+        Bus.versionedType(SessionEvent.Compaction.Ended.type, 1),
+      ].toSorted(),
+    )
+  }),
+)
+
+it.effect("automatic compaction waits for a background summary still being written", () =>
+  Effect.gen(function* () {
+    requests = []
+    const release = yield* Deferred.make<void>()
+    beforeResponse = Deferred.await(release)
+    const bus = yield* Bus.Service
+    const compaction = yield* enablePrecompute
+    const session = yield* insertSession(Session.ID.make("ses_precompute_join"))
+    const history = precomputeHistory()
+    const started = yield* bus
+      .subscribe(SessionEvent.Compaction.Started)
+      .pipe(Stream.take(1), Stream.runCollect, Effect.forkChild({ startImmediately: true }))
+
+    yield* compaction.precompute(Effect.succeed(loaded(session, history.near)))
+    const compacting = yield* compaction
+      .compact({ reason: "auto", context: loaded(session, history.due) })
+      .pipe(Effect.forkChild({ startImmediately: true }))
+
+    // The compaction shows as running while the summary it waits for is still being written.
+    expect(yield* Fiber.join(started)).toHaveLength(1)
+    expect(compacting.pollUnsafe()).toBeUndefined()
+    yield* Deferred.succeed(release, undefined)
+
+    expect(yield* Fiber.join(compacting)).toEqual({ status: "completed" })
+    expect(requests).toHaveLength(1)
+  }).pipe(Effect.ensuring(Effect.sync(() => (beforeResponse = Effect.void)))),
+)
+
+it.effect("a model switch waits for the new model's first response before summarizing in the background", () =>
+  Effect.gen(function* () {
+    requests = []
+    const compaction = yield* enablePrecompute
+    const session = yield* insertSession(Session.ID.make("ses_precompute_switch"))
+    const history = precomputeHistory()
+    const switched = (messages: readonly SessionMessage.Info[]) => ({
+      ...loaded(session, messages),
+      model: { ...resolved, ref: { ...resolved.ref, id: Model.ID.make("other") } },
+    })
+
+    // The latest response came from the previous model, so the new one has no cached prefix to summarize from.
+    yield* compaction.precompute(Effect.succeed(switched(history.near)))
+    expect(yield* compaction.compact({ reason: "auto", context: switched(history.due) })).toEqual({
+      status: "completed",
+    })
+    expect(requests).toHaveLength(1)
+    expect(JSON.stringify(requests[0].messages)).toContain("Third answer")
+  }),
+)
+
+it.effect("a background summary that fell too far behind is replaced from a newer response", () =>
+  Effect.gen(function* () {
+    requests = []
+    const compaction = yield* enablePrecompute
+    const session = yield* insertSession(Session.ID.make("ses_precompute_behind"))
+    const history = precomputeHistory()
+    // About 35k tokens arrived after the summarized prefix, past the 30k that may stay verbatim beside it.
+    const behind = [...history.near, textUser("x".repeat(140_000)), measured("Burst handled", 160_000)]
+
+    yield* compaction.precompute(Effect.succeed(loaded(session, history.near)))
+    yield* compaction.precompute(Effect.succeed(loaded(session, behind)))
+    const due = [...behind, textUser("Next question"), measured("Next answer", 182_000)]
+    expect(yield* compaction.compact({ reason: "auto", context: loaded(session, due) })).toEqual({
+      status: "completed",
+    })
+
+    // Compaction swapped in the newer summary, which ends before the latest response, instead of writing one.
+    const summarized = JSON.stringify(requests.at(-1)?.messages)
+    expect(summarized).toContain("x".repeat(1_000))
+    expect(summarized).not.toContain("Burst handled")
+  }),
+)
+
+it.effect("a failed background summary is retried from a newer response, then left until compaction", () =>
+  Effect.gen(function* () {
+    requests = []
+    const compaction = yield* enablePrecompute
+    const session = yield* insertSession(Session.ID.make("ses_precompute_failed"))
+    const history = precomputeHistory()
+    const later = [...history.near, textUser("Third question"), measured("Third answer", 160_000)]
+    const latest = [...later, textUser("Fourth question"), measured("Fourth answer", 165_000)]
+    const precomputeFailing = (messages: readonly SessionMessage.Info[]) =>
+      Effect.gen(function* () {
+        const reached = yield* Deferred.make<void>()
+        beforeResponse = Deferred.succeed(reached, undefined).pipe(Effect.andThen(Effect.die("provider down")))
+        yield* compaction.precompute(Effect.succeed(loaded(session, messages)))
+        yield* Deferred.await(reached)
+        yield* Effect.yieldNow
+      })
+
+    yield* precomputeFailing(history.near)
+    expect(requests).toHaveLength(1)
+    // The same response would send the same request again.
+    yield* compaction.precompute(Effect.succeed(loaded(session, history.near)))
+    expect(requests).toHaveLength(1)
+
+    yield* precomputeFailing(later)
+    expect(requests).toHaveLength(2)
+    expect(JSON.stringify(requests[1].messages)).toContain("Second answer")
+
+    // Two failures in a row stop background summaries until the next compaction.
+    yield* compaction.precompute(Effect.succeed(loaded(session, latest)))
+    expect(requests).toHaveLength(2)
+  }).pipe(Effect.ensuring(Effect.sync(() => (beforeResponse = Effect.void)))),
+)
+
+it.effect("compaction summarizes as usual when the background summary no longer fits the conversation", () =>
+  Effect.gen(function* () {
+    const compaction = yield* enablePrecompute
+    const session = yield* insertSession(Session.ID.make("ses_precompute_stale"))
+    const history = precomputeHistory()
+    const compactAfterPrecompute = (due: readonly SessionMessage.Info[], context = loaded(session, due)) =>
+      Effect.gen(function* () {
+        requests = []
+        yield* compaction.precompute(Effect.succeed(loaded(session, history.near)))
+        expect(yield* compaction.compact({ reason: "auto", context })).toEqual({ status: "completed" })
+        // The background summary is stopped; the summary that is kept covers the whole conversation.
+        return JSON.stringify(requests.at(-1)?.messages)
+      })
+
+    // About 35k tokens arrived after the summarized prefix, past the 30k that may stay verbatim beside it.
+    const burst = [...history.near, textUser("x".repeat(140_000)), measured("Burst handled", 182_000)]
+    expect(yield* compactAfterPrecompute(burst)).toContain("Burst handled")
+
+    // A different model would replay a summary written for the previous one.
+    const switched = {
+      ...loaded(session, history.due),
+      model: { ...resolved, ref: { ...resolved.ref, id: Model.ID.make("other") } },
+    }
+    expect(yield* compactAfterPrecompute(history.due, switched)).toContain("Third answer")
+  }),
+)
diff --git a/packages/protocol/openapi.json b/packages/protocol/openapi.json
index 1c68daeaadd1..071689d906dd 100644
--- a/packages/protocol/openapi.json
+++ b/packages/protocol/openapi.json
@@ -14463,6 +14463,9 @@
               "todo": {
                 "type": "boolean"
               },
+              "precompute_compaction": {
+                "type": "boolean"
+              },
               "subagent_depth": {
                 "type": "integer",
                 "minimum": 0
diff --git a/packages/schema/src/config/experimental.ts b/packages/schema/src/config/experimental.ts
index 4b378aeb1a60..874e4e55866f 100644
--- a/packages/schema/src/config/experimental.ts
+++ b/packages/schema/src/config/experimental.ts
@@ -11,6 +11,10 @@ export class Info extends Schema.Class<Info>("ConfigExperimental.Info")({
   todo: Schema.Boolean.pipe(optional).annotate({
     description: "Enable the experimental todowrite tool. Defaults to false.",
   }),
+  precompute_compaction: Schema.Boolean.pipe(optional).annotate({
+    description:
+      "Summarize the conversation in the background as it nears the compaction threshold, so automatic compaction does not wait for the summary. Background summaries that are never used still cost tokens. Defaults to false.",
+  }),
   subagent_depth: NonNegativeInt.pipe(optional).annotate({
     description: "Maximum subagent nesting depth. Defaults to 1.",
   }),
diff --git a/services/www/openapi.json b/services/www/openapi.json
index 1c68daeaadd1..071689d906dd 100644
--- a/services/www/openapi.json
+++ b/services/www/openapi.json
@@ -14463,6 +14463,9 @@
               "todo": {
                 "type": "boolean"
               },
+              "precompute_compaction": {
+                "type": "boolean"
+              },
               "subagent_depth": {
                 "type": "integer",
                 "minimum": 0
diff --git a/services/www/public/openapi.json b/services/www/public/openapi.json
index 1c68daeaadd1..071689d906dd 100644
--- a/services/www/public/openapi.json
+++ b/services/www/public/openapi.json
@@ -14463,6 +14463,9 @@
               "todo": {
                 "type": "boolean"
               },
+              "precompute_compaction": {
+                "type": "boolean"
+              },
               "subagent_depth": {
                 "type": "integer",
                 "minimum": 0