diff --git a/apps/web/src/features/conversation/chat.ts b/apps/web/src/features/conversation/chat.ts
index 1c8240d..cc76bd7 100644
--- a/apps/web/src/features/conversation/chat.ts
+++ b/apps/web/src/features/conversation/chat.ts
@@ -90,6 +90,9 @@ export function useChat(skey: string, options: ChatOptions = {}) {
       return refresh(skey)
     },
   })
+  // The stable functions alone, so what calls them stays the same from render to render.
+  const { mutate: stop } = stopping
+  const { mutate: regenerate } = regenerating
   const leaf = branch.at(-1)?.message
   // The later of the two, so a later success clears an earlier failure.
   const outcome = [stopping, regenerating].reduce((a, b) => (b.submittedAt > a.submittedAt ? b : a))
@@ -114,10 +117,9 @@ export function useChat(skey: string, options: ChatOptions = {}) {
     running: leaf?.record.status === 'pending' ? leaf.rkey : null,
     send,
     /** Ask again for the reply to a user message, by its key, with a model or the same one. */
-    regenerate: (parent: string | null, model: ModelRef | null) =>
-      regenerating.mutate({ parent, model }),
+    regenerate: (parent: string | null, model: ModelRef | null) => regenerate({ parent, model }),
     regenerating: regenerating.isPending,
-    stop: (replyRkey: string) => stopping.mutate(replyRkey),
+    stop: (replyRkey: string) => stop(replyRkey),
     /** How the last regeneration or stop went, for the conversation's one alert. */
     outcome: { error: outcome.error, submittedAt: outcome.submittedAt },
   }
diff --git a/apps/web/src/features/conversation/components/BranchView.tsx b/apps/web/src/features/conversation/components/BranchView.tsx
index b109344..55c26b1 100644
--- a/apps/web/src/features/conversation/components/BranchView.tsx
+++ b/apps/web/src/features/conversation/components/BranchView.tsx
@@ -1,10 +1,10 @@
-import type { ReactNode } from 'react'
+import { memo, type ReactNode } from 'react'
 import type { BlobUrl } from '../../../parts/types.ts'
 import type { BranchMessage, BranchStep } from '../lib/branch.ts'
 import { MessageView } from './MessageView.tsx'
 
-interface Props {
-  branch: BranchStep[]
+/** What the conversation gives every message on the branch. */
+interface RowOptions {
   blobUrl: BlobUrl
   /** Show another version of a message, by its rkey. */
   onPick: (rkey: string) => void
@@ -20,25 +20,71 @@ interface Props {
   arrived?: (message: BranchMessage) => boolean
 }
 
+interface Props extends RowOptions {
+  branch: BranchStep[]
+}
+
 /** The messages on the branch on screen, each with its versions, and the id `m-<rkey>`. */
 export function BranchView(props: Props) {
   return (
     <>
-      {props.branch.map(({ message, siblings, index }) => (
-        <MessageView
-          key={message.rkey}
-          id={`m-${message.rkey}`}
-          rkey={message.rkey}
-          record={message.record}
-          pending={message.record.status === 'pending' ? props.pending?.(message) : undefined}
-          live={message.record.status === 'pending' ? props.live?.(message) : undefined}
+      {props.branch.map((step) => (
+        <BranchRow
+          key={step.message.rkey}
+          message={step.message}
+          index={step.index}
+          count={step.siblings.length}
+          previous={step.siblings[step.index - 1]?.rkey}
+          next={step.siblings[step.index + 1]?.rkey}
           blobUrl={props.blobUrl}
-          siblings={{ messages: siblings, index, onPick: props.onPick }}
-          actions={props.actions?.(message)}
-          retry={message.record.status === 'error' ? props.retry?.(message) : undefined}
-          arrived={props.arrived?.(message)}
+          onPick={props.onPick}
+          pending={props.pending}
+          live={props.live}
+          actions={props.actions}
+          retry={props.retry}
+          arrived={props.arrived}
         />
       ))}
     </>
   )
 }
+
+interface RowProps extends RowOptions {
+  message: BranchMessage
+  /** Its place among its versions, and how many there are. */
+  index: number
+  count: number
+  /** The versions on either side, by rkey. */
+  previous?: string
+  next?: string
+}
+
+/**
+ * One message on the branch. It renders again only when its own record or its place among its
+ * versions changes, since the local copy keeps an unchanged message the same object, so a message
+ * arriving or a reply finishing doesn't render every other message again.
+ */
+const BranchRow = memo(function BranchRow(props: RowProps) {
+  const message = props.message
+  const status = message.record.status
+  return (
+    <MessageView
+      id={`m-${message.rkey}`}
+      rkey={message.rkey}
+      record={message.record}
+      pending={status === 'pending' ? props.pending?.(message) : undefined}
+      live={status === 'pending' ? props.live?.(message) : undefined}
+      blobUrl={props.blobUrl}
+      siblings={{
+        index: props.index,
+        count: props.count,
+        previous: props.previous,
+        next: props.next,
+        onPick: props.onPick,
+      }}
+      actions={props.actions?.(message)}
+      retry={status === 'error' ? props.retry?.(message) : undefined}
+      arrived={props.arrived?.(message)}
+    />
+  )
+})
diff --git a/apps/web/src/features/conversation/components/ConversationView.tsx b/apps/web/src/features/conversation/components/ConversationView.tsx
index 3615421..7ccea77 100644
--- a/apps/web/src/features/conversation/components/ConversationView.tsx
+++ b/apps/web/src/features/conversation/components/ConversationView.tsx
@@ -19,7 +19,7 @@ import { ConversationHeader } from './ConversationHeader.tsx'
 import { ConversationSkeleton } from './ConversationSkeleton.tsx'
 import { EmptyConversation } from './EmptyConversation.tsx'
 import { LiveAuthor } from './LiveAuthor.tsx'
-import { type ConversationOperations, MessageActions } from './message-actions.tsx'
+import { type ConversationOperations, MessageActions, RunningReply } from './message-actions.tsx'
 import { ReplyStream } from './ReplyStream.tsx'
 
 interface Props {
@@ -56,7 +56,6 @@ export function ConversationView(props: Props) {
   const operations: ConversationOperations = {
     edit: setEditingRkey,
     quote: (text) => composer.current?.quote(text),
-    running: stoppable,
     regenerate: chat.regenerate,
     stop: chat.stop,
     models,
@@ -88,38 +87,40 @@ export function ConversationView(props: Props) {
       <ErrorAlert error={lastError(actions.outcome, chat.outcome) ?? chat.loadError} />
       {waiting && <ConversationSkeleton />}
       {chat.empty && <EmptyConversation onStart={(text) => composer.current?.fill(text)} />}
-      <BranchView
-        branch={branch}
-        blobUrl={blobUrl}
-        onPick={chat.pick}
-        pending={(message) => (
-          <ReplyStream skey={props.skey} rkey={message.rkey} blobUrl={blobUrl} />
-        )}
-        live={(message) => (
-          <LiveAuthor
-            skey={props.skey}
-            rkey={message.rkey}
-            model={(message.record.model as { id?: string } | undefined)?.id ?? 'Assistant'}
-            since={message.record.createdAt}
-          />
-        )}
-        actions={(message) => <MessageActions message={message} operations={operations} />}
-        // A failed reply tries again with the same model.
-        retry={(message) => (
-          <Button
-            size="small"
-            className="mt-2.5"
-            busy={chat.regenerating}
-            onClick={() =>
-              chat.regenerate((message.record.parent as string | undefined) ?? null, null)
-            }
-          >
-            <RetryIcon className="size-3.75 text-muted" />
-            Try again
-          </Button>
-        )}
-        arrived={(message) => !opened?.has(message.rkey)}
-      />
+      <RunningReply.Provider value={stoppable}>
+        <BranchView
+          branch={branch}
+          blobUrl={blobUrl}
+          onPick={chat.pick}
+          pending={(message) => (
+            <ReplyStream skey={props.skey} rkey={message.rkey} blobUrl={blobUrl} />
+          )}
+          live={(message) => (
+            <LiveAuthor
+              skey={props.skey}
+              rkey={message.rkey}
+              model={(message.record.model as { id?: string } | undefined)?.id ?? 'Assistant'}
+              since={message.record.createdAt}
+            />
+          )}
+          actions={(message) => <MessageActions message={message} operations={operations} />}
+          // A failed reply tries again with the same model.
+          retry={(message) => (
+            <Button
+              size="small"
+              className="mt-2.5"
+              busy={chat.regenerating}
+              onClick={() =>
+                chat.regenerate((message.record.parent as string | undefined) ?? null, null)
+              }
+            >
+              <RetryIcon className="size-3.75 text-muted" />
+              Try again
+            </Button>
+          )}
+          arrived={(message) => !opened?.has(message.rkey)}
+        />
+      </RunningReply.Provider>
       <BranchComposer
         branch={branch}
         editing={editing}
diff --git a/apps/web/src/features/conversation/components/MessageView.tsx b/apps/web/src/features/conversation/components/MessageView.tsx
index d8d9e4a..055ba73 100644
--- a/apps/web/src/features/conversation/components/MessageView.tsx
+++ b/apps/web/src/features/conversation/components/MessageView.tsx
@@ -88,9 +88,7 @@ export function MessageView(props: MessageViewProps) {
         )}
       >
         <Author record={record} live={props.live} />
-        {props.siblings && props.siblings.messages.length > 1 && (
-          <SiblingPicker siblings={props.siblings} />
-        )}
+        {props.siblings && props.siblings.count > 1 && <SiblingPicker siblings={props.siblings} />}
       </header>
       <PartsView parts={parts} record={record} blobUrl={props.blobUrl} scope={props.rkey} />
       {record.status === 'pending' && props.pending}
diff --git a/apps/web/src/features/conversation/components/SiblingPicker.tsx b/apps/web/src/features/conversation/components/SiblingPicker.tsx
index 70f6c4f..c64f340 100644
--- a/apps/web/src/features/conversation/components/SiblingPicker.tsx
+++ b/apps/web/src/features/conversation/components/SiblingPicker.tsx
@@ -1,10 +1,13 @@
 import { ChevronLeftIcon, ChevronRightIcon } from '../../../shared/icons.tsx'
-import type { BranchMessage } from '../lib/branch.ts'
 
 /** A message's alternative versions, and which one is shown. */
 export interface Siblings {
-  messages: BranchMessage[]
+  /** The place of the one shown, and how many there are. */
   index: number
+  count: number
+  /** The versions on either side, by rkey. */
+  previous?: string
+  next?: string
   /** Show another version, by its rkey. */
   onPick: (rkey: string) => void
 }
@@ -19,27 +22,27 @@ const arrow =
 
 /** Arrows to step between alternative versions of a message, around a count that keeps its width. */
 export function SiblingPicker(props: Props) {
-  const previous = props.siblings.messages[props.siblings.index - 1]
-  const next = props.siblings.messages[props.siblings.index + 1]
+  const previous = props.siblings.previous
+  const next = props.siblings.next
   return (
     <span className="inline-flex items-center gap-0.5 text-caption text-muted">
       <button
         type="button"
         aria-label="Previous version"
         disabled={!previous}
-        onClick={() => previous && props.siblings.onPick(previous.rkey)}
+        onClick={() => previous && props.siblings.onPick(previous)}
         className={arrow}
       >
         <ChevronLeftIcon className="size-3.5" />
       </button>
       <span className="min-w-6.5 text-center tabular-nums">
-        {props.siblings.index + 1}/{props.siblings.messages.length}
+        {props.siblings.index + 1}/{props.siblings.count}
       </span>
       <button
         type="button"
         aria-label="Next version"
         disabled={!next}
-        onClick={() => next && props.siblings.onPick(next.rkey)}
+        onClick={() => next && props.siblings.onPick(next)}
         className={arrow}
       >
         <ChevronRightIcon className="size-3.5" />
diff --git a/apps/web/src/features/conversation/components/message-actions.tsx b/apps/web/src/features/conversation/components/message-actions.tsx
index 2e42302..d8164c3 100644
--- a/apps/web/src/features/conversation/components/message-actions.tsx
+++ b/apps/web/src/features/conversation/components/message-actions.tsx
@@ -1,5 +1,5 @@
 import type { ModelRef } from '@scn-chat/lexicons'
-import type { ComponentType } from 'react'
+import { type ComponentType, createContext, useContext } from 'react'
 import { PencilIcon, RetryIcon } from '../../../shared/icons.tsx'
 import { action, iconAction } from '../../../shared/ui/actions.ts'
 import { CopyButton } from '../../../shared/ui/CopyButton.tsx'
@@ -23,10 +23,15 @@ export interface ConversationOperations {
   storedIn: string
   /** Quote text into the composer. */
   quote?: (text: string) => void
-  /** The reply running at the end of the branch, which the composer offers to stop instead. */
-  running?: string | null
 }
 
+/**
+ * The reply running at the end of the branch, by rkey, which the composer offers to stop instead.
+ * A context, apart from the operations, so a reply starting or finishing rerenders only the stop
+ * actions rather than every message's actions.
+ */
+export const RunningReply = createContext<string | null>(null)
+
 export interface MessageActionProps {
   message: BranchMessage
   operations: ConversationOperations
@@ -85,8 +90,9 @@ function RegenerateAction(props: MessageActionProps) {
 }
 
 function StopAction(props: MessageActionProps) {
+  const running = useContext(RunningReply)
   if (isUser(props.message) || !isPending(props.message)) return null
-  if (props.message.rkey === props.operations.running) return null
+  if (props.message.rkey === running) return null
   return (
     <button
       type="button"
diff --git a/apps/web/src/features/models/hooks/useModels.ts b/apps/web/src/features/models/hooks/useModels.ts
index 9d65b6a..461e857 100644
--- a/apps/web/src/features/models/hooks/useModels.ts
+++ b/apps/web/src/features/models/hooks/useModels.ts
@@ -5,12 +5,15 @@ import { preferencesQuery } from '../../settings/queries.ts'
 import { fallbackModel } from '../models.ts'
 import { modelsQuery } from '../queries.ts'
 
+/** No models, the same list each time, so what takes them doesn't rerender until some arrive. */
+const none: never[] = []
+
 /** The models on offer, and the fallback model for a turn whose branch inherits `inherited`. */
 export function useModels(inherited: ModelRef | null = null) {
   const catalog = useQuery(modelsQuery)
   const preferences = useQuery(preferencesQuery)
   return {
-    models: catalog.data?.models ?? [],
+    models: catalog.data?.models ?? none,
     /** The catalog, or the preferences that choose among it, are on their way. */
     loading: catalog.isPending || preferences.isPending,
     /** The catalog loaded and offers the user no models at all. */
diff --git a/apps/web/tests/features/conversation/components/ConversationView.test.tsx b/apps/web/tests/features/conversation/components/ConversationView.test.tsx
index aff780f..f2c6d59 100644
--- a/apps/web/tests/features/conversation/components/ConversationView.test.tsx
+++ b/apps/web/tests/features/conversation/components/ConversationView.test.tsx
@@ -5,6 +5,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { MeContext } from '../../../../src/features/auth/session.ts'
 import { BusyBanner } from '../../../../src/features/conversation/components/BusyBanner.tsx'
 import { ConversationView } from '../../../../src/features/conversation/components/ConversationView.tsx'
+import type * as messageView from '../../../../src/features/conversation/components/MessageView.tsx'
 import type { StoreClient } from '../../../../src/store/client.ts'
 import type { HandoverState } from '../../../../src/store/handover.ts'
 import { StoreProvider } from '../../../../src/store/react.tsx'
@@ -12,6 +13,23 @@ import { FakeEventSource, stubEventSource } from '../../../helpers/event-source.
 import { stubFetch, writes } from '../../../helpers/fetch.ts'
 import { renderAt } from '../../../helpers/router.tsx'
 
+/** How often each message has rendered, by rkey. */
+const messageRenders = vi.hoisted(() => new Map<string, number>())
+vi.mock(
+  '../../../../src/features/conversation/components/MessageView.tsx',
+  async (importOriginal) => {
+    const actual = await importOriginal<typeof messageView>()
+    return {
+      ...actual,
+      MessageView: (props: messageView.MessageViewProps) => {
+        const rkey = props.rkey ?? ''
+        messageRenders.set(rkey, (messageRenders.get(rkey) ?? 0) + 1)
+        return actual.MessageView(props)
+      },
+    }
+  },
+)
+
 const d = (name: string) => `network.sharedcomputer.chat.defs#${name}`
 const text = (value: string) => ({
   $type: d('plainContent'),
@@ -297,6 +315,25 @@ describe('ConversationView', () => {
     await vi.waitFor(() => expect(scroller.scrollTop).toBe(600))
   })
 
+  it('renders again only the message that changed when a reply finishes', async () => {
+    const first = [user('u', 'question'), reply('u.r0', 'answer', 'u')]
+    const store = fakeStore([
+      ...first,
+      user('v', 'again', 'u.r0'),
+      reply('v.r0', '', 'v', 'pending'),
+    ])
+    await renderWith(store, <ConversationView skey="s1" />)
+    await screen.findByText('again')
+    await act(async () => {})
+    messageRenders.clear()
+    act(() =>
+      store.update([...store.data.messages.slice(0, 3), reply('v.r0', 'second answer', 'v')]),
+    )
+    await screen.findByText('second answer')
+    expect(messageRenders.get('v.r0')).toBeGreaterThan(0)
+    for (const rkey of ['u', 'u.r0', 'v']) expect(messageRenders.get(rkey)).toBeUndefined()
+  })
+
   it('syncs and shows a message written from another client', async () => {
     const fetch = vi.fn(async () => Response.json({}))
     stubFetch(fetch)
diff --git a/apps/web/tests/features/conversation/components/MessageView.test.tsx b/apps/web/tests/features/conversation/components/MessageView.test.tsx
index 1924471..50fcda8 100644
--- a/apps/web/tests/features/conversation/components/MessageView.test.tsx
+++ b/apps/web/tests/features/conversation/components/MessageView.test.tsx
@@ -456,11 +456,7 @@ describe('MessageView', () => {
       <MessageView
         blobUrl={blobUrl}
         record={{ role: 'assistant', content: { $type: d('plainContent'), parts: [] } }}
-        siblings={{
-          messages: ['a', 'b', 'c'].map((rkey) => ({ rkey, record: {} })),
-          index: 1,
-          onPick,
-        }}
+        siblings={{ index: 1, count: 3, previous: 'a', next: 'c', onPick }}
       />,
     )
     expect(screen.getByText('2/3')).toBeInTheDocument()
diff --git a/specs/web-ui.md b/specs/web-ui.md
index f378ef3..a19e69d 100644
--- a/specs/web-ui.md
+++ b/specs/web-ui.md
@@ -123,7 +123,7 @@ The reply follower, in `features/conversation/reply-follower.ts`, follows each p
 
 Each followed reply has a stream query over the reply's stream endpoint, private to the follower. It reduces the stream's events into the reply's parts in the record's own shape, by index: `part-start` starts a text or reasoning part, `delta` appends to it, and `part` sets a finished tool call, tool result, or source. A `queued` event marks the reply as waiting until its first part arrives. The query ends after the `status` event. Since streamed parts have the record's shape, a pending reply and a finished one render through the same view. A finished status (`complete`, `error`, or `cancelled`) refreshes the conversation from the PDS, which brings the final record into the browser store. The events that arrive within one animation frame are reduced as one batch, so a reply streaming a word at a time renders at most once a frame, and the `status` event is passed on at once with whatever came before it. A stream runs once while the conversation is open. Leaving the conversation drops it, and coming back follows the reply again.
 
-A reply's views read it from the follower without ever starting a stream, so each delta re-renders only the views that show it, never the conversation. `ReplyStream`, which `ConversationView` puts in `MessageView`'s `pending` slot, reads `useFollowedReply(skey, rkey)`: what has streamed so far, and why the reply is no longer live, if it isn't. `LiveAuthor` reads `useReplyStarted(skey, rkey)`, which re-renders the header only once the reply starts. A message with nothing in the slot, as on the shared page, shows "Thinking..." while pending.
+A reply's views read it from the follower without ever starting a stream, so each delta re-renders only the views that show it, never the conversation. `ReplyStream`, which `ConversationView` puts in `MessageView`'s `pending` slot, reads `useFollowedReply(skey, rkey)`: what has streamed so far, and why the reply is no longer live, if it isn't. `LiveAuthor` reads `useReplyStarted(skey, rkey)`, which re-renders the header only once the reply starts. A message with nothing in the slot, as on the shared page, shows "Thinking..." while pending. A change to the conversation, such as a message arriving or a reply finishing, renders again only the messages it changed: `BranchView` gives each message's row only its record, which the local copy keeps the same object while unchanged, its place among its versions, and functions that stay the same, and the reply running at the end of the branch reaches the Stop actions through the `RunningReply` context.
 
 If a reply is still pending after its stream ends, because the stream dropped or the status says another server runs it, the follower polls, checking the conversation against the PDS as opening it does, with a backoff from two seconds to thirty until the reply leaves `pending`. The first poll comes one interval after the stream ends, and polling continues while the tab is in the background. Meanwhile `ReplyStream` keeps what streamed and says why the reply is no longer live: "Lost the live stream. Checking for the reply…" when the stream dropped or sent an event it couldn't read, and "Not streaming on this server. Checking for the reply…" when its status was not final.