diff --git a/output/playwright/new-chat-agents-dropdown.png b/output/playwright/new-chat-agents-dropdown.png
new file mode 100644
index 000000000..9d331ff8d
Binary files /dev/null and b/output/playwright/new-chat-agents-dropdown.png differ
diff --git a/src/App.vue b/src/App.vue
index 3394df590..e38af8b1b 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -525,6 +525,17 @@
                 <p v-if="newThreadCwd" class="new-thread-folder-selected" :title="newThreadCwd">
                   {{ t('Selected folder') }}: {{ newThreadCwd }}
                 </p>
+                <div v-if="newThreadAgentOptions.length > 1" class="new-thread-agents-select">
+                  <p class="new-thread-agents-select-label">{{ t('Instructions') }}</p>
+                  <ComposerDropdown
+                    class="new-thread-agents-dropdown"
+                    :model-value="selectedNewThreadAgentFile"
+                    :options="newThreadAgentDropdownOptions"
+                    :placeholder="t('Select instructions')"
+                    :disabled="isLoadingNewThreadAgents"
+                    @update:model-value="onSelectNewThreadAgentFile"
+                  />
+                </div>
                 <div class="new-thread-folder-actions">
                   <button class="new-thread-folder-action new-thread-folder-action-primary" type="button" @click="onOpenExistingFolder">
                     {{ t('Select folder') }}
@@ -874,6 +885,7 @@ import {
   getAccounts,
   createLocalDirectory,
   getFirstLaunchPluginsCardPreference,
+  getAgentInstructionsOptions,
   getHomeDirectory,
   getTelegramConfig,
   getProjectRootSuggestion,
@@ -890,7 +902,7 @@ import {
 } from './api/codexGateway'
 import type { ReasoningEffort, SpeedMode, ThreadScrollState, UiAccountEntry, UiRateLimitWindow, UiServerRequest, UiServerRequestReply, UiThreadTokenUsage } from './types/codex'
 import type { ComposerDraftPayload, ThreadComposerExposed } from './components/content/ThreadComposer.vue'
-import type { LocalDirectoryEntry, TelegramStatus, WorktreeBranchOption } from './api/codexGateway'
+import type { AgentInstructionsOption, LocalDirectoryEntry, TelegramStatus, WorktreeBranchOption } from './api/codexGateway'
 import { getFreeModeStatus, setFreeMode, setFreeModeCustomKey, setCustomProvider } from './api/codexGateway'
 import { getPathLeafName, getPathParent, isProjectlessChatPath, normalizePathForUi } from './pathUtils.js'
 
@@ -1133,6 +1145,9 @@ const newThreadRuntime = ref<'local' | 'worktree'>('local')
 const newWorktreeBaseBranch = ref('')
 const worktreeBranchOptions = ref<WorktreeBranchOption[]>([])
 const isLoadingWorktreeBranches = ref(false)
+const newThreadAgentOptions = ref<AgentInstructionsOption[]>([])
+const selectedNewThreadAgentFile = ref('project:AGENTS.md')
+const isLoadingNewThreadAgents = ref(false)
 const workspaceRootOptionsState = ref<{ order: string[]; labels: Record<string, string> }>({ order: [], labels: {} })
 const worktreeInitStatus = ref<{ phase: 'idle' | 'running' | 'error'; title: string; message: string }>({
   phase: 'idle',
@@ -1421,6 +1436,12 @@ const newWorktreeBranchDropdownOptions = computed<Array<{ value: string; label:
   }
   return options
 })
+const newThreadAgentDropdownOptions = computed<Array<{ value: string; label: string }>>(() =>
+  newThreadAgentOptions.value.map((option) => ({ value: option.value, label: option.label })),
+)
+const selectedNewThreadAgentOption = computed(() =>
+  newThreadAgentOptions.value.find((option) => option.value === selectedNewThreadAgentFile.value) ?? null,
+)
 const selectedWorktreeBranchLabel = computed(() => {
   const selectedBranch = newWorktreeBaseBranch.value.trim()
   if (!selectedBranch) return ''
@@ -2342,6 +2363,10 @@ function onSelectNewThreadFolder(cwd: string): void {
   createFolderError.value = ''
 }
 
+function onSelectNewThreadAgentFile(value: string): void {
+  selectedNewThreadAgentFile.value = value.trim() || 'project:AGENTS.md'
+}
+
 function onSelectNewWorktreeBranch(branch: string): void {
   newWorktreeBaseBranch.value = branch.trim()
 }
@@ -3332,10 +3357,32 @@ watch(
   () => newThreadCwd.value,
   () => {
     worktreeInitStatus.value = { phase: 'idle', title: '', message: '' }
+    void loadNewThreadAgentOptions()
     void refreshDefaultProjectName()
   },
 )
 
+async function loadNewThreadAgentOptions(): Promise<void> {
+  const cwd = newThreadCwd.value.trim()
+  selectedNewThreadAgentFile.value = 'project:AGENTS.md'
+  newThreadAgentOptions.value = []
+  if (!cwd) return
+
+  isLoadingNewThreadAgents.value = true
+  try {
+    const options = await getAgentInstructionsOptions(cwd)
+    newThreadAgentOptions.value = options
+    if (!options.some((option) => option.value === selectedNewThreadAgentFile.value)) {
+      selectedNewThreadAgentFile.value = options[0]?.value ?? 'project:AGENTS.md'
+    }
+  } catch {
+    newThreadAgentOptions.value = []
+    selectedNewThreadAgentFile.value = 'project:AGENTS.md'
+  } finally {
+    isLoadingNewThreadAgents.value = false
+  }
+}
+
 watch(
   () => [newThreadRuntime.value, newThreadCwd.value] as const,
   ([runtime, cwd]) => {
@@ -3445,7 +3492,9 @@ async function submitFirstMessageForNewThread(
       targetCwd = directory.cwd
       newThreadCwd.value = directory.cwd
     }
-    const threadId = await sendMessageToNewThread(text, targetCwd, imageUrls, skills, fileAttachments)
+    const selectedAgent = selectedNewThreadAgentOption.value
+    const baseInstructions = selectedAgent && !selectedAgent.isDefault ? selectedAgent.content : undefined
+    const threadId = await sendMessageToNewThread(text, targetCwd, imageUrls, skills, fileAttachments, baseInstructions)
     if (!threadId) return
     await router.replace({ name: 'thread', params: { threadId } })
     scheduleMobileConversationJumpToLatest()
@@ -3750,6 +3799,22 @@ async function loadWorktreeBranches(sourceCwd: string): Promise<void> {
   @apply mt-2 mb-0 max-w-3xl text-center text-xs text-zinc-500 break-all;
 }
 
+.new-thread-agents-select {
+  @apply mt-3 w-full max-w-3xl;
+}
+
+.new-thread-agents-select-label {
+  @apply m-0 mb-1 text-xs font-medium uppercase tracking-wide text-zinc-500;
+}
+
+.new-thread-agents-dropdown :deep(.composer-dropdown-trigger) {
+  @apply h-9 rounded-xl border border-zinc-200 bg-white px-3 text-sm text-zinc-700;
+}
+
+:global(:root.dark) .new-thread-agents-select-label {
+  @apply text-zinc-500;
+}
+
 .new-thread-folder-actions {
   @apply mt-3 flex w-full max-w-3xl flex-wrap items-center justify-center gap-2;
 }
diff --git a/src/api/codexGateway.test.ts b/src/api/codexGateway.test.ts
index c3ea21f88..709006d91 100644
--- a/src/api/codexGateway.test.ts
+++ b/src/api/codexGateway.test.ts
@@ -1,23 +1,22 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
-import { startThreadTurn } from './codexGateway'
+import { getAgentInstructionsOptions, startThread, startThreadTurn } from './codexGateway'
 
-function mockRpcFetch(): { requests: Array<{ method: string, params: Record<string, unknown> }> } {
-  const requests: Array<{ method: string, params: Record<string, unknown> }> = []
+function mockRpcFetch(): { requests: Array<{ method: string, params: Record<string, unknown>, url: string }> } {
+  const requests: Array<{ method: string, params: Record<string, unknown>, url: string }> = []
 
   vi.stubGlobal('fetch', vi.fn(async (_input: RequestInfo | URL, init?: RequestInit) => {
+    const url = String(_input)
     const body = typeof init?.body === 'string'
-      ? JSON.parse(init.body) as { method: string, params: Record<string, unknown> }
+      ? JSON.parse(init.body) as { method: string, params: Record<string, unknown>, model?: unknown, baseInstructions?: unknown }
       : { method: '', params: {} }
 
-    requests.push(body)
+    requests.push({ ...body, url })
 
-    return new Response(JSON.stringify({
-      result: {
-        turn: {
-          id: `turn-${requests.length}`,
-        },
-      },
-    }), {
+    const result = url.includes('/codex-api/thread/start-with-agent-instructions') || body.method === 'thread/start'
+      ? { thread: { id: `thread-${requests.length}` }, model: body.params?.model ?? body.model ?? '' }
+      : { turn: { id: `turn-${requests.length}` } }
+
+    return new Response(JSON.stringify({ result }), {
       status: 200,
       headers: {
         'Content-Type': 'application/json',
@@ -28,6 +27,95 @@ function mockRpcFetch(): { requests: Array<{ method: string, params: Record<stri
   return { requests }
 }
 
+describe('startThread instruction payloads', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('omits baseInstructions for the default AGENTS.md selection', async () => {
+    const { requests } = mockRpcFetch()
+
+    await startThread('/tmp/TestChat', 'gpt-5.4')
+
+    expect(requests).toHaveLength(1)
+    expect(requests[0].method).toBe('thread/start')
+    expect(requests[0].params).toEqual({
+      cwd: '/tmp/TestChat',
+      model: 'gpt-5.4',
+    })
+  })
+
+  it('sends only the selected custom agent instructions as baseInstructions', async () => {
+    const { requests } = mockRpcFetch()
+
+    await startThread('/tmp/TestChat', 'gpt-5.4', 'CUSTOM_AGENT_ONLY', { deferCwdUntilTurn: true })
+
+    expect(requests).toHaveLength(1)
+    expect(requests[0].url).toBe('/codex-api/thread/start-with-agent-instructions')
+    expect(requests[0]).toMatchObject({
+      cwd: '/tmp/TestChat',
+      model: 'gpt-5.4',
+      baseInstructions: 'CUSTOM_AGENT_ONLY',
+    })
+    expect(JSON.stringify(requests[0])).not.toContain('ORIGINAL_AGENTS_MARKER')
+  })
+})
+
+describe('getAgentInstructionsOptions', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('preserves project and global instruction scopes', async () => {
+    vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify({
+      data: [
+        {
+          value: 'project:AGENTS.md',
+          label: 'Default AGENTS.md',
+          path: '/tmp/TestChat/AGENTS.md',
+          content: 'ORIGINAL_AGENTS_MARKER',
+          isDefault: true,
+          scope: 'project',
+        },
+        {
+          value: 'global:AGENTS.review.md',
+          label: 'Global: AGENTS.review.md',
+          path: '/Users/igor/.codex/AGENTS.review.md',
+          content: 'GLOBAL_REVIEW_MARKER',
+          isDefault: false,
+          scope: 'global',
+        },
+      ],
+    }), {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })))
+
+    const options = await getAgentInstructionsOptions('/tmp/TestChat')
+
+    expect(options).toEqual([
+      {
+        value: 'project:AGENTS.md',
+        label: 'Default AGENTS.md',
+        path: '/tmp/TestChat/AGENTS.md',
+        content: 'ORIGINAL_AGENTS_MARKER',
+        isDefault: true,
+        scope: 'project',
+      },
+      {
+        value: 'global:AGENTS.review.md',
+        label: 'Global: AGENTS.review.md',
+        path: '/Users/igor/.codex/AGENTS.review.md',
+        content: 'GLOBAL_REVIEW_MARKER',
+        isDefault: false,
+        scope: 'global',
+      },
+    ])
+  })
+})
+
 describe('startThreadTurn collaboration mode payloads', () => {
   afterEach(() => {
     vi.unstubAllGlobals()
diff --git a/src/api/codexGateway.ts b/src/api/codexGateway.ts
index 0ffca281e..e020d41c1 100644
--- a/src/api/codexGateway.ts
+++ b/src/api/codexGateway.ts
@@ -284,6 +284,15 @@ export type ComposerFileSuggestion = {
   path: string
 }
 
+export type AgentInstructionsOption = {
+  value: string
+  label: string
+  path: string
+  content: string
+  isDefault: boolean
+  scope: 'project' | 'global'
+}
+
 const DEFAULT_COLLABORATION_MODE_OPTIONS: CollaborationModeOption[] = [
   { value: 'default', label: 'Default' },
   { value: 'plan', label: 'Plan' },
@@ -1332,16 +1341,26 @@ export type ForkedThread = {
   messages: UiMessage[]
 }
 
-export async function startThread(cwd?: string, model?: string): Promise<StartedThread> {
+export async function startThread(
+  cwd?: string,
+  model?: string,
+  baseInstructions?: string,
+  options?: { deferCwdUntilTurn?: boolean },
+): Promise<StartedThread> {
   try {
     const params: Record<string, unknown> = {}
-    if (typeof cwd === 'string' && cwd.trim().length > 0) {
+    if (options?.deferCwdUntilTurn !== true && typeof cwd === 'string' && cwd.trim().length > 0) {
       params.cwd = cwd.trim()
     }
     if (typeof model === 'string' && model.trim().length > 0) {
       params.model = model.trim()
     }
-    const payload = await callRpc<ThreadStartResponse>('thread/start', params)
+    if (typeof baseInstructions === 'string' && baseInstructions.trim().length > 0) {
+      params.baseInstructions = baseInstructions
+    }
+    const payload = options?.deferCwdUntilTurn === true && typeof baseInstructions === 'string' && baseInstructions.trim().length > 0
+      ? await startThreadWithAgentInstructions(cwd, model, baseInstructions)
+      : await callRpc<ThreadStartResponse>('thread/start', params)
     const threadId = normalizeThreadIdFromPayload(payload)
     if (!threadId) {
       throw new Error('thread/start did not return a thread id')
@@ -1355,6 +1374,34 @@ export async function startThread(cwd?: string, model?: string): Promise<Started
   }
 }
 
+async function startThreadWithAgentInstructions(
+  cwd: string | undefined,
+  model: string | undefined,
+  baseInstructions: string,
+): Promise<ThreadStartResponse> {
+  const body: Record<string, unknown> = { baseInstructions }
+  if (typeof cwd === 'string' && cwd.trim().length > 0) {
+    body.cwd = cwd.trim()
+  }
+  if (typeof model === 'string' && model.trim().length > 0) {
+    body.model = model.trim()
+  }
+  const response = await fetch('/codex-api/thread/start-with-agent-instructions', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  const payload = await readJsonResponse(response)
+  if (!response.ok) {
+    throw new Error(getErrorMessageFromPayload(payload, 'Failed to start thread with custom agent instructions'))
+  }
+  const record =
+    payload && typeof payload === 'object' && !Array.isArray(payload)
+      ? (payload as Record<string, unknown>)
+      : {}
+  return (record.result ?? {}) as ThreadStartResponse
+}
+
 export async function forkThread(threadId: string): Promise<ForkedThread>
 export async function forkThread(threadId: string, cwd: string | undefined, model: string | undefined): Promise<StartedThread>
 export async function forkThread(
@@ -1504,6 +1551,7 @@ export async function startThreadTurn(
   skills?: Array<{ name: string; path: string }>,
   fileAttachments: FileAttachmentParam[] = [],
   collaborationMode?: CollaborationModeKind,
+  cwd?: string,
 ): Promise<string> {
   try {
     const normalizedModel = model?.trim() ?? ''
@@ -1549,6 +1597,9 @@ export async function startThreadTurn(
       threadId,
       input,
     }
+    if (typeof cwd === 'string' && cwd.trim().length > 0) {
+      params.cwd = cwd.trim()
+    }
     if (attachments.length > 0) params.attachments = attachments
     if (normalizedModel) {
       params.model = normalizedModel
@@ -2575,6 +2626,40 @@ export async function createProjectlessThreadDirectory(prompt?: string): Promise
   }
 }
 
+export async function getAgentInstructionsOptions(cwd: string): Promise<AgentInstructionsOption[]> {
+  const trimmedCwd = cwd.trim()
+  if (!trimmedCwd) return []
+  const query = new URLSearchParams({ cwd: trimmedCwd })
+  const response = await fetch(`/codex-api/agent-instructions?${query.toString()}`)
+  const payload = await readJsonResponse(response)
+  if (!response.ok) {
+    const message = getErrorMessageFromPayload(payload, 'Failed to load agent instructions')
+    throw new Error(message)
+  }
+  const record =
+    payload && typeof payload === 'object' && !Array.isArray(payload)
+      ? (payload as Record<string, unknown>)
+      : {}
+  const data = Array.isArray(record.data) ? record.data : []
+  return data.flatMap((item) => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) return []
+    const row = item as Record<string, unknown>
+    const value = typeof row.value === 'string' ? row.value.trim() : ''
+    const label = typeof row.label === 'string' ? row.label.trim() : ''
+    const path = typeof row.path === 'string' ? normalizePathForUi(row.path) : ''
+    const content = typeof row.content === 'string' ? row.content : ''
+    if (!value || !label || !path) return []
+    return [{
+      value,
+      label,
+      path,
+      content,
+      isDefault: row.isDefault === true,
+      scope: row.scope === 'global' ? 'global' : 'project',
+    }]
+  })
+}
+
 export async function getProjectRootSuggestion(basePath: string): Promise<{ name: string; path: string }> {
   const query = new URLSearchParams({ basePath })
   const response = await fetch(`/codex-api/project-root-suggestion?${query.toString()}`)
diff --git a/src/composables/useDesktopState.ts b/src/composables/useDesktopState.ts
index f77ce1d32..288af7ae6 100644
--- a/src/composables/useDesktopState.ts
+++ b/src/composables/useDesktopState.ts
@@ -4326,6 +4326,7 @@ export function useDesktopState() {
     imageUrls: string[] = [],
     skills: Array<{ name: string; path: string }> = [],
     fileAttachments: FileAttachment[] = [],
+    baseInstructions?: string,
   ): Promise<string> {
     if (isUpdatingSpeedMode.value) return ''
 
@@ -4344,14 +4345,24 @@ export function useDesktopState() {
 
     try {
       try {
-        const startedThread = await startThread(targetCwd || undefined, selectedModel || undefined)
+        const startedThread = await startThread(
+          targetCwd || undefined,
+          selectedModel || undefined,
+          baseInstructions,
+          { deferCwdUntilTurn: typeof baseInstructions === 'string' && baseInstructions.trim().length > 0 },
+        )
         threadId = startedThread.threadId
         setThreadModelId(threadId, startedThread.model)
         setSelectedCollaborationModeForThread(threadId, selectedMode)
       } catch (unknownError) {
         if (selectedModel && selectedModel !== MODEL_FALLBACK_ID && isUnsupportedChatGptModelError(unknownError)) {
           await applyFallbackModelSelection()
-          const fallbackThread = await startThread(targetCwd || undefined, MODEL_FALLBACK_ID)
+          const fallbackThread = await startThread(
+            targetCwd || undefined,
+            MODEL_FALLBACK_ID,
+            baseInstructions,
+            { deferCwdUntilTurn: typeof baseInstructions === 'string' && baseInstructions.trim().length > 0 },
+          )
           threadId = fallbackThread.threadId
           setThreadModelId(threadId, fallbackThread.model)
           setSelectedCollaborationModeForThread(threadId, selectedMode)
@@ -4386,7 +4397,7 @@ export function useDesktopState() {
       const capturedThreadId = threadId
       const capturedCwd = targetCwd || null
       const capturedPrompt = nextText
-      void startTurnForThread(threadId, nextText, imageUrls, skills, fileAttachments, selectedMode)
+      void startTurnForThread(threadId, nextText, imageUrls, skills, fileAttachments, selectedMode, targetCwd || undefined)
         .catch((unknownError) => {
           shouldAutoScrollOnNextAgentEvent = false
           setThreadInProgress(threadId, false)
@@ -4423,6 +4434,7 @@ export function useDesktopState() {
     skills: Array<{ name: string; path: string }> = [],
     fileAttachments: FileAttachment[] = [],
     collaborationModeOverride?: CollaborationModeKind,
+    cwdOverride?: string,
   ): Promise<void> {
     const reasoningEffort = selectedReasoningEffort.value
     const collaborationMode = collaborationModeOverride === 'plan' ? 'plan' : collaborationModeOverride === 'default'
@@ -4470,6 +4482,7 @@ export function useDesktopState() {
           skills.length > 0 ? skills : undefined,
           fileAttachments,
           collaborationMode,
+          cwdOverride,
         )
       } catch (unknownError) {
         if (modelId && modelId !== MODEL_FALLBACK_ID && isUnsupportedChatGptModelError(unknownError)) {
@@ -4492,6 +4505,7 @@ export function useDesktopState() {
             skills.length > 0 ? skills : undefined,
             fileAttachments,
             collaborationMode,
+            cwdOverride,
           )
         } else {
           throw unknownError
diff --git a/src/server/codexAppServerBridge.ts b/src/server/codexAppServerBridge.ts
index 14ff44ca6..58b938d1b 100644
--- a/src/server/codexAppServerBridge.ts
+++ b/src/server/codexAppServerBridge.ts
@@ -60,6 +60,8 @@ type RpcProxyRequest = {
   params?: unknown
 }
 
+const customAgentThreadCwdById = new Map<string, string>()
+
 type ServerRequestReply = {
   result?: unknown
   error?: {
@@ -317,6 +319,34 @@ function asRecord(value: unknown): Record<string, unknown> | null {
     : null
 }
 
+function rewriteCustomAgentThreadCwd<T>(value: T): T {
+  const record = asRecord(value)
+  if (!record) return value
+
+  const rewriteThread = (threadValue: unknown): void => {
+    const thread = asRecord(threadValue)
+    const threadId = typeof thread?.id === 'string' ? thread.id : ''
+    const mappedCwd = threadId ? customAgentThreadCwdById.get(threadId) : undefined
+    if (thread && mappedCwd) {
+      thread.cwd = mappedCwd
+    }
+  }
+
+  rewriteThread(record.thread)
+  if (Array.isArray(record.threads)) {
+    for (const thread of record.threads) rewriteThread(thread)
+  }
+
+  const thread = asRecord(record.thread)
+  const threadId = typeof thread?.id === 'string' ? thread.id : ''
+  const mappedCwd = threadId ? customAgentThreadCwdById.get(threadId) : undefined
+  if (mappedCwd) {
+    record.cwd = mappedCwd
+  }
+
+  return value
+}
+
 function isInlineDataUrl(value: string): boolean {
   return /^data:/iu.test(value.trim())
 }
@@ -2280,11 +2310,104 @@ async function listFilesWithRipgrep(cwd: string): Promise<string[]> {
   })
 }
 
+async function listAgentInstructionFiles(cwd: string): Promise<Array<{
+  value: string
+  label: string
+  path: string
+  content: string
+  isDefault: boolean
+  scope: 'project' | 'global'
+}>> {
+  const normalizedCwd = isAbsolute(cwd) ? cwd : resolve(cwd)
+  const info = await stat(normalizedCwd)
+  if (!info.isDirectory()) {
+    throw new Error('cwd is not a directory')
+  }
+
+  const projectEntries = await readdir(normalizedCwd, { withFileTypes: true })
+  const projectCustomFiles = projectEntries
+    .filter((entry) => entry.isFile() && /^AGENTS(?:\.[^.]+)+\.md$/u.test(entry.name))
+    .map((entry) => entry.name)
+    .sort((a, b) => a.localeCompare(b))
+  const rows: Array<{
+    value: string
+    label: string
+    path: string
+    content: string
+    isDefault: boolean
+    scope: 'project' | 'global'
+  }> = []
+
+  for (const fileName of ['AGENTS.md', ...projectCustomFiles]) {
+    const filePath = join(normalizedCwd, fileName)
+    try {
+      const content = await readFile(filePath, 'utf8')
+      rows.push({
+        value: `project:${fileName}`,
+        label: fileName === 'AGENTS.md' ? 'Default AGENTS.md' : `Project: ${fileName}`,
+        path: filePath,
+        content,
+        isDefault: fileName === 'AGENTS.md',
+        scope: 'project',
+      })
+    } catch {
+      if (fileName === 'AGENTS.md') {
+        rows.push({
+          value: 'project:AGENTS.md',
+          label: 'Default AGENTS.md',
+          path: filePath,
+          content: '',
+          isDefault: true,
+          scope: 'project',
+        })
+      }
+    }
+  }
+
+  const codexHome = getCodexHomeDir()
+  try {
+    const globalEntries = await readdir(codexHome, { withFileTypes: true })
+    const globalCustomFiles = globalEntries
+      .filter((entry) => entry.isFile() && /^AGENTS(?:\.[^.]+)+\.md$/u.test(entry.name))
+      .map((entry) => entry.name)
+      .sort((a, b) => a.localeCompare(b))
+    for (const fileName of globalCustomFiles) {
+      const filePath = join(codexHome, fileName)
+      try {
+        const content = await readFile(filePath, 'utf8')
+        rows.push({
+          value: `global:${fileName}`,
+          label: `Global: ${fileName}`,
+          path: filePath,
+          content,
+          isDefault: false,
+          scope: 'global',
+        })
+      } catch {
+        // Ignore unreadable global personality files so one bad file does not hide project options.
+      }
+    }
+  } catch {
+    // A missing CODEX_HOME should not prevent project-level AGENTS selection.
+  }
+
+  return rows
+}
+
 function getCodexHomeDir(): string {
   const codexHome = process.env.CODEX_HOME?.trim()
   return codexHome && codexHome.length > 0 ? codexHome : join(homedir(), '.codex')
 }
 
+async function getNeutralInstructionsCwd(): Promise<string> {
+  const neutralCwd = join(tmpdir(), 'codex-web-agent-instructions-neutral')
+  await mkdir(neutralCwd, { recursive: true })
+  if (existsSync(join(neutralCwd, 'AGENTS.md'))) {
+    throw new Error(`Neutral instructions cwd unexpectedly contains AGENTS.md: ${neutralCwd}`)
+  }
+  return neutralCwd
+}
+
 function getSkillsInstallDir(): string {
   return join(getCodexHomeDir(), 'skills')
 }
@@ -5052,7 +5175,8 @@ export function createCodexBridgeMiddleware(): CodexBridgeMiddleware {
 
         const rpcResult = await appServer.rpc(body.method, body.params ?? null)
         const trimmedResult = trimThreadTurnsInRpcResult(body.method, rpcResult)
-        const result = await sanitizeThreadTurnsInlinePayloads(body.method, trimmedResult)
+        const sanitizedResult = await sanitizeThreadTurnsInlinePayloads(body.method, trimmedResult)
+        const result = rewriteCustomAgentThreadCwd(sanitizedResult)
 
         if (THREAD_METHODS_WITH_TURNS.has(body.method)) {
           const rpcRecord = asRecord(result)
@@ -5067,6 +5191,36 @@ export function createCodexBridgeMiddleware(): CodexBridgeMiddleware {
         return
       }
 
+      if (req.method === 'POST' && url.pathname === '/codex-api/thread/start-with-agent-instructions') {
+        const payload = asRecord(await readJsonBody(req))
+        const targetCwd = typeof payload?.cwd === 'string' ? payload.cwd.trim() : ''
+        const model = typeof payload?.model === 'string' ? payload.model.trim() : ''
+        const baseInstructions = typeof payload?.baseInstructions === 'string' ? payload.baseInstructions : ''
+        if (!baseInstructions.trim()) {
+          setJson(res, 400, { error: 'Missing baseInstructions' })
+          return
+        }
+        try {
+          const neutralCwd = await getNeutralInstructionsCwd()
+          const params: Record<string, unknown> = {
+            cwd: neutralCwd,
+            baseInstructions,
+          }
+          if (model) params.model = model
+          const rpcResult = await appServer.rpc('thread/start', params)
+          const rpcRecord = asRecord(rpcResult)
+          const thread = asRecord(rpcRecord?.thread)
+          const threadId = typeof thread?.id === 'string' ? thread.id : ''
+          if (threadId && targetCwd) {
+            customAgentThreadCwdById.set(threadId, targetCwd)
+          }
+          setJson(res, 200, { result: rewriteCustomAgentThreadCwd(rpcResult) })
+        } catch (error) {
+          setJson(res, 500, { error: getErrorMessage(error, 'Failed to start thread with custom agent instructions') })
+        }
+        return
+      }
+
       if (req.method === 'GET' && url.pathname === '/codex-api/thread-file-change-fallback') {
         const threadId = url.searchParams.get('threadId')?.trim() ?? ''
         if (!threadId) {
@@ -5910,6 +6064,21 @@ export function createCodexBridgeMiddleware(): CodexBridgeMiddleware {
         return
       }
 
+      if (req.method === 'GET' && url.pathname === '/codex-api/agent-instructions') {
+        const rawCwd = url.searchParams.get('cwd')?.trim() ?? ''
+        if (!rawCwd) {
+          setJson(res, 400, { error: 'Missing cwd' })
+          return
+        }
+        try {
+          const rows = await listAgentInstructionFiles(rawCwd)
+          setJson(res, 200, { data: rows })
+        } catch (error) {
+          setJson(res, 400, { error: getErrorMessage(error, 'Failed to load agent instructions') })
+        }
+        return
+      }
+
       if (req.method === 'GET' && url.pathname === '/codex-api/prompts') {
         setJson(res, 200, { data: await listComposerPrompts() })
         return
diff --git a/tests.md b/tests.md
index 8d8f8528f..cfaef40ca 100644
--- a/tests.md
+++ b/tests.md
@@ -3883,3 +3883,43 @@ Codex app-server `account/chatgptAuthTokens/refresh` requests are handled automa
 
 #### Rollback/Cleanup
 - None, unless a test-only `$CODEX_HOME` was used
+
+---
+
+### New-thread custom and global AGENTS selector
+
+#### Feature/Change Name
+The new-thread screen detects project `AGENTS.*.md` files and global `~/.codex/AGENTS.*.md` personality files, then lets the user choose custom instructions without loading the default `AGENTS.md`.
+
+#### Prerequisites/Setup
+1. Dev server running (`pnpm run dev`)
+2. Test folder `/Users/igor/temp/TestChat` exists
+3. Test files exist:
+   - `/Users/igor/temp/TestChat/AGENTS.md` with marker `ORIGINAL_AGENTS_MARKER`
+   - `/Users/igor/temp/TestChat/AGENTS.alpha.md` with marker `CUSTOM_ALPHA_MARKER`
+   - `/Users/igor/temp/TestChat/AGENTS.beta.md` with marker `CUSTOM_BETA_MARKER`
+4. Optional global personality file exists: `/Users/igor/.codex/AGENTS.global-test.md` with marker `GLOBAL_AGENT_MARKER`
+5. Light theme and dark theme both available from the appearance switcher
+
+#### Steps
+1. Open the new-thread screen in light theme
+2. Select `/Users/igor/temp/TestChat` as the folder
+3. Confirm an `Instructions` dropdown appears with `Default AGENTS.md`, `Project: AGENTS.alpha.md`, `Project: AGENTS.beta.md`, and any available `Global: AGENTS.*.md` files
+4. Select `Project: AGENTS.alpha.md`
+5. Send: `What is the active marker? Answer with only the marker.`
+6. Confirm the assistant answers `CUSTOM_ALPHA_MARKER`
+7. Confirm the custom start response has `instructionSources: []` and does not include `/Users/igor/temp/TestChat/AGENTS.md`
+8. If `/Users/igor/.codex/AGENTS.global-test.md` exists, select `Global: AGENTS.global-test.md`, send the same prompt, and confirm the assistant answers `GLOBAL_AGENT_MARKER`
+9. Switch to dark theme and repeat the dropdown visibility/readability check
+
+#### Expected Results
+- No instructions dropdown is shown unless the selected folder or `~/.codex` has at least one `AGENTS.*.md` file
+- Leaving `Default AGENTS.md` selected uses the normal `thread/start` path without `baseInstructions`
+- Selecting `Project: AGENTS.alpha.md` sends that file content as `baseInstructions`
+- Selecting a global `~/.codex/AGENTS.*.md` file sends that global file content as `baseInstructions`
+- The backend starts custom-instruction threads in a neutral cwd first, so the original `AGENTS.md` is not read
+- The UI still shows the real selected folder as the thread cwd after custom thread creation
+- Dropdown trigger, menu, and labels are readable in both light theme and dark theme
+
+#### Rollback/Cleanup
+- Remove the temporary `/Users/igor/temp/TestChat/AGENTS*.md` files if they are no longer needed