diff --git a/.changeset/chat-instructions-from-history.md b/.changeset/chat-instructions-from-history.md
new file mode 100644
index 000000000..fa1d2ef76
--- /dev/null
+++ b/.changeset/chat-instructions-from-history.md
@@ -0,0 +1,6 @@
+---
+"@truefoundry/trueforge": patch
+"@truefoundry/trueforge-ui": patch
+---
+
+Draft system instructions from an existing chat, then let the user edit before applying
diff --git a/packages/trueforge-ui/src/atoms/GenerateInstructionsButton.tsx b/packages/trueforge-ui/src/atoms/GenerateInstructionsButton.tsx
new file mode 100644
index 000000000..5434440ee
--- /dev/null
+++ b/packages/trueforge-ui/src/atoms/GenerateInstructionsButton.tsx
@@ -0,0 +1,254 @@
+'use client';
+
+import {
+  useTrueFoundryAdoptAgentSpec,
+  useTrueFoundryAgentSpec,
+  useTrueFoundryFlushAgentSpec,
+} from '@truefoundry/assistant-ui-runtime';
+import { useEffect, useId, useRef, useState } from 'react';
+import { useAuiState } from '../assistant-ui.js';
+import { Icon } from '../icons/Icon.js';
+import { hasGenerateInstructionsFromChat } from '../server/generateInstructionsFromChat.js';
+import { useOptionalServer } from '../server/ServerContext.js';
+import { useOptionalShellMode } from '../server/ShellModeContext.js';
+import { getErrorMessage } from '../utils/getErrorMessage.js';
+import { auiButtonClass } from './lib/buttonClasses.js';
+import { auiInputClass } from './lib/inputClasses.js';
+import { CenteredModal } from './primitives/CenteredModal.js';
+
+export type GenerateInstructionsButtonProps = {
+  disabled?: boolean;
+  className?: string;
+};
+
+export function useGenerateInstructionsVisible(): boolean {
+  const shell = useOptionalShellMode();
+  const server = useOptionalServer();
+  const remoteId = useAuiState(s => s.threadListItem.remoteId);
+  if (shell == null || shell.mode.status !== 'active') return false;
+  if (remoteId == null || remoteId.length === 0) return false;
+  return hasGenerateInstructionsFromChat(server);
+}
+
+export function GenerateInstructionsButton({ disabled = false, className }: GenerateInstructionsButtonProps) {
+  const visible = useGenerateInstructionsVisible();
+  if (!visible) return null;
+  return <GenerateInstructionsButtonContent disabled={disabled} className={className} />;
+}
+
+function GenerateInstructionsButtonContent({ disabled, className }: { disabled: boolean; className?: string }) {
+  const server = useOptionalServer();
+  const shell = useOptionalShellMode();
+  const remoteId = useAuiState(s => s.threadListItem.remoteId);
+  const { agentSpec } = useTrueFoundryAgentSpec();
+  const agentSpecRef = useRef(agentSpec);
+  agentSpecRef.current = agentSpec;
+  const flushAgentSpec = useTrueFoundryFlushAgentSpec();
+  const adoptAgentSpec = useTrueFoundryAdoptAgentSpec();
+  const titleId = useId();
+  const [open, setOpen] = useState(false);
+  const [loading, setLoading] = useState(false);
+  const [applying, setApplying] = useState(false);
+  const [draft, setDraft] = useState('');
+  const [sources, setSources] = useState<Array<{ turnId: string; role: 'user' | 'assistant'; excerpt: string }>>([]);
+  const [error, setError] = useState<string | null>(null);
+  const [copied, setCopied] = useState(false);
+  const errorRef = useRef<HTMLParagraphElement>(null);
+  const inFlightRef = useRef(false);
+  const applyingRef = useRef(false);
+  const canApply = shell?.mode.status === 'active' && shell.mode.isMutable && agentSpec != null;
+
+  useEffect(() => {
+    if (error === null) return;
+    errorRef.current?.scrollIntoView?.({ block: 'nearest', behavior: 'smooth' });
+  }, [error]);
+
+  const close = () => {
+    if (loading || applying) return;
+    setOpen(false);
+    setDraft('');
+    setSources([]);
+    setError(null);
+    setCopied(false);
+  };
+
+  const generate = async () => {
+    if (!hasGenerateInstructionsFromChat(server) || remoteId == null || inFlightRef.current) return;
+    inFlightRef.current = true;
+    setLoading(true);
+    setError(null);
+    setCopied(false);
+    try {
+      const result = await server.generateInstructionsFromChat({ sessionId: remoteId });
+      setDraft(result.instructions);
+      setSources(result.sources);
+    } catch (caught) {
+      setDraft('');
+      setSources([]);
+      setError(getErrorMessage(caught, 'Could not generate instructions from this chat'));
+    } finally {
+      inFlightRef.current = false;
+      setLoading(false);
+    }
+  };
+
+  const show = () => {
+    if (inFlightRef.current || applyingRef.current || loading || applying) return;
+    setOpen(true);
+    void generate();
+  };
+
+  const apply = async () => {
+    if (
+      !canApply ||
+      agentSpecRef.current === null ||
+      remoteId == null ||
+      !hasGenerateInstructionsFromChat(server) ||
+      applyingRef.current
+    ) {
+      return;
+    }
+    const instructions = draft.trim();
+    if (instructions.length === 0) return;
+    applyingRef.current = true;
+    setApplying(true);
+    setError(null);
+    try {
+      await flushAgentSpec();
+      const latest = agentSpecRef.current;
+      if (latest === null) return;
+      const next = { ...latest, instructions };
+      const updated = await server.updateSession({ sessionId: remoteId, agentSpec: next });
+      adoptAgentSpec({ agentSpec: next, updatedAt: updated.updatedAt });
+      setOpen(false);
+      setDraft('');
+      setSources([]);
+    } catch (caught) {
+      setError(getErrorMessage(caught, 'Could not apply instructions to this chat'));
+    } finally {
+      applyingRef.current = false;
+      setApplying(false);
+    }
+  };
+
+  const copyDraft = async () => {
+    if (draft.trim().length === 0 || typeof navigator === 'undefined' || navigator.clipboard == null) return;
+    await navigator.clipboard.writeText(draft);
+    setCopied(true);
+  };
+
+  return (
+    <>
+      <button
+        type="button"
+        disabled={disabled || loading || applying || open}
+        className={auiButtonClass({ variant: 'ghost', size: 'sm', className })}
+        onClick={show}
+      >
+        <Icon name="lightbulb" className="size-3.5" />
+        From chat
+      </button>
+
+      <CenteredModal
+        open={open}
+        onOpenChange={next => !next && close()}
+        title="Instructions from this chat"
+        className="md:h-auto md:max-h-[85dvh] md:max-w-2xl"
+        aria-label="Instructions from this chat"
+      >
+        <div className="flex min-h-0 w-full flex-1 flex-col">
+          <div className="min-h-0 flex-1 overflow-y-auto px-5 py-3">
+            <p className="text-text-secondary mb-3 text-sm">
+              This is a draft from the conversation. Edit it before it becomes this chat&apos;s system instructions.
+              Nothing is saved until you apply it.
+            </p>
+
+            <label className="mb-3 block" htmlFor={titleId}>
+              <span className="mb-1.5 block text-sm font-medium">Suggested instructions</span>
+              <textarea
+                id={titleId}
+                value={draft}
+                disabled={loading || applying}
+                onChange={event => setDraft(event.target.value)}
+                rows={8}
+                placeholder={loading ? 'Reading this chat…' : 'No suggestion yet.'}
+                className={auiInputClass('resize-y py-2 disabled:opacity-60')}
+              />
+            </label>
+
+            {sources.length > 0 ? (
+              <div className="mb-3">
+                <p className="text-text-secondary mb-1.5 text-xs font-semibold tracking-wide uppercase">
+                  Inferred from
+                </p>
+                <ul className="space-y-1.5">
+                  {sources.map(source => (
+                    <li
+                      key={`${source.turnId}-${source.role}-${source.excerpt}`}
+                      className="text-text-secondary text-xs"
+                    >
+                      <span className="text-text-primary font-medium">{source.role}</span>
+                      {': '}
+                      {source.excerpt}
+                    </li>
+                  ))}
+                </ul>
+              </div>
+            ) : null}
+
+            {canApply ? null : (
+              <p className="text-text-secondary mb-2 text-xs">
+                This chat is bound to a saved agent, so the draft is not applied here. Copy it, or save a new agent.
+              </p>
+            )}
+
+            {error ? (
+              <p
+                ref={errorRef}
+                role="alert"
+                className="text-failure-bg mt-2 text-sm wrap-break-word whitespace-pre-wrap"
+              >
+                {error}
+              </p>
+            ) : null}
+          </div>
+
+          <div className="bg-card-bg sticky bottom-0 z-10 flex shrink-0 flex-wrap justify-end gap-2 border-t border-border px-5 py-4">
+            <button
+              type="button"
+              disabled={loading || applying}
+              className={auiButtonClass({ variant: 'secondary' })}
+              onClick={close}
+            >
+              Cancel
+            </button>
+            <button
+              type="button"
+              disabled={loading || applying || draft.trim().length === 0}
+              className={auiButtonClass({ variant: 'secondary' })}
+              onClick={() => void copyDraft()}
+            >
+              {copied ? 'Copied' : 'Copy'}
+            </button>
+            {canApply ? (
+              <button
+                type="button"
+                disabled={loading || applying || draft.trim().length === 0}
+                className={auiButtonClass({ variant: 'default' })}
+                onClick={() => void apply()}
+              >
+                {applying ? 'Applying…' : 'Apply to this chat'}
+              </button>
+            ) : null}
+          </div>
+        </div>
+      </CenteredModal>
+    </>
+  );
+}
+
+declare module '../theme/SlotsProvider.js' {
+  interface AtomSlots {
+    GenerateInstructionsButton: typeof GenerateInstructionsButton;
+  }
+}
diff --git a/packages/trueforge-ui/src/index.ts b/packages/trueforge-ui/src/index.ts
index 42f16c6b2..13af28fde 100644
--- a/packages/trueforge-ui/src/index.ts
+++ b/packages/trueforge-ui/src/index.ts
@@ -347,4 +347,6 @@ export { DraftCompositeSelector } from './atoms/draft/DraftCompositeSelector.js'
 export type { DraftCompositeSelectorProps } from './atoms/draft/DraftCompositeSelector.js';
 export { DraftModelSelector } from './atoms/draft/DraftModelSelector.js';
 export type { DraftModelSelectorProps } from './atoms/draft/DraftModelSelector.js';
+export { GenerateInstructionsButton } from './atoms/GenerateInstructionsButton.js';
+export type { GenerateInstructionsButtonProps } from './atoms/GenerateInstructionsButton.js';
 export { SaveAgentButton } from './atoms/SaveAgentButton.js';
diff --git a/packages/trueforge-ui/src/layouts/DrawerLayout.tsx b/packages/trueforge-ui/src/layouts/DrawerLayout.tsx
index caed58cd6..5ba510c86 100644
--- a/packages/trueforge-ui/src/layouts/DrawerLayout.tsx
+++ b/packages/trueforge-ui/src/layouts/DrawerLayout.tsx
@@ -20,6 +20,7 @@ export function DrawerLayout({ className }: { className?: string }) {
   const aui = useAui();
   const shell = useOptionalShellMode();
   const ClearChatButton = useSlot('ClearChatButton');
+  const GenerateInstructionsButton = useSlot('GenerateInstructionsButton');
   const SaveAgentButton = useSlot('SaveAgentButton');
   const SelectAgentEmptyState = useSlot('SelectAgentEmptyState');
   const [threadsOpen, setThreadsOpen] = useState(false);
@@ -73,6 +74,7 @@ export function DrawerLayout({ className }: { className?: string }) {
             <NamedAgentHeaderLabel />
             <span className="min-w-0 flex-1" />
             <ClearChatButton />
+            <GenerateInstructionsButton />
             <SaveAgentButton />
           </>
         ) : (
diff --git a/packages/trueforge-ui/src/layouts/SidebarLayout.tsx b/packages/trueforge-ui/src/layouts/SidebarLayout.tsx
index 21511cfb1..8d91c945d 100644
--- a/packages/trueforge-ui/src/layouts/SidebarLayout.tsx
+++ b/packages/trueforge-ui/src/layouts/SidebarLayout.tsx
@@ -28,6 +28,7 @@ export function SidebarLayout({ className }: { className?: string }) {
   const BrandLogo = useSlot('BrandLogo');
   const AgentsLibraryButton = useSlot('AgentsLibraryButton');
   const ClearChatButton = useSlot('ClearChatButton');
+  const GenerateInstructionsButton = useSlot('GenerateInstructionsButton');
   const SaveAgentButton = useSlot('SaveAgentButton');
   const SelectAgentEmptyState = useSlot('SelectAgentEmptyState');
   const [collapsed, setCollapsed] = useState(desktopCollapsed);
@@ -163,6 +164,7 @@ export function SidebarLayout({ className }: { className?: string }) {
               <NamedAgentHeaderLabel />
               <span className="min-w-0 flex-1" />
               <ClearChatButton />
+              <GenerateInstructionsButton />
               <SaveAgentButton />
             </>
           ) : (
diff --git a/packages/trueforge-ui/src/layouts/StackChatPanel.tsx b/packages/trueforge-ui/src/layouts/StackChatPanel.tsx
index e84396494..dafffba02 100644
--- a/packages/trueforge-ui/src/layouts/StackChatPanel.tsx
+++ b/packages/trueforge-ui/src/layouts/StackChatPanel.tsx
@@ -31,6 +31,7 @@ export function StackChatPanel({ className, threadHeaderEnd }: StackChatPanelPro
   const aui = useAui();
   const shell = useOptionalShellMode();
   const ClearChatButton = useSlot('ClearChatButton');
+  const GenerateInstructionsButton = useSlot('GenerateInstructionsButton');
   const SaveAgentButton = useSlot('SaveAgentButton');
   const SelectAgentEmptyState = useSlot('SelectAgentEmptyState');
   const isIdle = shell?.mode.status === 'idle';
@@ -78,6 +79,7 @@ export function StackChatPanel({ className, threadHeaderEnd }: StackChatPanelPro
             <NamedAgentHeaderLabel />
             <span className="min-w-0 flex-1" />
             <ClearChatButton />
+            <GenerateInstructionsButton />
             <SaveAgentButton />
             {threadHeaderEnd}
           </header>
diff --git a/packages/trueforge-ui/src/plugins/trueforge-agent-server-adapter/chatServer.ts b/packages/trueforge-ui/src/plugins/trueforge-agent-server-adapter/chatServer.ts
index cb6053f37..d1cee1b08 100644
--- a/packages/trueforge-ui/src/plugins/trueforge-agent-server-adapter/chatServer.ts
+++ b/packages/trueforge-ui/src/plugins/trueforge-agent-server-adapter/chatServer.ts
@@ -12,6 +12,7 @@
  * agent. The UI filters with registry `agentId`.
  */
 import type { TrueForge, TrueForgeApi } from '@truefoundry/trueforge-sdk';
+import type { GeneratedChatInstructions } from '../../server/generateInstructionsFromChat.js';
 import type {
   AgentChatServer,
   ListResult,
@@ -146,9 +147,59 @@ function toHarnessInput(input: TurnInputItem[]): TrueForgeApi.TurnInputItem[] {
   );
 }
 
-export function createHarnessChatServer(
-  options: CreateHarnessChatServerOptions = {},
-): AgentChatServer<HarnessAgentSpec> {
+function readApiErrorMessage(body: unknown, fallback: string): string {
+  if (typeof body !== 'object' || body === null) {
+    return fallback;
+  }
+  const error = Reflect.get(body, 'error');
+  if (typeof error !== 'object' || error === null) {
+    return fallback;
+  }
+  const message = Reflect.get(error, 'message');
+  return typeof message === 'string' && message.trim() !== '' ? message : fallback;
+}
+
+function readGeneratedChatInstructions(body: unknown): GeneratedChatInstructions | undefined {
+  if (typeof body !== 'object' || body === null) {
+    return undefined;
+  }
+  const data = Reflect.get(body, 'data');
+  if (typeof data !== 'object' || data === null) {
+    return undefined;
+  }
+  const instructions = Reflect.get(data, 'instructions');
+  if (typeof instructions !== 'string' || instructions.trim() === '') {
+    return undefined;
+  }
+  const current = Reflect.get(data, 'current_instructions');
+  const currentInstructions = typeof current === 'string' ? current : null;
+  const sourcesRaw = Reflect.get(data, 'sources');
+  const sources: GeneratedChatInstructions['sources'] = [];
+  if (Array.isArray(sourcesRaw)) {
+    for (const item of sourcesRaw) {
+      if (typeof item !== 'object' || item === null) {
+        continue;
+      }
+      const turnId = Reflect.get(item, 'turn_id');
+      const role = Reflect.get(item, 'role');
+      const excerpt = Reflect.get(item, 'excerpt');
+      if (typeof turnId !== 'string' || typeof excerpt !== 'string') {
+        continue;
+      }
+      if (role !== 'user' && role !== 'assistant') {
+        continue;
+      }
+      sources.push({ turnId, role, excerpt });
+    }
+  }
+  return { instructions, currentInstructions, sources };
+}
+
+export type HarnessChatServer = AgentChatServer<HarnessAgentSpec> & {
+  generateInstructionsFromChat: (request: { sessionId: string }) => Promise<GeneratedChatInstructions>;
+};
+
+export function createHarnessChatServer(options: CreateHarnessChatServerOptions = {}): HarnessChatServer {
   const client = options.client ?? createTrueForgeClient(options);
   return {
     // The sandbox is resolved server-side from the turn, so `sandboxId` is accepted for parity
@@ -268,5 +319,20 @@ export function createHarnessChatServer(
       });
       return toListResult(page, toUiEventItem);
     },
+
+    async generateInstructionsFromChat({ sessionId }) {
+      const response = await client.fetch(`/api/v1/sessions/${encodeURIComponent(sessionId)}/generate-instructions`, {
+        method: 'POST',
+      });
+      const body: unknown = await response.json().catch(() => undefined);
+      if (!response.ok) {
+        throw new Error(readApiErrorMessage(body, 'Could not generate instructions from this chat'));
+      }
+      const parsed = readGeneratedChatInstructions(body);
+      if (parsed === undefined) {
+        throw new Error('Could not generate instructions from this chat');
+      }
+      return parsed;
+    },
   };
 }
diff --git a/packages/trueforge-ui/src/plugins/trueforge-agent-server-adapter/index.ts b/packages/trueforge-ui/src/plugins/trueforge-agent-server-adapter/index.ts
index 22f806734..1a08b361a 100644
--- a/packages/trueforge-ui/src/plugins/trueforge-agent-server-adapter/index.ts
+++ b/packages/trueforge-ui/src/plugins/trueforge-agent-server-adapter/index.ts
@@ -45,6 +45,7 @@ export {
   toHarnessAgentSpec,
   toUiAgentSpec,
   type CreateHarnessChatServerOptions,
+  type HarnessChatServer,
 } from './chatServer.js';
 export { createTrueForgeClient } from './client.js';
 export type { CreateTrueForgeClientOptions } from './client.js';
diff --git a/packages/trueforge-ui/src/server/generateInstructionsFromChat.ts b/packages/trueforge-ui/src/server/generateInstructionsFromChat.ts
new file mode 100644
index 000000000..56fd0582b
--- /dev/null
+++ b/packages/trueforge-ui/src/server/generateInstructionsFromChat.ts
@@ -0,0 +1,25 @@
+import type { AgentUIServer } from './types.js';
+
+export type GeneratedChatInstructionSource = {
+  turnId: string;
+  role: 'user' | 'assistant';
+  excerpt: string;
+};
+
+export type GeneratedChatInstructions = {
+  instructions: string;
+  currentInstructions: string | null;
+  sources: GeneratedChatInstructionSource[];
+};
+
+export type GenerateInstructionsFromChat = (request: { sessionId: string }) => Promise<GeneratedChatInstructions>;
+
+export type AgentUIServerWithInstructionDraft = AgentUIServer & {
+  generateInstructionsFromChat: GenerateInstructionsFromChat;
+};
+
+export function hasGenerateInstructionsFromChat(
+  server: AgentUIServer | null,
+): server is AgentUIServerWithInstructionDraft {
+  return server != null && typeof Reflect.get(server, 'generateInstructionsFromChat') === 'function';
+}
diff --git a/packages/trueforge-ui/src/theme/defaultSlots.ts b/packages/trueforge-ui/src/theme/defaultSlots.ts
index e3a9f07c1..f4d77b4ab 100644
--- a/packages/trueforge-ui/src/theme/defaultSlots.ts
+++ b/packages/trueforge-ui/src/theme/defaultSlots.ts
@@ -20,6 +20,7 @@ import { ComposerShell } from '../atoms/ComposerShell.js';
 import { DraftComposerLeftSection, DraftComposerRightSection } from '../atoms/draft/DraftComposerSections.js';
 import { DraftCompositeSelector } from '../atoms/draft/DraftCompositeSelector.js';
 import { DraftModelSelector } from '../atoms/draft/DraftModelSelector.js';
+import { GenerateInstructionsButton } from '../atoms/GenerateInstructionsButton.js';
 import { HistoryLoader } from '../atoms/HistoryLoader.js';
 import { Markdown } from '../atoms/Markdown.js';
 import { MessageActionBar } from '../atoms/MessageActionBar.js';
@@ -115,6 +116,7 @@ export const defaultSlots = {
   AgentsLibrary,
   AgentsLibraryButton,
   SaveAgentButton,
+  GenerateInstructionsButton,
   SelectAgentEmptyState,
   ClearChatButton,
   ThreadListRowSkeleton,
diff --git a/packages/trueforge-ui/test/atoms/GenerateInstructionsButton.test.tsx b/packages/trueforge-ui/test/atoms/GenerateInstructionsButton.test.tsx
new file mode 100644
index 000000000..6bf25a022
--- /dev/null
+++ b/packages/trueforge-ui/test/atoms/GenerateInstructionsButton.test.tsx
@@ -0,0 +1,182 @@
+// @vitest-environment jsdom
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { GenerateInstructionsButton } from '@/atoms/GenerateInstructionsButton.js';
+import { ServerProvider } from '@/server/ServerContext.js';
+import { ShellModeProvider } from '@/server/ShellModeContext.js';
+import type { AgentSpec, AgentUIServer } from '@/server/types.js';
+import { SlotsProvider } from '@/theme/SlotsProvider.js';
+import { createMockAgentUIServer } from '../server/mockServer.js';
+
+let agentSpec: AgentSpec;
+const flushAgentSpec = vi.fn(async () => undefined);
+const adoptAgentSpec = vi.fn();
+const generateInstructionsFromChat = vi.fn();
+
+vi.mock('@truefoundry/assistant-ui-runtime', () => ({
+  useTrueFoundryAgentSpec: () => ({ agentSpec, draftSessionId: 'draft-1' }),
+  useTrueFoundryFlushAgentSpec: () => flushAgentSpec,
+  useTrueFoundryAdoptAgentSpec: () => adoptAgentSpec,
+}));
+
+vi.mock('@/assistant-ui.js', () => ({
+  useAuiState: (selector: (state: { threadListItem: { remoteId?: string } }) => unknown) =>
+    selector({ threadListItem: { remoteId: 'sess-1' } }),
+}));
+
+beforeAll(() => {
+  HTMLDialogElement.prototype.showModal = function showModal() {
+    this.setAttribute('open', '');
+  };
+  HTMLDialogElement.prototype.close = function close() {
+    this.removeAttribute('open');
+    this.dispatchEvent(new Event('close'));
+  };
+});
+
+function renderButton(serverOverrides: Partial<AgentUIServer> = {}) {
+  const server = {
+    ...createMockAgentUIServer({
+      updateSession: vi.fn(async ({ agentSpec: next }) => ({
+        id: 'sess-1',
+        isMutable: true,
+        createdAt: '2026-08-01T00:00:00.000Z',
+        updatedAt: '2026-08-01T00:00:01.000Z',
+        agentSpec: next,
+      })),
+      ...serverOverrides,
+    }),
+    generateInstructionsFromChat,
+  };
+  return {
+    server,
+    ...render(
+      <SlotsProvider>
+        <ServerProvider server={server}>
+          <ShellModeProvider agentConfig={{ mode: 'AgentComposer' }}>
+            <GenerateInstructionsButton />
+          </ShellModeProvider>
+        </ServerProvider>
+      </SlotsProvider>,
+    ),
+  };
+}
+
+describe('GenerateInstructionsButton', () => {
+  beforeEach(() => {
+    agentSpec = { model: { name: 'openai/gpt-4.1' }, instructions: 'Be helpful.' };
+    flushAgentSpec.mockClear();
+    adoptAgentSpec.mockClear();
+    generateInstructionsFromChat.mockReset();
+    generateInstructionsFromChat.mockResolvedValue({
+      instructions: 'Write changelog-style release notes. Never mention ticket ids.',
+      currentInstructions: 'Be helpful.',
+      sources: [{ turnId: 't1', role: 'user', excerpt: 'Always use a changelog.' }],
+    });
+  });
+
+  it('hides when the host cannot generate instructions', () => {
+    render(
+      <SlotsProvider>
+        <ServerProvider server={createMockAgentUIServer()}>
+          <ShellModeProvider agentConfig={{ mode: 'AgentComposer' }}>
+            <GenerateInstructionsButton />
+          </ShellModeProvider>
+        </ServerProvider>
+      </SlotsProvider>,
+    );
+    expect(screen.queryByRole('button', { name: /From chat/i })).not.toBeInTheDocument();
+  });
+
+  it('fills an editable draft and does not apply until confirmed', async () => {
+    renderButton();
+    fireEvent.click(screen.getByRole('button', { name: /From chat/i }));
+
+    await waitFor(() => {
+      expect(generateInstructionsFromChat).toHaveBeenCalledWith({ sessionId: 'sess-1' });
+    });
+    const textarea = screen.getByLabelText('Suggested instructions');
+    expect(textarea).toHaveValue('Write changelog-style release notes. Never mention ticket ids.');
+    expect(screen.getByText(/Always use a changelog/)).toBeInTheDocument();
+    expect(adoptAgentSpec).not.toHaveBeenCalled();
+
+    fireEvent.change(textarea, { target: { value: 'Edited instructions for this chat.' } });
+    fireEvent.click(screen.getByRole('button', { name: /Apply to this chat/i }));
+
+    await waitFor(() => {
+      expect(adoptAgentSpec).toHaveBeenCalled();
+    });
+    expect(adoptAgentSpec.mock.calls[0]?.[0]).toEqual(
+      expect.objectContaining({
+        agentSpec: expect.objectContaining({ instructions: 'Edited instructions for this chat.' }),
+      }),
+    );
+  });
+
+  it('offers copy but not apply on a named-agent chat', async () => {
+    const server = {
+      ...createMockAgentUIServer(),
+      generateInstructionsFromChat,
+    };
+    render(
+      <SlotsProvider>
+        <ServerProvider server={server}>
+          <ShellModeProvider agentConfig={{ mode: 'SingleAgent', name: 'writer' }}>
+            <GenerateInstructionsButton />
+          </ShellModeProvider>
+        </ServerProvider>
+      </SlotsProvider>,
+    );
+    fireEvent.click(screen.getByRole('button', { name: /From chat/i }));
+    await waitFor(() => {
+      expect(screen.getByLabelText('Suggested instructions')).toHaveValue(
+        'Write changelog-style release notes. Never mention ticket ids.',
+      );
+    });
+    expect(screen.queryByRole('button', { name: /Apply to this chat/i })).not.toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /Copy/i })).toBeEnabled();
+    expect(adoptAgentSpec).not.toHaveBeenCalled();
+  });
+
+  it('shows the server error for a short chat and leaves instructions untouched', async () => {
+    generateInstructionsFromChat.mockRejectedValue(
+      new Error('This chat is too short to infer durable system instructions.'),
+    );
+    renderButton();
+    fireEvent.click(screen.getByRole('button', { name: /From chat/i }));
+
+    await waitFor(() => {
+      expect(screen.getByRole('alert')).toHaveTextContent(/too short/i);
+    });
+    expect(screen.queryByRole('button', { name: /Apply to this chat/i })).toBeDisabled();
+    expect(adoptAgentSpec).not.toHaveBeenCalled();
+  });
+
+  it('starts only one generate if From chat is clicked twice', async () => {
+    let resolveGenerate: (value: {
+      instructions: string;
+      currentInstructions: string;
+      sources: Array<{ turnId: string; role: 'user' | 'assistant'; excerpt: string }>;
+    }) => void = () => undefined;
+    generateInstructionsFromChat.mockImplementation(
+      () =>
+        new Promise(resolve => {
+          resolveGenerate = resolve;
+        }),
+    );
+    renderButton();
+    const button = screen.getByRole('button', { name: /From chat/i });
+    fireEvent.click(button);
+    fireEvent.click(button);
+    expect(generateInstructionsFromChat).toHaveBeenCalledTimes(1);
+    resolveGenerate({
+      instructions: 'Only one draft.',
+      currentInstructions: 'Be helpful.',
+      sources: [],
+    });
+    await waitFor(() => {
+      expect(screen.getByLabelText('Suggested instructions')).toHaveValue('Only one draft.');
+    });
+  });
+});
diff --git a/packages/trueforge-ui/test/plugins/trueforge-agent-server-adapter/harnessServer.test.ts b/packages/trueforge-ui/test/plugins/trueforge-agent-server-adapter/harnessServer.test.ts
index 57c2b0485..343a4a838 100644
--- a/packages/trueforge-ui/test/plugins/trueforge-agent-server-adapter/harnessServer.test.ts
+++ b/packages/trueforge-ui/test/plugins/trueforge-agent-server-adapter/harnessServer.test.ts
@@ -268,4 +268,26 @@ describe('createHarnessChatServer', () => {
       },
     ]);
   });
+
+  it('drafts instructions from chat without applying them', async () => {
+    const fetchGenerate: typeof fetch = async (input, init) => {
+      const url = input instanceof Request ? input.url : String(input);
+      const method = init?.method ?? 'GET';
+      if (url.endsWith('/api/v1/sessions/ses_1/generate-instructions') && method === 'POST') {
+        return Response.json({
+          data: {
+            instructions: 'Write changelog-style release notes.',
+            current_instructions: 'Be helpful.',
+            sources: [{ turn_id: 't1', role: 'user', excerpt: 'Always use a changelog.' }],
+          },
+        });
+      }
+      return fetchMock(input, init);
+    };
+    const server = createHarnessChatServer({ fetch: fetchGenerate });
+    const result = await server.generateInstructionsFromChat({ sessionId: 'ses_1' });
+    assert.equal(result.instructions, 'Write changelog-style release notes.');
+    assert.equal(result.currentInstructions, 'Be helpful.');
+    assert.deepEqual(result.sources, [{ turnId: 't1', role: 'user', excerpt: 'Always use a changelog.' }]);
+  });
 });
diff --git a/packages/trueforge-ui/test/publicUiExports.test.ts b/packages/trueforge-ui/test/publicUiExports.test.ts
index 8fd9d6952..2089e13ad 100644
--- a/packages/trueforge-ui/test/publicUiExports.test.ts
+++ b/packages/trueforge-ui/test/publicUiExports.test.ts
@@ -38,6 +38,7 @@ const expectedRuntimeExports: Array<keyof typeof sdk> = [
   'DraftCompositeSelector',
   'DraftModelSelector',
   'ToasterProvider',
+  'GenerateInstructionsButton',
   'HistoryLoader',
   'HistoryLoaderContainer',
   'Icon',
diff --git a/packages/trueforge/src/apis/sessions.ts b/packages/trueforge/src/apis/sessions.ts
index eb92d3657..1aaaa04ab 100644
--- a/packages/trueforge/src/apis/sessions.ts
+++ b/packages/trueforge/src/apis/sessions.ts
@@ -10,7 +10,7 @@ import {
   SessionStoreNotFoundError,
   TurnNotFoundError,
 } from '@truefoundry/trueforge-core/agent-session';
-import { extractErrorLogFields } from '@truefoundry/trueforge-core/core';
+import { extractErrorLogFields, VercelAILLM } from '@truefoundry/trueforge-core/core';
 import {
   redisRequest,
   RequestTimeoutError,
@@ -32,14 +32,25 @@ import {
   cancelSessionRoute,
   createSessionRoute,
   deleteSessionRoute,
+  generateSessionInstructionsRoute,
   getSessionRoute,
   listSessionEventsRoute,
   listSessionsRoute,
   updateSessionRoute,
 } from '../routes/sessionRoutes';
 import type { ActiveTurnRegistry } from '../runtime/activeTurns';
+import {
+  assertTranscriptHasInstructionSignal,
+  extractChatTranscript,
+  InsufficientChatSignalError,
+} from '../runtime/chatInstructionTranscript';
+import {
+  draftInstructionsFromChat,
+  loadInstructionTranscriptEvents,
+  resolveSessionAgentSpec,
+} from '../runtime/generateSessionInstructions';
 import { executorFromTurnId } from '../runtime/peeringIds';
-import { validateAgentSpec } from '../runtime/sessionResources';
+import { getModelDetails, validateAgentSpec } from '../runtime/sessionResources';
 import { isSessionAgentNameRef, type Session } from '../schemas/session';
 
 /** The server is single-tenant; every record lives under one fixed tenant scope. */
@@ -396,6 +407,75 @@ export function createSessionsRouter(deps: SessionsRouterDeps) {
     }
   };
 
+  const generateSessionInstructionsHandler: RouteHandler<typeof generateSessionInstructionsRoute> = async c => {
+    const { session_id: sessionId } = c.req.valid('param');
+    const session = await deps.sessions.get({ tenant_id: TENANT_ID, session_id: sessionId });
+    if (!session) {
+      return c.json({ error: { message: `Session not found: ${sessionId}` } }, 404);
+    }
+    if (!checkSessionAccess({ userRef: deps.resolveUserContext(c).userRef, createdBy: session.record.created_by })) {
+      return c.json({ error: { message: FORBIDDEN_SESSION_ACCESS } }, 403);
+    }
+
+    const spec = await resolveSessionAgentSpec({
+      agent: session.record.agent,
+      getAgentById: id => deps.agentStore.getAgent({ tenant_id: TENANT_ID, id }),
+    });
+    if (spec === undefined) {
+      return c.json({ error: { message: `Agent not found for session: ${sessionId}` } }, 422);
+    }
+
+    let events;
+    try {
+      events = await loadInstructionTranscriptEvents(session);
+    } catch (error) {
+      if (error instanceof SessionStoreConflictError) {
+        return c.json({ error: { message: error.message } }, 400);
+      }
+      if (error instanceof SessionStoreNotFoundError) {
+        return c.json({ error: { message: error.message } }, 404);
+      }
+      throw error;
+    }
+
+    try {
+      assertTranscriptHasInstructionSignal(extractChatTranscript(events));
+    } catch (error) {
+      if (error instanceof InsufficientChatSignalError) {
+        return c.json({ error: { message: error.message } }, 422);
+      }
+      throw error;
+    }
+
+    const { providerConfig } = await getModelDetails({
+      tenant_id: TENANT_ID,
+      name: spec.model.name,
+      store: deps.modelProviderStore,
+    });
+
+    try {
+      const data = await draftInstructionsFromChat({
+        events,
+        currentInstructions: spec.instructions,
+        llm: new VercelAILLM({
+          providerConfig,
+          logger: deps.logger,
+          signal: c.req.raw.signal,
+        }),
+      });
+      return c.json({ data }, 200);
+    } catch (error) {
+      if (error instanceof InsufficientChatSignalError) {
+        return c.json({ error: { message: error.message } }, 422);
+      }
+      deps.logger.warn('Failed to generate session instructions', {
+        sessionId,
+        ...extractErrorLogFields(error),
+      });
+      return c.json({ error: { message: 'Failed to generate instructions from this chat' } }, 502);
+    }
+  };
+
   const router = new OpenAPIHono();
   router.openapi(createSessionRoute, createSessionHandler);
   router.openapi(getSessionRoute, getSessionHandler);
@@ -404,6 +484,7 @@ export function createSessionsRouter(deps: SessionsRouterDeps) {
   router.openapi(listSessionsRoute, listSessionsHandler);
   router.openapi(cancelSessionRoute, cancelSessionHandler);
   router.openapi(listSessionEventsRoute, listSessionEventsHandler);
+  router.openapi(generateSessionInstructionsRoute, generateSessionInstructionsHandler);
   deps.requestReplyRouter.registerRoute(SESSIONS_CANCEL_PATH, cancelSessionTurnPeerHandler(deps.activeTurns));
   return router;
 }
diff --git a/packages/trueforge/src/routes/sessionRoutes.ts b/packages/trueforge/src/routes/sessionRoutes.ts
index 441657579..1e6b065f8 100644
--- a/packages/trueforge/src/routes/sessionRoutes.ts
+++ b/packages/trueforge/src/routes/sessionRoutes.ts
@@ -8,6 +8,7 @@ import { RequestErrorResponseSchema } from '../schemas/errors';
 import { ListSessionEventsRequestQuerySchema, ListSessionEventsResponseSchema } from '../schemas/events';
 import {
   CreateSessionRequestSchema,
+  GenerateSessionInstructionsResponseSchema,
   GetSessionResponseSchema,
   ListSessionsRequestQuerySchema,
   ListSessionsResponseSchema,
@@ -242,3 +243,44 @@ export const listSessionEventsRoute = createRoute({
     },
   },
 });
+
+export const generateSessionInstructionsRoute = createRoute({
+  method: 'post',
+  path: '/{session_id}/generate-instructions',
+  tags: [OpenApiTag.AGENT_SESSIONS],
+  summary: 'Generate system instructions from chat history',
+  description:
+    "Draft system instructions from this session's transcript and current instructions. The suggestion is not saved. The client must show it for edit and apply it with a separate session or agent update. Short chats that do not establish behavior return 422.",
+  'x-fern-sdk-group-name': ['sessions'],
+  'x-fern-sdk-method-name': 'generate_instructions',
+  request: {
+    params: SessionIdParamsSchema,
+  },
+  responses: {
+    200: {
+      content: { 'application/json': { schema: GenerateSessionInstructionsResponseSchema } },
+      description: 'Suggested instructions and the transcript excerpts they came from.',
+    },
+    400: {
+      content: { 'application/json': { schema: RequestErrorResponseSchema } },
+      description: 'The session event log could not be read because of a conflicting store state.',
+    },
+    403: {
+      content: { 'application/json': { schema: RequestErrorResponseSchema } },
+      description: 'Caller is not the session creator.',
+    },
+    404: {
+      content: { 'application/json': { schema: RequestErrorResponseSchema } },
+      description: 'Session or referenced turn not found.',
+    },
+    422: {
+      content: { 'application/json': { schema: RequestErrorResponseSchema } },
+      description:
+        'The chat is too short to infer durable instructions, the named agent is missing, or the session model is not configured.',
+    },
+    502: {
+      content: { 'application/json': { schema: RequestErrorResponseSchema } },
+      description: 'The model call to draft instructions failed.',
+    },
+  },
+});
diff --git a/packages/trueforge/src/runtime/chatInstructionTranscript.ts b/packages/trueforge/src/runtime/chatInstructionTranscript.ts
new file mode 100644
index 000000000..608a69bdd
--- /dev/null
+++ b/packages/trueforge/src/runtime/chatInstructionTranscript.ts
@@ -0,0 +1,191 @@
+/**
+ * Turns a session event log into a bounded chat transcript used to draft
+ * system instructions. Kept free of I/O so short-chat rejection is deterministic.
+ */
+import { EventType, MAIN_THREAD_ID, type SessionEventItem } from '@truefoundry/trueforge-core/agent-session';
+import type { ChatInstructionSource } from '../schemas/session';
+
+export const INSUFFICIENT_SIGNAL_TOKEN = 'INSUFFICIENT_SIGNAL';
+
+/** Below this much *user* text, the chat is greetings and small talk, not durable behavior. */
+export const MIN_TRANSCRIPT_CHARS = 80;
+const MAX_TRANSCRIPT_CHARS = 12_000;
+const MAX_SOURCES = 8;
+const EXCERPT_CHARS = 180;
+const MIN_INSTRUCTION_CHARS = 24;
+
+const GENERIC_INSTRUCTION = /^(you are (a |an )?(helpful|friendly|useful)( ai| virtual)? assistant\.?)$/i;
+
+export type ChatInstructionRole = 'user' | 'assistant';
+
+export interface ChatInstructionLine {
+  turn_id: string;
+  role: ChatInstructionRole;
+  text: string;
+}
+
+export class InsufficientChatSignalError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'InsufficientChatSignalError';
+  }
+}
+
+function textFromUnknownContent(content: unknown): string {
+  if (typeof content === 'string') {
+    return content.trim();
+  }
+  if (!Array.isArray(content)) {
+    return '';
+  }
+  const parts: string[] = [];
+  for (const part of content) {
+    if (typeof part !== 'object' || part === null) {
+      continue;
+    }
+    const type: unknown = Reflect.get(part, 'type');
+    if (type === 'text') {
+      const text: unknown = Reflect.get(part, 'text');
+      if (typeof text === 'string' && text.trim() !== '') {
+        parts.push(text.trim());
+      }
+      continue;
+    }
+    if (type === 'file') {
+      const name: unknown = Reflect.get(part, 'name');
+      if (typeof name === 'string' && name.trim() !== '') {
+        parts.push(`[file: ${name.trim()}]`);
+      }
+    }
+  }
+  return parts.join('\n');
+}
+
+function excerptFrom(text: string): string {
+  const compact = text.replace(/\s+/g, ' ').trim();
+  if (compact.length <= EXCERPT_CHARS) {
+    return compact;
+  }
+  return `${compact.slice(0, EXCERPT_CHARS - 1).trimEnd()}…`;
+}
+
+function stripFence(raw: string): string {
+  const trimmed = raw.trim();
+  const fenced = /^```(?:[\w-]+)?\n([\s\S]*?)\n```$/.exec(trimmed);
+  if (fenced?.[1] !== undefined) {
+    return fenced[1].trim();
+  }
+  return trimmed;
+}
+
+/**
+ * Walk newest-first events, keep user turns and root-agent replies, then
+ * reverse so the prompt reads oldest to newest within the character budget.
+ */
+export function extractChatTranscript(events: readonly SessionEventItem[]): ChatInstructionLine[] {
+  const newestFirst: ChatInstructionLine[] = [];
+  let used = 0;
+
+  for (const item of events) {
+    if (used >= MAX_TRANSCRIPT_CHARS) {
+      break;
+    }
+    const event = item.event;
+    if (event.type === EventType.TURN_CREATED) {
+      const input = event.input ?? [];
+      // Events are newest-first; walk the turn's user items newest-first too so
+      // the final transcript reverse keeps them chronological within the turn.
+      for (let i = input.length - 1; i >= 0; i -= 1) {
+        const part = input[i];
+        if (part.type !== EventType.USER_MESSAGE) {
+          continue;
+        }
+        const text = textFromUnknownContent(part.content);
+        if (text.length === 0) {
+          continue;
+        }
+        const clipped = text.slice(0, MAX_TRANSCRIPT_CHARS - used);
+        newestFirst.push({ turn_id: item.turn_id, role: 'user', text: clipped });
+        used += clipped.length;
+        if (used >= MAX_TRANSCRIPT_CHARS) {
+          break;
+        }
+      }
+      continue;
+    }
+    if (event.type !== EventType.MODEL_MESSAGE || event.thread_id !== MAIN_THREAD_ID) {
+      continue;
+    }
+    const text = textFromUnknownContent(Reflect.get(event, 'content'));
+    if (text.length === 0) {
+      continue;
+    }
+    const clipped = text.slice(0, MAX_TRANSCRIPT_CHARS - used);
+    newestFirst.push({ turn_id: item.turn_id, role: 'assistant', text: clipped });
+    used += clipped.length;
+  }
+
+  return newestFirst.reverse();
+}
+
+export function sourcesFromTranscript(lines: readonly ChatInstructionLine[]): ChatInstructionSource[] {
+  const picked = lines.length <= MAX_SOURCES ? lines : lines.slice(-MAX_SOURCES);
+  return picked.map(line => ({
+    turn_id: line.turn_id,
+    role: line.role,
+    excerpt: excerptFrom(line.text),
+  }));
+}
+
+export function assertTranscriptHasInstructionSignal(lines: readonly ChatInstructionLine[]): void {
+  const userLines = lines.filter(line => line.role === 'user');
+  const userChars = userLines.reduce((sum, line) => sum + line.text.length, 0);
+  if (userLines.length === 0 || userChars < MIN_TRANSCRIPT_CHARS) {
+    throw new InsufficientChatSignalError(
+      'This chat is too short to infer durable system instructions. Continue the conversation, or write the instructions yourself.',
+    );
+  }
+}
+
+export function buildInstructionGenerationPrompt(input: {
+  currentInstructions: string | undefined;
+  lines: readonly ChatInstructionLine[];
+}): { system: string; user: string } {
+  const current = input.currentInstructions?.trim() ?? '';
+  const transcript = input.lines.map(line => `[${line.role}] ${line.text}`).join('\n\n');
+  return {
+    system: [
+      'You extract durable system instructions for an AI agent from a chat transcript.',
+      "Write instructions a maintainer would save as the agent's system prompt.",
+      'Capture only preferences, constraints, tone, format, and domain the conversation actually established.',
+      'Do not invent a persona, tools, or policies the chat did not show.',
+      'Do not retell the conversation or quote it at length.',
+      `If the chat is too thin to write real instructions, reply with exactly ${INSUFFICIENT_SIGNAL_TOKEN} and nothing else.`,
+      'Output plain text only. No title, no markdown fences, no preamble.',
+    ].join(' '),
+    user: [
+      'Current instructions (may be empty):',
+      current.length > 0 ? current : '(none)',
+      '',
+      'Transcript, oldest first:',
+      transcript,
+      '',
+      'Write the system instructions.',
+    ].join('\n'),
+  };
+}
+
+export function parseGeneratedInstructions(raw: string): string {
+  const cleaned = stripFence(raw);
+  if (cleaned.length === 0 || cleaned.toUpperCase() === INSUFFICIENT_SIGNAL_TOKEN) {
+    throw new InsufficientChatSignalError(
+      'This chat does not establish how the agent should behave. Continue the conversation, or write the instructions yourself.',
+    );
+  }
+  if (cleaned.length < MIN_INSTRUCTION_CHARS || GENERIC_INSTRUCTION.test(cleaned)) {
+    throw new InsufficientChatSignalError(
+      'The model could not infer durable instructions from this chat. Continue the conversation, or write them yourself.',
+    );
+  }
+  return cleaned;
+}
diff --git a/packages/trueforge/src/runtime/generateSessionInstructions.ts b/packages/trueforge/src/runtime/generateSessionInstructions.ts
new file mode 100644
index 000000000..8dddb3c58
--- /dev/null
+++ b/packages/trueforge/src/runtime/generateSessionInstructions.ts
@@ -0,0 +1,104 @@
+/**
+ * Drafts system instructions from a session transcript. Does not write them
+ * back — the caller returns a suggestion the user can edit and apply.
+ */
+import type {
+  AgentSpec,
+  SessionAgent,
+  SessionEventItem,
+  TokenPagination,
+} from '@truefoundry/trueforge-core/agent-session';
+import type { ILLM } from '@truefoundry/trueforge-core/core';
+import type { GeneratedSessionInstructions } from '../schemas/session';
+import {
+  assertTranscriptHasInstructionSignal,
+  buildInstructionGenerationPrompt,
+  extractChatTranscript,
+  parseGeneratedInstructions,
+  sourcesFromTranscript,
+} from './chatInstructionTranscript';
+
+function textFromLlmContent(content: unknown): string {
+  if (typeof content === 'string') {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return '';
+  }
+  const parts: string[] = [];
+  for (const part of content) {
+    if (typeof part !== 'object' || part === null) {
+      continue;
+    }
+    if (Reflect.get(part, 'type') !== 'text') {
+      continue;
+    }
+    const text: unknown = Reflect.get(part, 'text');
+    if (typeof text === 'string') {
+      parts.push(text);
+    }
+  }
+  return parts.join('\n');
+}
+
+export async function loadInstructionTranscriptEvents(session: {
+  listEvents: (input: {
+    limit: number;
+    page_token?: string | undefined;
+  }) => Promise<{ data: SessionEventItem[]; pagination: TokenPagination }>;
+}): Promise<SessionEventItem[]> {
+  const events: SessionEventItem[] = [];
+  let pageToken: string | undefined;
+  for (let page = 0; page < 4; page += 1) {
+    const result = await session.listEvents({
+      limit: 100,
+      ...(pageToken === undefined ? {} : { page_token: pageToken }),
+    });
+    events.push(...result.data);
+    const next = result.pagination.next_page_token;
+    if (next === undefined || next.length === 0) {
+      break;
+    }
+    pageToken = next;
+  }
+  return events;
+}
+
+export async function resolveSessionAgentSpec(input: {
+  agent: SessionAgent;
+  getAgentById: (id: string) => Promise<{ manifest: AgentSpec } | undefined>;
+}): Promise<AgentSpec | undefined> {
+  if (input.agent.type === 'inline') {
+    return input.agent.spec;
+  }
+  const record = await input.getAgentById(input.agent.id);
+  return record?.manifest;
+}
+
+export async function draftInstructionsFromChat(input: {
+  events: readonly SessionEventItem[];
+  currentInstructions: string | undefined;
+  llm: ILLM;
+}): Promise<GeneratedSessionInstructions> {
+  const lines = extractChatTranscript(input.events);
+  assertTranscriptHasInstructionSignal(lines);
+  const prompt = buildInstructionGenerationPrompt({
+    currentInstructions: input.currentInstructions,
+    lines,
+  });
+  const completion = await input.llm.createNonStream({
+    temperature: 0.2,
+    max_tokens: 800,
+    messages: [
+      { role: 'system', content: prompt.system },
+      { role: 'user', content: prompt.user },
+    ],
+  });
+  const instructions = parseGeneratedInstructions(textFromLlmContent(completion.output.content));
+  const current = input.currentInstructions?.trim();
+  return {
+    instructions,
+    current_instructions: current === undefined || current.length === 0 ? null : current,
+    sources: sourcesFromTranscript(lines),
+  };
+}
diff --git a/packages/trueforge/src/schemas/session.ts b/packages/trueforge/src/schemas/session.ts
index 0583bdf7f..8e8298657 100644
--- a/packages/trueforge/src/schemas/session.ts
+++ b/packages/trueforge/src/schemas/session.ts
@@ -92,3 +92,34 @@ export const ListSessionsResponseSchema = z
     pagination: TokenPaginationSchema,
   })
   .openapi('ListSessionsResponse');
+
+export const ChatInstructionSourceSchema = z
+  .object({
+    turn_id: z.string().min(1).describe('Turn that contributed this excerpt.'),
+    role: z.enum(['user', 'assistant']).describe('Speaker of the excerpt.'),
+    excerpt: z.string().min(1).describe('Short quote from the transcript used as evidence.'),
+  })
+  .strict()
+  .openapi('ChatInstructionSource');
+
+export type ChatInstructionSource = z.infer<typeof ChatInstructionSourceSchema>;
+
+export const GeneratedSessionInstructionsSchema = z
+  .object({
+    instructions: z.string().min(1).describe('Suggested system instructions. Not applied until the client saves them.'),
+    current_instructions: z
+      .string()
+      .nullable()
+      .describe('Instructions currently on the session or named agent, if any.'),
+    sources: z.array(ChatInstructionSourceSchema).describe('Transcript excerpts the suggestion was inferred from.'),
+  })
+  .strict()
+  .openapi('GeneratedSessionInstructions');
+
+export type GeneratedSessionInstructions = z.infer<typeof GeneratedSessionInstructionsSchema>;
+
+export const GenerateSessionInstructionsResponseSchema = z
+  .object({
+    data: GeneratedSessionInstructionsSchema,
+  })
+  .openapi('GenerateSessionInstructionsResponse');
diff --git a/packages/trueforge/tests/unit/apis/sessionHttp.test.ts b/packages/trueforge/tests/unit/apis/sessionHttp.test.ts
index dd40b0027..7cbf82dd2 100644
--- a/packages/trueforge/tests/unit/apis/sessionHttp.test.ts
+++ b/packages/trueforge/tests/unit/apis/sessionHttp.test.ts
@@ -165,6 +165,10 @@ describe('sessions HTTP agent binding', () => {
     expect(cancelForbidden.status).toBe(403);
     expect(await cancelForbidden.json()).toEqual(forbiddenBody);
 
+    const generateForbidden = await app.request('/other-user-session/generate-instructions', { method: 'POST' });
+    expect(generateForbidden.status).toBe(403);
+    expect(await generateForbidden.json()).toEqual(forbiddenBody);
+
     const eventsForbidden = await app.request('/other-user-session/events');
     expect(eventsForbidden.status).toBe(403);
     expect(await eventsForbidden.json()).toEqual(forbiddenBody);
@@ -214,4 +218,15 @@ describe('sessions HTTP agent binding', () => {
     const both = await app.request('/', jsonInit('POST', { agent: { name: 'named-agent', ...inlineSpec } }));
     expect(both.status).toBe(400);
   });
+
+  it('rejects generate-instructions on an empty chat without calling a model', async () => {
+    const created = await app.request('/', jsonInit('POST', { agent: { spec: inlineSpec } }));
+    expect(created.status).toBe(201);
+    const { data } = (await created.json()) as { data: { id: string } };
+
+    const generated = await app.request(`/${data.id}/generate-instructions`, { method: 'POST' });
+    expect(generated.status).toBe(422);
+    const body = (await generated.json()) as { error: { message: string } };
+    expect(body.error.message).toMatch(/too short/i);
+  });
 });
diff --git a/packages/trueforge/tests/unit/runtime/chatInstructionTranscript.test.ts b/packages/trueforge/tests/unit/runtime/chatInstructionTranscript.test.ts
new file mode 100644
index 000000000..029c3e9ec
--- /dev/null
+++ b/packages/trueforge/tests/unit/runtime/chatInstructionTranscript.test.ts
@@ -0,0 +1,173 @@
+import { EventType, MAIN_THREAD_ID, type SessionEventItem } from '@truefoundry/trueforge-core/agent-session';
+import {
+  assertTranscriptHasInstructionSignal,
+  buildInstructionGenerationPrompt,
+  extractChatTranscript,
+  INSUFFICIENT_SIGNAL_TOKEN,
+  InsufficientChatSignalError,
+  parseGeneratedInstructions,
+  sourcesFromTranscript,
+} from '../../../src/runtime/chatInstructionTranscript';
+
+function userTurn(input: { turnId: string; text: string; eventId: string }): SessionEventItem {
+  return {
+    turn_id: input.turnId,
+    event: {
+      type: EventType.TURN_CREATED,
+      id: input.eventId,
+      turn_id: input.turnId,
+      previous_turn_id: null,
+      input: [{ type: EventType.USER_MESSAGE, content: input.text }],
+      state: { status: 'running' },
+      created_at: '2026-08-01T00:00:00.000Z',
+      thread_id: null,
+    },
+  };
+}
+
+function assistantMessage(input: {
+  turnId: string;
+  text: string;
+  eventId: string;
+  threadId?: string;
+}): SessionEventItem {
+  return {
+    turn_id: input.turnId,
+    event: {
+      type: EventType.MODEL_MESSAGE,
+      id: input.eventId,
+      thread_id: input.threadId ?? MAIN_THREAD_ID,
+      created_at: '2026-08-01T00:00:01.000Z',
+      content: input.text,
+    },
+  };
+}
+
+describe('chatInstructionTranscript', () => {
+  it('reads user turns and root assistant replies in chronological order', () => {
+    const lines = extractChatTranscript([
+      assistantMessage({ turnId: 't2', text: 'I will use a changelog format.', eventId: 'e4' }),
+      userTurn({
+        turnId: 't2',
+        text: 'Always summarize PRs as a changelog with breaking changes last.',
+        eventId: 'e3',
+      }),
+      assistantMessage({ turnId: 't1', text: 'Hi, how can I help?', eventId: 'e2' }),
+      userTurn({ turnId: 't1', text: 'Hello', eventId: 'e1' }),
+    ]);
+
+    expect(lines.map(line => `${line.role}:${line.text}`)).toEqual([
+      'user:Hello',
+      'assistant:Hi, how can I help?',
+      'user:Always summarize PRs as a changelog with breaking changes last.',
+      'assistant:I will use a changelog format.',
+    ]);
+  });
+
+  it('keeps multiple user messages in one turn in chronological order', () => {
+    const lines = extractChatTranscript([
+      {
+        turn_id: 't1',
+        event: {
+          type: EventType.TURN_CREATED,
+          id: 'e1',
+          turn_id: 't1',
+          previous_turn_id: null,
+          input: [
+            { type: EventType.USER_MESSAGE, content: 'First preference: be terse.' },
+            { type: EventType.USER_MESSAGE, content: 'Second preference: use a changelog.' },
+          ],
+          state: { status: 'running' },
+          created_at: '2026-08-01T00:00:00.000Z',
+          thread_id: null,
+        },
+      },
+    ]);
+    expect(lines.map(line => line.text)).toEqual([
+      'First preference: be terse.',
+      'Second preference: use a changelog.',
+    ]);
+  });
+
+  it('skips subagent replies', () => {
+    const lines = extractChatTranscript([
+      assistantMessage({
+        turnId: 't1',
+        text: 'Subagent noise',
+        eventId: 'e2',
+        threadId: 'child-1',
+      }),
+      userTurn({
+        turnId: 't1',
+        text: 'Write release notes in the house style, never mention internal ticket ids.',
+        eventId: 'e1',
+      }),
+    ]);
+    expect(lines).toEqual([
+      {
+        turn_id: 't1',
+        role: 'user',
+        text: 'Write release notes in the house style, never mention internal ticket ids.',
+      },
+    ]);
+  });
+
+  it('rejects greetings that do not establish behavior', () => {
+    const lines = extractChatTranscript([
+      assistantMessage({ turnId: 't1', text: 'Hi!', eventId: 'e2' }),
+      userTurn({ turnId: 't1', text: 'hey', eventId: 'e1' }),
+    ]);
+    expect(() => assertTranscriptHasInstructionSignal(lines)).toThrow(InsufficientChatSignalError);
+  });
+
+  it('does not let a long assistant reply pad a short user greeting past the gate', () => {
+    const canned =
+      'I am a helpful assistant. I can write code, summarize documents, and answer questions about your project in as much detail as you would like.';
+    const lines = extractChatTranscript([
+      assistantMessage({ turnId: 't1', text: canned, eventId: 'e2' }),
+      userTurn({ turnId: 't1', text: 'hi', eventId: 'e1' }),
+    ]);
+    expect(canned.length).toBeGreaterThan(80);
+    expect(() => assertTranscriptHasInstructionSignal(lines)).toThrow(InsufficientChatSignalError);
+  });
+
+  it('accepts a long user preference even without an assistant reply', () => {
+    const lines = extractChatTranscript([
+      userTurn({
+        turnId: 't1',
+        text: 'You are a release notes writer. Always group changes by feature, bugfix, and breaking. Never mention Jira keys.',
+        eventId: 'e1',
+      }),
+    ]);
+    expect(() => assertTranscriptHasInstructionSignal(lines)).not.toThrow();
+  });
+
+  it('treats INSUFFICIENT_SIGNAL and generic helper one-liners as a failed draft', () => {
+    expect(() => parseGeneratedInstructions(INSUFFICIENT_SIGNAL_TOKEN)).toThrow(InsufficientChatSignalError);
+    expect(() => parseGeneratedInstructions('You are a helpful assistant.')).toThrow(InsufficientChatSignalError);
+    expect(parseGeneratedInstructions('```\nAlways reply with a changelog grouped by feature.\n```')).toBe(
+      'Always reply with a changelog grouped by feature.',
+    );
+  });
+
+  it('builds a prompt that includes current instructions and the transcript', () => {
+    const prompt = buildInstructionGenerationPrompt({
+      currentInstructions: 'Be terse.',
+      lines: [
+        { turn_id: 't1', role: 'user', text: 'Prefer bullet lists.' },
+        { turn_id: 't1', role: 'assistant', text: 'Understood.' },
+      ],
+    });
+    expect(prompt.user).toContain('Be terse.');
+    expect(prompt.user).toContain('[user] Prefer bullet lists.');
+    expect(prompt.system).toContain(INSUFFICIENT_SIGNAL_TOKEN);
+  });
+
+  it('caps sources to the most recent lines', () => {
+    const sources = sourcesFromTranscript([
+      { turn_id: 't1', role: 'user', text: 'First' },
+      { turn_id: 't1', role: 'assistant', text: 'Second' },
+    ]);
+    expect(sources[0]).toEqual({ turn_id: 't1', role: 'user', excerpt: 'First' });
+  });
+});
diff --git a/packages/trueforge/tests/unit/runtime/generateSessionInstructions.test.ts b/packages/trueforge/tests/unit/runtime/generateSessionInstructions.test.ts
new file mode 100644
index 000000000..79ff66268
--- /dev/null
+++ b/packages/trueforge/tests/unit/runtime/generateSessionInstructions.test.ts
@@ -0,0 +1,170 @@
+import {
+  AgentSpecSchema,
+  EventType,
+  MAIN_THREAD_ID,
+  type SessionEventItem,
+} from '@truefoundry/trueforge-core/agent-session';
+import type { ILLM } from '@truefoundry/trueforge-core/core';
+import { InsufficientChatSignalError } from '../../../src/runtime/chatInstructionTranscript';
+import {
+  draftInstructionsFromChat,
+  loadInstructionTranscriptEvents,
+  resolveSessionAgentSpec,
+} from '../../../src/runtime/generateSessionInstructions';
+
+function llmThatReturns(text: string): ILLM {
+  return {
+    create: jest.fn(),
+    createNonStream: jest.fn().mockResolvedValue({
+      output: { role: 'assistant', content: text },
+      usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 },
+      finish_reason: 'stop',
+    }),
+  };
+}
+
+function richTranscript(): SessionEventItem[] {
+  return [
+    {
+      turn_id: 't1',
+      event: {
+        type: EventType.MODEL_MESSAGE,
+        id: 'e2',
+        thread_id: MAIN_THREAD_ID,
+        created_at: '2026-08-01T00:00:01.000Z',
+        content: 'I will write the notes in that format.',
+      },
+    },
+    {
+      turn_id: 't1',
+      event: {
+        type: EventType.TURN_CREATED,
+        id: 'e1',
+        turn_id: 't1',
+        previous_turn_id: null,
+        input: [
+          {
+            type: EventType.USER_MESSAGE,
+            content:
+              'You are a release notes writer. Group changes by feature then bugfix. Never mention internal ticket ids.',
+          },
+        ],
+        state: { status: 'running' },
+        created_at: '2026-08-01T00:00:00.000Z',
+        thread_id: null,
+      },
+    },
+  ];
+}
+
+describe('draftInstructionsFromChat', () => {
+  it('returns a suggestion without applying it', async () => {
+    const result = await draftInstructionsFromChat({
+      events: richTranscript(),
+      currentInstructions: 'Be helpful.',
+      llm: llmThatReturns('Write release notes grouped by feature then bugfix. Never mention ticket ids.'),
+    });
+    expect(result.current_instructions).toBe('Be helpful.');
+    expect(result.instructions).toContain('release notes');
+    expect(result.sources.length).toBeGreaterThan(0);
+    expect(result.sources[0]?.role).toBe('user');
+  });
+
+  it('does not call the model when the chat is too thin', async () => {
+    const llm = llmThatReturns('should not run');
+    const createNonStream = jest.spyOn(llm, 'createNonStream');
+    await expect(
+      draftInstructionsFromChat({
+        events: [],
+        currentInstructions: undefined,
+        llm,
+      }),
+    ).rejects.toBeInstanceOf(InsufficientChatSignalError);
+    expect(createNonStream).not.toHaveBeenCalled();
+  });
+
+  it('does not call the model when only the assistant side is long', async () => {
+    const llm = llmThatReturns('should not run');
+    const createNonStream = jest.spyOn(llm, 'createNonStream');
+    await expect(
+      draftInstructionsFromChat({
+        events: [
+          {
+            turn_id: 't1',
+            event: {
+              type: EventType.MODEL_MESSAGE,
+              id: 'e2',
+              thread_id: MAIN_THREAD_ID,
+              created_at: '2026-08-01T00:00:01.000Z',
+              content:
+                'Sure, I can help with that. I am a helpful assistant and I will write as much as you want about any topic you pick.',
+            },
+          },
+          {
+            turn_id: 't1',
+            event: {
+              type: EventType.TURN_CREATED,
+              id: 'e1',
+              turn_id: 't1',
+              previous_turn_id: null,
+              input: [{ type: EventType.USER_MESSAGE, content: 'hey' }],
+              state: { status: 'running' },
+              created_at: '2026-08-01T00:00:00.000Z',
+              thread_id: null,
+            },
+          },
+        ],
+        currentInstructions: undefined,
+        llm,
+      }),
+    ).rejects.toBeInstanceOf(InsufficientChatSignalError);
+    expect(createNonStream).not.toHaveBeenCalled();
+  });
+});
+
+describe('resolveSessionAgentSpec', () => {
+  const inlineSpec = AgentSpecSchema.parse({
+    model: { name: 'anthropic/claude-sonnet-4-6' },
+    instructions: 'inline',
+  });
+
+  it('returns an inline spec without a registry lookup', async () => {
+    const getAgentById = jest.fn();
+    const spec = await resolveSessionAgentSpec({
+      agent: { type: 'inline', spec: inlineSpec },
+      getAgentById,
+    });
+    expect(spec?.instructions).toBe('inline');
+    expect(getAgentById).not.toHaveBeenCalled();
+  });
+
+  it('resolves a named session from the agent store', async () => {
+    const spec = AgentSpecSchema.parse({
+      model: { name: 'anthropic/claude-sonnet-4-6' },
+      instructions: 'from-registry',
+    });
+    const resolved = await resolveSessionAgentSpec({
+      agent: { type: 'reference', id: 'agt_1', name: 'writer' },
+      getAgentById: async id => (id === 'agt_1' ? { manifest: spec } : undefined),
+    });
+    expect(resolved).toEqual(spec);
+  });
+});
+
+describe('loadInstructionTranscriptEvents', () => {
+  it('pages session events until the cursor is exhausted', async () => {
+    const listEvents = jest
+      .fn()
+      .mockResolvedValueOnce({
+        data: richTranscript().slice(0, 1),
+        pagination: { next_page_token: 'p2' },
+      })
+      .mockResolvedValueOnce({
+        data: richTranscript().slice(1),
+        pagination: {},
+      });
+    const events = await loadInstructionTranscriptEvents({ listEvents });
+    expect(listEvents).toHaveBeenCalledTimes(2);
+    expect(events).toHaveLength(2);
+  });
+});