@@ -24,6 +24,7 @@ import {
 } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/lane-activity'
 import { MainAgentActivity } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/main-agent-activity'
 import {
+  getActivityHeaderTool,
   getActivityStatusTool,
   getCompletedActivityLabel,
   getInProgressActivityLabel,
@@ -119,13 +120,14 @@ export function AgentGroupView({
   const isMainAgent = agentName === 'mothership'
   const tools = isMainAgent ? [] : collectGroupTools(items)
   const statusTool = getActivityStatusTool(tools)
-  const statusTitle = useToolCallTitle(
-    statusTool && {
-      ...statusTool,
-      toolCallId: statusTool.id,
+  const headerTool = statusTool && getActivityHeaderTool(tools, statusTool)
+  const headerTitle = useToolCallTitle(
+    headerTool && {
+      ...headerTool,
+      toolCallId: headerTool.id,
       displayTitle:
-        statusTool.displayTitle ||
-        getToolDisplayTitle(String(statusTool.toolName ?? ''), undefined),
+        headerTool.displayTitle ||
+        getToolDisplayTitle(String(headerTool.toolName ?? ''), undefined),
     }
   )
   const activityDescriptor =
@@ -283,8 +285,13 @@ export function AgentGroupView({
   const headerText = error
     ? agentLabel
     : inProgress
-      ? statusTool && statusTitle
-        ? getInProgressActivityLabel(statusTitle.activeLabel, statusTool, tools)
+      ? headerTool && headerTitle
+        ? getInProgressActivityLabel(
+            headerTitle.activeLabel,
+            headerTool,
+            tools,
+            activityDescriptor?.title
+          )
         : 'Thinking'
       : tools.length > 0
         ? getCompletedActivityLabel(tools, activityDescriptor)
@@ -307,7 +314,7 @@ export function AgentGroupView({
       ) : (
         <ActivityStream
           activity={{ label: headerText, isActive: headerActive, icon: agentIcon }}
-          activityKey={statusTool?.id}
+          activityKey={headerTool?.id}
           expandedLabel={pendingInteraction ? undefined : activityDescriptor?.title}
           attentionKey={`${getActivityAttentionKey(tools)}:${activeBrowserTakeover?.id ?? ''}`}
           collapsible={collapsible}
 
@@ -310,7 +310,7 @@ describe('AgentGroup inline main activity', () => {
   })
 
   it.each(['sim_cli', 'run_code'])(
-    'shows %s argument preparation before its concrete call',
+    'names a first %s call by its activity intent, else its own title, while its arguments stream',
     (toolName) => {
       vi.useFakeTimers()
       const render = (
@@ -342,16 +342,107 @@ describe('AgentGroup inline main activity', () => {
           )
         )
         act(() => vi.advanceTimersByTime(1000))
+        expect(container.textContent).not.toContain('Working')
         return container.textContent
       }
-      expect(render({}, 'executing')).toBe('Working…')
-      const params = { code: '1', activity: { id: 'check', completedTitle: 'Checked inputs' } }
+      expect(render({}, 'executing')).toBe('Running checks')
+      expect(render({ activity: { id: 'check', title: 'Checking inputs' } }, 'executing')).toBe(
+        'Checking inputs'
+      )
+      const params = { code: '1', activity: { id: 'check', title: 'Checking inputs' } }
       expect(render(params, 'executing')).toBe('Running checks')
       expect(render(params, 'success')).toBe('Running checks')
       expect(render(params, 'success', false)).toBe('Ran checks')
     }
   )
 
+  it.each([
+    [
+      'sim_cli',
+      { toolName: 'sim_cli', displayTitle: 'Running CLI command', params: {} },
+      {
+        toolName: 'cli_workflows_list',
+        displayTitle: 'Listing workflows',
+        params: { args: ['workflows', 'list'] },
+      },
+    ],
+    [
+      'run_code',
+      { toolName: 'run_code', displayTitle: 'Running code', params: { activity: { id: 'a' } } },
+      {
+        toolName: 'run_code',
+        displayTitle: 'Summing invoices',
+        params: { activity: { id: 'a' }, title: 'Summing invoices', code: '1' },
+      },
+    ],
+    [
+      'call_integration_tool',
+      { toolName: 'call_integration_tool', displayTitle: 'Calling integration', params: {} },
+      {
+        toolName: 'call_integration_tool',
+        displayTitle: 'Sending the report',
+        params: {},
+        streamingArgs: '{"description":"Sending the report",',
+      },
+    ],
+  ])(
+    'keeps the previous call in the live header while a %s call has no title',
+    (_name, pending, titled) => {
+      vi.useFakeTimers()
+      const read = {
+        id: 'read',
+        toolName: 'read',
+        displayTitle: 'Reading notes.md',
+        status: 'success' as const,
+      }
+      const render = (next: Partial<ToolCallData>) => {
+        act(() =>
+          root.render(
+            createElement(AgentGroup, {
+              agentName: 'mothership',
+              agentLabel: 'Sim',
+              activity: { id: 'a', title: 'Reconciling accounts' },
+              isStreaming: true,
+              isLaneOpen: true,
+              items: [
+                { type: 'tool', data: read },
+                {
+                  type: 'tool',
+                  data: { id: 'next', status: 'executing', ...next } as ToolCallData,
+                },
+              ],
+            })
+          )
+        )
+        act(() => vi.advanceTimersByTime(1000))
+        const header = container.querySelector('[role="status"]')!
+        expect(header.querySelector('[class*="shimmer"]')).not.toBeNull()
+        expect(container.textContent).not.toContain('Working')
+        return { text: header.textContent, icon: header.querySelector('svg')?.outerHTML }
+      }
+      const iconOf = (data: Partial<ToolCallData>) => {
+        act(() =>
+          root.render(
+            createElement(AgentGroup, {
+              agentName: 'mothership',
+              agentLabel: 'Sim',
+              items: [
+                { type: 'tool', data: { id: 'solo', status: 'success', ...data } as ToolCallData },
+              ],
+            })
+          )
+        )
+        return container.querySelector('svg')?.outerHTML
+      }
+      const readIcon = iconOf(read)
+      const titledIcon = iconOf(titled)
+      expect(readIcon).not.toBe(titledIcon)
+
+      expect(render(pending)).toEqual({ text: 'Reading notes.md', icon: readIcon })
+      expect(render(titled)).toEqual({ text: titled.displayTitle, icon: titledIcon })
+    }
+  )
+
   it('keeps an activity unfinished while a standalone approval is pending', () => {
     act(() =>
       root.render(
@@ -1175,6 +1266,48 @@ describe('AgentGroup nested status line', () => {
     expect(header).toContain('Deploying Invoice Sync as API')
   })
 
+  it('keeps the previous call in a subagent header while the next call has no title', () => {
+    vi.useFakeTimers()
+    const header = (items: AgentGroupItem[]) => {
+      render(items)
+      act(() => vi.advanceTimersByTime(1000))
+      const status = container.querySelector('[role="status"]')!
+      expect(status.querySelector('[class*="shimmer"]')).not.toBeNull()
+      expect(container.textContent).not.toContain('Working')
+      return status.textContent
+    }
+    const cli = (data: Partial<ToolCallData>): AgentGroupItem => ({
+      type: 'tool',
+      data: { id: 'cli', status: 'executing', startedAt: 2, ...data } as ToolCallData,
+    })
+    const pending = cli({ toolName: 'sim_cli', displayTitle: 'Running CLI command', params: {} })
+    const titled = cli({
+      toolName: 'cli_workflows_list',
+      displayTitle: 'Listing workflows',
+      params: { args: ['workflows', 'list'] },
+    })
+    try {
+      expect(header([namedTool('Reading workflow', 'success' as ToolCallStatus, 1), pending])).toBe(
+        'Reading workflow'
+      )
+      expect(header([namedTool('Reading workflow', 'success' as ToolCallStatus, 1), titled])).toBe(
+        'Listing workflows'
+      )
+      expect(header([pending])).toBe('Running CLI command')
+      expect(
+        header([
+          cli({
+            toolName: 'sim_cli',
+            displayTitle: 'Running CLI command',
+            params: { activity: { id: 'a', title: 'Checking inputs' } },
+          }),
+        ])
+      ).toBe('Checking inputs')
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
   it('falls back to the last tool at any depth when nothing is running', () => {
     const header = render([
       namedTool('Reading workflow', 'success' as ToolCallStatus, 1),
 
@@ -1,6 +1,10 @@
 /** @vitest-environment node */
 import { describe, expect, it } from 'vitest'
-import { getCompletedActivityLabel } from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-activity-group'
+import {
+  getActivityHeaderTool,
+  getCompletedActivityLabel,
+  getInProgressActivityLabel,
+} from '@/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-activity-group'
 import type { ToolCallData, ToolCallStatus } from '@/app/workspace/[workspaceId]/home/types'
 
 /** A finished activity without a model title is labelled by its action summary. */
@@ -134,3 +138,85 @@ describe('interrupted activity summaries', () => {
     ).toBe('Ran invoice workflow')
   })
 })
+
+describe('in-progress activity header', () => {
+  const read = tool('read', 'Reading notes.md')
+  const pendingCli = tool('sim_cli', 'Running CLI command', 'executing', {
+    activity: { id: 'a' },
+  })
+  const pendingGateway = tool('call_integration_tool', 'Calling integration', 'executing')
+
+  it.each([
+    ['a CLI call before its command parses', pendingCli],
+    ['a code call before its arguments resolve', tool('run_code', 'Running code', 'executing')],
+    ['a gateway call before its description streams', pendingGateway],
+  ])('holds the previous call for %s', (_case, pending) => {
+    const tools = [read, pending]
+    expect(getActivityHeaderTool(tools, pending)).toBe(read)
+    expect(getInProgressActivityLabel('Reading notes.md', read, tools, 'Reconciling')).toBe(
+      'Reading notes.md'
+    )
+  })
+
+  it('holds the call the header described before, skipping untitled and failed calls', () => {
+    const failed = tool('grep', 'Searching', 'error')
+    const tools = [read, failed, pendingGateway, pendingCli]
+    expect(getActivityHeaderTool(tools, pendingCli)).toBe(read)
+  })
+
+  it('never holds a failed call, falling back to the new call itself', () => {
+    const failed = tool('grep', 'Searching', 'error')
+    expect(getActivityHeaderTool([failed, pendingCli], pendingCli)).toBe(pendingCli)
+    expect(
+      getInProgressActivityLabel(
+        'Running CLI command',
+        pendingCli,
+        [failed, pendingCli],
+        'Reconciling'
+      )
+    ).toBe('Reconciling')
+  })
+
+  it('keeps a call waiting on approval as the header, never holding past or onto it', () => {
+    const gatedGateway = {
+      ...pendingGateway,
+      id: 'gateway-gated',
+      status: 'awaiting_approval' as const,
+    }
+    expect(getActivityHeaderTool([read, gatedGateway], gatedGateway)).toBe(gatedGateway)
+    const gatedRead = { ...read, id: 'read-gated', status: 'awaiting_approval' as const }
+    expect(getActivityHeaderTool([read, gatedRead, pendingCli], pendingCli)).toBe(read)
+  })
+
+  it.each([
+    ['a parsed CLI command', tool('cli_workflows_list', 'Listing workflows', 'executing')],
+    [
+      'resolved code arguments',
+      tool('run_code', 'Summing', 'executing', { activity: { id: 'a' }, code: '1' }),
+    ],
+    [
+      'a streamed gateway description',
+      {
+        ...pendingGateway,
+        id: 'gateway-described',
+        streamingArgs: '{"description":"Sending the report",',
+      },
+    ],
+    [
+      'a model activity description',
+      { ...pendingCli, id: 'cli-described', activityDescription: 'Listing the workflows' },
+    ],
+  ])('describes the new call once it has %s', (_case, titled) => {
+    expect(getActivityHeaderTool([read, titled], titled)).toBe(titled)
+  })
+
+  it('reads a first untitled call as the activity intent, else its own title', () => {
+    expect(getActivityHeaderTool([pendingCli], pendingCli)).toBe(pendingCli)
+    expect(
+      getInProgressActivityLabel('Running CLI command', pendingCli, [pendingCli], 'Reconciling')
+    ).toBe('Reconciling')
+    expect(
+      getInProgressActivityLabel('Running CLI command', pendingCli, [pendingCli], undefined)
+    ).toBe('Running CLI command')
+  })
+})