diff --git a/client/src/backend_bridge/api_helpers.ts b/client/src/backend_bridge/api_helpers.ts
index 7b2f39e..3c83d49 100644
--- a/client/src/backend_bridge/api_helpers.ts
+++ b/client/src/backend_bridge/api_helpers.ts
@@ -17,46 +17,96 @@ export type LlmChatOptions = {
   signal?: AbortSignal | undefined;
 };
 
+const normalizedOpenAIChatCompletionMessageSchema = z.object({
+  content: z.string(),
+  reasoning_content: z.string().optional(),
+});
+
+type NormalizedLLMChatMessage = z.infer<typeof normalizedOpenAIChatCompletionMessageSchema>;
+
 const openAIChatCompletionSchema = z.object({
   choices: z.array(
     z.object({
-      message: z.object({
-        content: z.string(),
+      message: normalizedOpenAIChatCompletionMessageSchema.extend({
+        reasoning: z.string().nullable().optional(),
+        reasoning_content: z.string().nullable().optional(),
       }),
     })
   ),
 });
 
-function extractStreamChunkText(chunkPayload: unknown): { mode: 'delta' | 'full' | 'none'; text: string } {
+type RawLLMChatMessage = z.infer<typeof openAIChatCompletionSchema>['choices'][number]['message'];
+
+type ExtractedStreamChunk =
+  | { mode: 'delta'; message: Partial<NormalizedLLMChatMessage> }
+  | { mode: 'full'; message: NormalizedLLMChatMessage }
+  | { mode: 'none' };
+
+function normalizeChatMessage(raw: RawLLMChatMessage): NormalizedLLMChatMessage {
+  const reasoningContent = raw.reasoning_content || raw.reasoning || undefined;
+
+  return {
+    ...raw,
+    reasoning_content: reasoningContent,
+  };
+}
+
+function extractStreamMessageFields(value: unknown): Partial<NormalizedLLMChatMessage> | undefined {
+  if (!value || typeof value !== 'object') {
+    return undefined;
+  }
+
+  const content = (value as { content?: unknown }).content;
+  const reasoningContent =
+    (value as { reasoning_content?: unknown }).reasoning_content ||
+    (value as { reasoning?: unknown }).reasoning;
+
+  if (typeof content !== 'string' && typeof reasoningContent !== 'string') {
+    return undefined;
+  }
+
+  return {
+    ...(typeof content === 'string' ? { content } : {}),
+    ...(typeof reasoningContent === 'string' ? { reasoning_content: reasoningContent } : {}),
+  };
+}
+
+function extractStreamChunkMessage(chunkPayload: unknown): ExtractedStreamChunk {
   if (!chunkPayload || typeof chunkPayload !== 'object') {
-    return { mode: 'none', text: '' };
+    return { mode: 'none' };
   }
 
   const choices = (chunkPayload as { choices?: unknown }).choices;
   if (!Array.isArray(choices) || choices.length === 0) {
-    return { mode: 'none', text: '' };
+    return { mode: 'none' };
   }
 
   const firstChoice = choices[0];
   if (!firstChoice || typeof firstChoice !== 'object') {
-    return { mode: 'none', text: '' };
+    return { mode: 'none' };
   }
 
   const delta = (firstChoice as { delta?: unknown }).delta;
-  if (delta && typeof delta === 'object' && typeof (delta as { content?: unknown }).content === 'string') {
-    return { mode: 'delta', text: (delta as { content: string }).content };
+  const deltaMessage = extractStreamMessageFields(delta);
+  if (deltaMessage) {
+    return { mode: 'delta', message: deltaMessage };
   }
 
   const message = (firstChoice as { message?: unknown }).message;
-  if (
-    message &&
-    typeof message === 'object' &&
-    typeof (message as { content?: unknown }).content === 'string'
-  ) {
-    return { mode: 'full', text: (message as { content: string }).content };
+  const fullMessage = extractStreamMessageFields(message);
+  if (fullMessage?.content !== undefined) {
+    return {
+      mode: 'full',
+      message: {
+        content: fullMessage.content,
+        ...(fullMessage.reasoning_content !== undefined
+          ? { reasoning_content: fullMessage.reasoning_content }
+          : {}),
+      },
+    };
   }
 
-  return { mode: 'none', text: '' };
+  return { mode: 'none' };
 }
 
 function buildLlmHttpError(response: Response, responseText: string) {
@@ -68,7 +118,10 @@ function buildLlmHttpError(response: Response, responseText: string) {
   return new Error(message);
 }
 
-async function parseLlmStreamingResponse(response: Response, onTokens: LlmTokenCallback): Promise<string> {
+async function parseLlmStreamingResponse(
+  response: Response,
+  onTokens: LlmTokenCallback
+): Promise<NormalizedLLMChatMessage> {
   const contentType = (response.headers.get('content-type') || '').toLowerCase();
   if (!contentType.includes('text/event-stream')) {
     const body = await response.text();
@@ -83,7 +136,7 @@ async function parseLlmStreamingResponse(response: Response, onTokens: LlmTokenC
     throw new Error('Streaming response body was empty.');
   }
 
-  let combinedText = '';
+  let combinedMessage: NormalizedLLMChatMessage = { content: '' };
   let pendingBuffer = '';
   let sawDoneMarker = false;
   const decoder = new TextDecoder();
@@ -106,16 +159,24 @@ async function parseLlmStreamingResponse(response: Response, onTokens: LlmTokenC
 
     let parsedPayload = JSON.parse(payload);
 
-    const extracted = extractStreamChunkText(parsedPayload);
-    if (extracted.mode === 'delta' && extracted.text) {
-      combinedText += extracted.text;
-      onTokens(combinedText);
+    const extracted = extractStreamChunkMessage(parsedPayload);
+    if (extracted.mode === 'delta') {
+      if (extracted.message.reasoning_content !== undefined) {
+        combinedMessage.reasoning_content =
+          (combinedMessage.reasoning_content ?? '') + extracted.message.reasoning_content;
+      }
+
+      if (extracted.message.content) {
+        combinedMessage.content += extracted.message.content;
+        onTokens(combinedMessage.content);
+      }
+
       return;
     }
 
     if (extracted.mode === 'full') {
-      combinedText = extracted.text;
-      onTokens(combinedText);
+      combinedMessage = extracted.message;
+      onTokens(combinedMessage.content);
     }
   };
 
@@ -154,10 +215,13 @@ async function parseLlmStreamingResponse(response: Response, onTokens: LlmTokenC
   pendingBuffer += decoder.decode();
   processBufferedLines(true);
 
-  return combinedText;
+  return combinedMessage;
 }
 
-export async function executeLlmChat(payload: Record<string, unknown>, options: LlmChatOptions = {}) {
+export async function executeLlmChat(
+  payload: Record<string, unknown>,
+  options: LlmChatOptions = {}
+): Promise<NormalizedLLMChatMessage | undefined> {
   const { targetUrl, authToken, onTokens, signal } = options;
   const streamingRequested = typeof onTokens === 'function';
 
@@ -193,7 +257,12 @@ export async function executeLlmChat(payload: Record<string, unknown>, options:
   }
 
   const completion = await parseJSONResponse(openAIChatCompletionSchema, response);
-  return completion?.choices?.[0]?.message?.content || '';
+  const message = completion?.choices?.[0]?.message;
+  if (message) {
+    return normalizeChatMessage(message);
+  }
+
+  return message;
 }
 
 export async function parseJSONResponse<TZodType>(
diff --git a/client/src/components/ChatPane.tsx b/client/src/components/ChatPane.tsx
index 3ca8ef9..23365b1 100644
--- a/client/src/components/ChatPane.tsx
+++ b/client/src/components/ChatPane.tsx
@@ -50,7 +50,8 @@ export default function ChatPane() {
   const [editingMessageId, setEditingMessageId] = useState<string | undefined>(undefined);
   const [editingMessageDraft, setEditingMessageDraft] = useState('');
 
-  const transcriptContainerRef = useRef<HTMLDivElement | null>(null);
+  const transcriptContainerOuterRef = useRef<HTMLDivElement | null>(null);
+  const transcriptContainerInnerRef = useRef<HTMLDivElement | null>(null);
   const autoScrollUnlockedRef = useRef(true);
   const inputRef = useRef<HTMLTextAreaElement | null>(null);
 
@@ -232,21 +233,8 @@ export default function ChatPane() {
     return remaining <= 24;
   };
 
-  const scrollTranscriptToBottom = () => {
-    setTimeout(() => {
-      const container = transcriptContainerRef.current;
-      if (!container || !autoScrollUnlockedRef.current) {
-        return;
-      }
-
-      requestAnimationFrame(() => {
-        container.scrollTop = container.scrollHeight;
-      });
-    }, 25);
-  };
-
   const handleTranscriptScroll = () => {
-    const container = transcriptContainerRef.current;
+    const container = transcriptContainerOuterRef.current;
     if (!container) {
       return;
     }
@@ -302,8 +290,20 @@ export default function ChatPane() {
   }, [transcript?.countAllMessages() === 0]);
 
   useEffect(() => {
-    scrollTranscriptToBottom();
-  }, [transcript]);
+    if (!transcriptContainerInnerRef.current) {
+      return;
+    }
+
+    const observer = new ResizeObserver(() => {
+      if (autoScrollUnlockedRef.current && transcriptContainerOuterRef.current) {
+        transcriptContainerOuterRef.current.scrollTop = transcriptContainerOuterRef.current.scrollHeight;
+      }
+    });
+
+    observer.observe(transcriptContainerInnerRef.current);
+
+    return () => observer.disconnect();
+  }, [transcriptContainerInnerRef.current]);
 
   if (!scenario || !userLocation) {
     return undefined;
@@ -396,135 +396,132 @@ export default function ChatPane() {
         </div>
 
         <div
-          ref={transcriptContainerRef}
+          ref={transcriptContainerOuterRef}
           onScroll={handleTranscriptScroll}
           className="border rounded-sm p-2 overflow-y-auto space-y-2 flex-1 min-h-0"
         >
-          {transcript.countAllMessages() === 0 && (
-            <div className="text-sm text-muted">
-              {participants[0]!.id === userCharacter.id
-                ? 'Say something to start the conversation, or choose an NPC to speak.'
-                : isPaused
-                  ? 'Click Speak on a character card to choose who talks next, or Start Chat to let them talk on their own.'
-                  : 'Conversation in progress...'}
-            </div>
-          )}
-          {transcript.getVisibleMessages(userCharacter.id).map((entry) => (
-            <div
-              key={entry.getId()}
-              className={`relative group ${entry.isSentByCharacter(userCharacter.id) ? 'text-right' : ''}`}
-            >
-              {entry.isImageMessage() ? (
-                <img
-                  src={entry.imageUrl()}
-                  alt="Generated"
-                  className="rounded-sm border inline-block"
-                  onLoad={scrollTranscriptToBottom}
-                />
-              ) : editingMessageId === entry.getId() && entry.isCharacterChatMessage() ? (
-                <div className="space-y-2">
-                  <div>
-                    <strong>{entry.getSpeakerName()}:</strong>
-                  </div>
-                  <textarea
-                    value={editingMessageDraft}
-                    onChange={(event) => setEditingMessageDraft(event.target.value)}
-                    rows={3}
-                    className="w-full border rounded-sm p-2 bg-inset text-sm"
-                    disabled={!isAwaitingCharacterInput}
-                  />
-                  <div className="flex justify-end gap-2 text-xs">
-                    <button
-                      type="button"
-                      onClick={() => setEditingMessageId(undefined)}
+          <div ref={transcriptContainerInnerRef} onScroll={handleTranscriptScroll} className="space-y-2">
+            {transcript.countAllMessages() === 0 && (
+              <div className="text-sm text-muted">
+                {participants[0]!.id === userCharacter.id
+                  ? 'Say something to start the conversation, or choose an NPC to speak.'
+                  : isPaused
+                    ? 'Click Speak on a character card to choose who talks next, or Start Chat to let them talk on their own.'
+                    : 'Conversation in progress...'}
+              </div>
+            )}
+            {transcript.getVisibleMessages(userCharacter.id).map((entry) => (
+              <div
+                key={entry.getId()}
+                className={`relative group ${entry.isSentByCharacter(userCharacter.id) ? 'text-right' : ''}`}
+              >
+                {entry.isImageMessage() ? (
+                  <img src={entry.imageUrl()} alt="Generated" className="rounded-sm border inline-block" />
+                ) : editingMessageId === entry.getId() && entry.isCharacterChatMessage() ? (
+                  <div className="space-y-2">
+                    <div>
+                      <strong>{entry.getSpeakerName()}:</strong>
+                    </div>
+                    <textarea
+                      value={editingMessageDraft}
+                      onChange={(event) => setEditingMessageDraft(event.target.value)}
+                      rows={3}
+                      className="w-full border rounded-sm p-2 bg-inset text-sm"
                       disabled={!isAwaitingCharacterInput}
-                    >
-                      Cancel
-                    </button>
-                    <button
-                      type="button"
-                      onClick={saveEditingMessageEdit}
-                      disabled={!isAwaitingCharacterInput || !editingMessageDraft.trim()}
-                    >
-                      Save
-                    </button>
+                    />
+                    <div className="flex justify-end gap-2 text-xs">
+                      <button
+                        type="button"
+                        onClick={() => setEditingMessageId(undefined)}
+                        disabled={!isAwaitingCharacterInput}
+                      >
+                        Cancel
+                      </button>
+                      <button
+                        type="button"
+                        onClick={saveEditingMessageEdit}
+                        disabled={!isAwaitingCharacterInput || !editingMessageDraft.trim()}
+                      >
+                        Save
+                      </button>
+                    </div>
                   </div>
-                </div>
-              ) : (
-                <>
-                  <strong>{entry.getSpeakerName()}</strong> <Markdown>{entry.getContent()}</Markdown>
-                </>
-              )}
-
-              {isAwaitingCharacterInput && !editingMessageId && (
-                <div className="absolute bottom-1 right-1 opacity-0 group-hover:opacity-100 transition-opacity flex items-center gap-1 text-xs h-6 leading-none">
-                  <button
-                    type="button"
-                    onClick={() => {
-                      const id = entry.getId();
-                      deleteMessage(id);
-                    }}
-                    disabled={!isAwaitingCharacterInput}
-                    title="Delete message"
-                    aria-label="Delete message"
-                    className="px-1 h-5 w-5 flex items-center justify-center"
-                  >
-                    🗑
-                  </button>
-
-                  {entry.isCharacterChatMessage() && (
+                ) : (
+                  <>
+                    <strong>{entry.getSpeakerName()}</strong> <Markdown>{entry.getContent()}</Markdown>
+                  </>
+                )}
+
+                {isAwaitingCharacterInput && !editingMessageId && (
+                  <div className="absolute bottom-1 right-1 opacity-0 group-hover:opacity-100 transition-opacity flex items-center gap-1 text-xs h-6 leading-none">
                     <button
                       type="button"
                       onClick={() => {
                         const id = entry.getId();
-                        submitChatRequestImage(id);
+                        deleteMessage(id);
                       }}
                       disabled={!isAwaitingCharacterInput}
-                      title="Retry message"
-                      aria-label="Retry message"
+                      title="Delete message"
+                      aria-label="Delete message"
                       className="px-1 h-5 w-5 flex items-center justify-center"
                     >
-                      🖼️
+                      🗑
                     </button>
-                  )}
 
-                  {entry.isCharacterChatMessage() &&
-                    entry.asCharacterChatMessage().senderId !== userCharacter.id && (
+                    {entry.isCharacterChatMessage() && (
                       <button
                         type="button"
                         onClick={() => {
                           const id = entry.getId();
-                          redoMessage(id);
+                          submitChatRequestImage(id);
                         }}
                         disabled={!isAwaitingCharacterInput}
                         title="Retry message"
                         aria-label="Retry message"
                         className="px-1 h-5 w-5 flex items-center justify-center"
                       >
-                        ↻
+                        🖼️
                       </button>
                     )}
 
-                  {!entry.isImageMessage() && (
-                    <button
-                      type="button"
-                      onClick={() => {
-                        const id = entry.getId();
-                        setEditingMessageId(id);
-                        setEditingMessageDraft(entry.getContent());
-                      }}
-                      disabled={!isAwaitingCharacterInput}
-                      title="Edit message"
-                      aria-label="Edit message"
-                      className="px-1 h-5 w-5 flex items-center justify-center"
-                    >
-                      ✎
-                    </button>
-                  )}
-                </div>
-              )}
-            </div>
-          ))}
+                    {entry.isCharacterChatMessage() &&
+                      entry.asCharacterChatMessage().senderId !== userCharacter.id && (
+                        <button
+                          type="button"
+                          onClick={() => {
+                            const id = entry.getId();
+                            redoMessage(id);
+                          }}
+                          disabled={!isAwaitingCharacterInput}
+                          title="Retry message"
+                          aria-label="Retry message"
+                          className="px-1 h-5 w-5 flex items-center justify-center"
+                        >
+                          ↻
+                        </button>
+                      )}
+
+                    {!entry.isImageMessage() && (
+                      <button
+                        type="button"
+                        onClick={() => {
+                          const id = entry.getId();
+                          setEditingMessageId(id);
+                          setEditingMessageDraft(entry.getContent());
+                        }}
+                        disabled={!isAwaitingCharacterInput}
+                        title="Edit message"
+                        aria-label="Edit message"
+                        className="px-1 h-5 w-5 flex items-center justify-center"
+                      >
+                        ✎
+                      </button>
+                    )}
+                  </div>
+                )}
+              </div>
+            ))}
+          </div>
         </div>
       </div>
 
diff --git a/client/src/components/character_overview/ScheduleEditor.tsx b/client/src/components/character_overview/ScheduleEditor.tsx
index 7588528..ba77d24 100644
--- a/client/src/components/character_overview/ScheduleEditor.tsx
+++ b/client/src/components/character_overview/ScheduleEditor.tsx
@@ -147,6 +147,19 @@ export default function ScheduleEditor({ groupId }: { groupId: string }) {
     setSelectedSegmentId(undefined);
   };
 
+  const duplicateSegment = (segment: ScheduleSegment) => {
+    const id = newId();
+
+    mutate((prev) => ({
+      ...prev,
+      segments: prev.segments.concat({
+        ...segment,
+        id,
+      }),
+    }));
+    setSelectedSegmentId(id);
+  };
+
   return (
     <div className="space-y-4">
       <div className="flex flex-wrap items-end gap-3">
@@ -437,18 +450,23 @@ export default function ScheduleEditor({ groupId }: { groupId: string }) {
             />
           </div>
 
-          <button
-            type="button"
-            onClick={() => {
-              if (mapModalOpen) {
-                // TODO: Quick fix for inability to control query param ordering via useQuery
-                closeCharacterOverview();
-              }
-              showMapZones();
-            }}
-          >
-            🗺 Add Map Zones
-          </button>
+          <div className="flex gap-2">
+            <button type="button" onClick={() => duplicateSegment(selectedSegment)}>
+              Duplicate
+            </button>
+            <button
+              type="button"
+              onClick={() => {
+                if (mapModalOpen) {
+                  // TODO: Quick fix for inability to control query param ordering via useQuery
+                  closeCharacterOverview();
+                }
+                showMapZones();
+              }}
+            >
+              🗺 Add Map Zones
+            </button>
+          </div>
         </div>
       ) : (
         <div className="text-sm text-muted">Select a segment to edit it, or add a new one.</div>
diff --git a/client/src/components/settings/ui/TemplateRenderLogSettingsSection.tsx b/client/src/components/settings/ui/TemplateRenderLogSettingsSection.tsx
index 4d4a84a..998a73f 100644
--- a/client/src/components/settings/ui/TemplateRenderLogSettingsSection.tsx
+++ b/client/src/components/settings/ui/TemplateRenderLogSettingsSection.tsx
@@ -55,6 +55,15 @@ export default function TemplateRenderLogSettingsSection() {
                   )}
                 </div>
 
+                {entry.completions?.reasoning?.trim() && (
+                  <div className="space-y-1">
+                    <p className="text-sm font-medium">Reasoning</p>
+                    <pre className="max-h-72 overflow-auto rounded-sm border p-2 text-xs font-mono whitespace-pre-wrap wrap-break-word">
+                      {entry.completions.reasoning}
+                    </pre>
+                  </div>
+                )}
+
                 {entry.completions && (
                   <div className="space-y-1">
                     <p className="text-sm font-medium">Raw Response (Pre-parser)</p>
@@ -64,13 +73,13 @@ export default function TemplateRenderLogSettingsSection() {
                   </div>
                 )}
 
-                {entry.parser && (
+                {(entry.parser?.parsedResponse || false) && (
                   <div className="space-y-1">
                     <p className="text-sm font-medium">Parsed Response</p>
                     <pre className="max-h-72 overflow-auto rounded-sm border p-2 text-xs font-mono whitespace-pre-wrap wrap-break-word">
-                      {typeof entry.parser?.parsedResponse === 'string'
+                      {typeof entry.parser.parsedResponse === 'string'
                         ? entry.parser.parsedResponse
-                        : JSON.stringify(entry.parser?.parsedResponse, null, 2)}
+                        : JSON.stringify(entry.parser.parsedResponse, null, 2)}
                     </pre>
                   </div>
                 )}
diff --git a/client/src/engine/chat/post_chat_memories.ts b/client/src/engine/chat/post_chat_memories.ts
index 8bbd187..e5f1811 100644
--- a/client/src/engine/chat/post_chat_memories.ts
+++ b/client/src/engine/chat/post_chat_memories.ts
@@ -237,7 +237,7 @@ export async function generateCharacterEndOfChatUpdates(
       conversationSummaryEntry
     );
 
-    const pairwiseContext = await buildTargetedChatTemplateContext(
+    let pairwiseContext = await buildTargetedChatTemplateContext(
       fromCharacterPerspective.id,
       otherCharacter.id,
       accumulator.resolvers
@@ -246,11 +246,35 @@ export async function generateCharacterEndOfChatUpdates(
     const newConversationGoal =
       await gatedRenderFunctions.nextConversationGoalUpdatesChainGroup(pairwiseContext);
 
+    accumulator.stageRelationshipFields(fromCharacterPerspective.id, otherCharacter.id, {
+      nextConversationGoal: newConversationGoal,
+    });
+
+    pairwiseContext = await buildTargetedChatTemplateContext(
+      fromCharacterPerspective.id,
+      otherCharacter.id,
+      accumulator.resolvers
+    );
+
     const newMemory = await gatedRenderFunctions.rollingPairwiseMemoryRewriteChainGroup(pairwiseContext);
 
+    accumulator.stageRelationshipFields(fromCharacterPerspective.id, otherCharacter.id, {
+      memory: newMemory,
+    });
+
+    pairwiseContext = await buildTargetedChatTemplateContext(
+      fromCharacterPerspective.id,
+      otherCharacter.id,
+      accumulator.resolvers
+    );
+
     const newRelationshipDescriptor =
       await gatedRenderFunctions.relationshipDescriptorUpdateChainGroup(pairwiseContext);
 
+    accumulator.stageRelationshipFields(fromCharacterPerspective.id, otherCharacter.id, {
+      descriptor: newRelationshipDescriptor,
+    });
+
     const familiarity = calculateInteractionUpdatedFamiliarity(
       initialPairwiseRelationship,
       fromCharacterPerspective.id === userCharacterId || otherCharacter.id === userCharacterId,
@@ -258,9 +282,6 @@ export async function generateCharacterEndOfChatUpdates(
     );
 
     accumulator.stageRelationshipFields(fromCharacterPerspective.id, otherCharacter.id, {
-      nextConversationGoal: newConversationGoal,
-      memory: newMemory,
-      descriptor: newRelationshipDescriptor,
       familiarity: familiarity.new,
     });
 
diff --git a/client/src/engine/chat/transcript.test.ts b/client/src/engine/chat/transcript.test.ts
index 62f1f3f..8868da6 100644
--- a/client/src/engine/chat/transcript.test.ts
+++ b/client/src/engine/chat/transcript.test.ts
@@ -49,6 +49,15 @@ describe('ConversationTranscript offscreen-mention RAG', () => {
     ({ transcript, live } = freshTranscript([ALICE.id, BOB.id, CAROL.id]));
   });
 
+  it("does not return self as RAG'd character", async () => {
+    transcript = await say(transcript, CAROL, 'Hello Eve');
+    transcript = transcript.addParticipant(EVE).updatedTranscript;
+    const raggedFromEvePerspective = transcript.getMentionedOffscreenCharacterIds(EVE.id);
+    expect(raggedFromEvePerspective).toHaveLength(0);
+    const raggedFromCarolPerspective = transcript.getMentionedOffscreenCharacterIds(CAROL.id);
+    expect(raggedFromCarolPerspective).toHaveLength(1);
+  });
+
   it('handles first message being a join message', async () => {
     transcript = await say(transcript, CAROL, 'Hello everyone');
     transcript = transcript.addParticipant(EVE).updatedTranscript;
diff --git a/client/src/engine/chat/transcript.ts b/client/src/engine/chat/transcript.ts
index 85ba6d3..6723a5f 100644
--- a/client/src/engine/chat/transcript.ts
+++ b/client/src/engine/chat/transcript.ts
@@ -773,7 +773,11 @@ export class ConversationTranscript {
       }
 
       for (const mentionedCharacterId of this.ragHelper.getMentionedCharacterIds(message.message.id)) {
-        if (seen.has(mentionedCharacterId) || this.isCurrentlyPresent(mentionedCharacterId)) {
+        if (
+          seen.has(mentionedCharacterId) ||
+          this.isCurrentlyPresent(mentionedCharacterId) ||
+          mentionedCharacterId === focusedCharacterId
+        ) {
           continue;
         }
 
diff --git a/client/src/engine/llm.ts b/client/src/engine/llm.ts
index c6fcb74..5db4058 100644
--- a/client/src/engine/llm.ts
+++ b/client/src/engine/llm.ts
@@ -210,24 +210,30 @@ export async function chatCompletion(
         ...(useSettingsStore.getState().tokenStreamingEnabled && onTokens ? { onTokens } : {}),
       };
 
-      const responseText = await Api.llmChat(payload, { ...transportOptions, signal: options.abortSignal });
+      const responseMessage = await Api.llmChat(payload, {
+        ...transportOptions,
+        signal: options.abortSignal,
+      });
 
       usePromptLogStore.getState().addEntry({
         payloadJson: stringifyForPromptLog(payload),
         transportOptionsJson: sanitizeTransportOptionsForPromptLog(transportOptions),
-        responseJson: stringifyForPromptLog(responseText),
+        responseJson: stringifyForPromptLog(responseMessage),
       });
 
+      const content = responseMessage?.content ?? '';
+
       if (completionRequestId) {
         useTemplateRenderLogStore.getState().postTemplateRender({
           completionRequestId,
           completions: {
-            rawResponse: responseText,
+            rawResponse: content,
+            reasoning: responseMessage?.reasoning_content,
           },
         });
       }
 
-      const cleaned = cleanLlmText(responseText, resolvedPromptOptions.responsePreParserSource);
+      const cleaned = cleanLlmText(content, resolvedPromptOptions.responsePreParserSource);
       if (!cleaned) {
         throw new Error('Empty LLM response');
       }
diff --git a/client/src/engine/memory_rag_helper.ts b/client/src/engine/memory_rag_helper.ts
index 3600ca1..e3f9b18 100644
--- a/client/src/engine/memory_rag_helper.ts
+++ b/client/src/engine/memory_rag_helper.ts
@@ -51,10 +51,12 @@ export class MemoryRAGHelper {
       return [];
     }
 
-    return entry.mentionedCharacterIds.map((mentionedCharacterId) => ({
-      mentionedCharacterId,
-      content: () => this.getRagContent(fromPerspectiveId, mentionedCharacterId, entry.senderId),
-    }));
+    return entry.mentionedCharacterIds
+      .filter((id) => id !== fromPerspectiveId)
+      .map((mentionedCharacterId) => ({
+        mentionedCharacterId,
+        content: () => this.getRagContent(fromPerspectiveId, mentionedCharacterId, entry.senderId),
+      }));
   }
 
   public serialize(): SerializedRagHelper {
diff --git a/client/src/engine/prompt_templates/chat/chat_system_prompt.ts b/client/src/engine/prompt_templates/chat/chat_system_prompt.ts
index 5658459..7611794 100644
--- a/client/src/engine/prompt_templates/chat/chat_system_prompt.ts
+++ b/client/src/engine/prompt_templates/chat/chat_system_prompt.ts
@@ -99,8 +99,8 @@ Your instructions:
 - <%= isInitialMessage ? 'Write a proactive first message in the conversation as ' + it.focusedCharacter.firstName + ' in first person perspective' : 'Write the next response as ' + it.focusedCharacter.firstName + ' in first person perspective' %>
 
 - <%= it.chatMedium === 'in_person'
-  ? 'Be concise. Write no more than three sentences.'
-  : 'Text messaging style (concise, casual, abbreviated, use emojis if consistent with ' + it.focusedCharacter.firstName + "'s persona). Be concise. Write no more than three sentences." %>
+  ? 'Be concise. Output no more than three sentences.'
+  : 'Text messaging style (concise, casual, abbreviated, use emojis if consistent with ' + it.focusedCharacter.firstName + "'s persona). Be concise. Output no more than three sentences." %>
 
 - Use quotes for speech and asterisks for actions and internal speech.
 - Be aware that other characters' internal speech is not directly known to your character.
@@ -132,8 +132,8 @@ class FinalInstructionsPromptTemplate extends PromptTemplateBase<
   : 'Write the next response as ' + it.focusedCharacter.firstName + ' in first person perspective.' %>
 
 - <%= it.chatMedium === 'in_person'
-  ? 'Be concise. Write no more than three sentences.'
-  : 'Text messaging style (concise, casual, abbreviated, use emojis if consistent with ' + it.focusedCharacter.firstName + "'s persona). Be concise. Write no more than three sentences." %>
+  ? 'Be concise. Output no more than three sentences.'
+  : 'Text messaging style (concise, casual, abbreviated, use emojis if consistent with ' + it.focusedCharacter.firstName + "'s persona). Be concise. Output no more than three sentences." %>
   
 - Use quotes for speech and asterisks for actions and internal speech.
 - Be aware that other characters' internal speech is not directly known to your character.
diff --git a/client/src/engine/prompt_templates/memories/conversation_rolling_summary.ts b/client/src/engine/prompt_templates/memories/conversation_rolling_summary.ts
index 25a8064..2a193e7 100644
--- a/client/src/engine/prompt_templates/memories/conversation_rolling_summary.ts
+++ b/client/src/engine/prompt_templates/memories/conversation_rolling_summary.ts
@@ -45,7 +45,7 @@ Conversation transcript:
 
 </transcript>
 
-Write the conversation summary now.`;
+Output the conversation summary now.`;
   public readonly contextSchema = focusedConversationExecutionContextSchema;
 
   public readonly templateName = 'Conversation Rolling Summary (User)';
diff --git a/client/src/engine/prompt_templates/memories/next_conversation_goal_updates.ts b/client/src/engine/prompt_templates/memories/next_conversation_goal_updates.ts
index 8ea1111..1617c91 100644
--- a/client/src/engine/prompt_templates/memories/next_conversation_goal_updates.ts
+++ b/client/src/engine/prompt_templates/memories/next_conversation_goal_updates.ts
@@ -7,7 +7,7 @@ import { targetedConversationExecutionContextSchema } from '../prompt_template_c
 class NextConversationGoalUpdatesSystemTemplate extends PromptTemplateBase<
   z.infer<typeof targetedConversationExecutionContextSchema>
 > {
-  public readonly defaultTemplateString = `Given <%= it.focusedCharacter.firstName %>'s character persona, their memory about <%= it.targetCharacter.firstName %>, and the transcript of a conversation that just happened involving both of them, you must write a goal for <%= it.focusedCharacter.firstName %> in their next interaction with <%= it.targetCharacter.firstName %>.
+  public readonly defaultTemplateString = `Given <%= it.focusedCharacter.firstName %>'s character persona, their memory about <%= it.targetCharacter.firstName %>, and the transcript of a conversation that just happened involving both of them, you must output a goal for <%= it.focusedCharacter.firstName %> in their next interaction with <%= it.targetCharacter.firstName %>.
 
 Rules:
 - Prioritize specific goals that were discussed in the conversation.
@@ -15,7 +15,8 @@ Rules:
 - Write in the third person perspective.
 - Choose a goal that provides strong narrative momentum.
 - Be specific and provide sufficient context.
-- Output the goal and nothing else`;
+- Be specific and creative about how <%= it.focusedCharacter.firstName %> might pursue this goal exactly. Specificity helps keep things moving along, creativity keeps it interesting.
+- Output the goal and necessary context, nothing else`;
   public readonly contextSchema = targetedConversationExecutionContextSchema;
 
   public readonly templateName = 'Next Conversation Goal (System)';
diff --git a/client/src/engine/prompt_templates/memories/offscreen_memory_extraction.ts b/client/src/engine/prompt_templates/memories/offscreen_memory_extraction.ts
index e8f58ad..f15093b 100644
--- a/client/src/engine/prompt_templates/memories/offscreen_memory_extraction.ts
+++ b/client/src/engine/prompt_templates/memories/offscreen_memory_extraction.ts
@@ -7,15 +7,18 @@ import { targetedConversationExecutionContextSchema } from '../prompt_template_c
 class OffscreenMemoryExtractionSystemTemplate extends PromptTemplateBase<
   z.infer<typeof targetedConversationExecutionContextSchema>
 > {
-  public readonly defaultTemplateString = `You will be given a conversation transcript in which <%= it.targetCharacter.firstName %> <%= it.targetCharacter.lastName %> may have been mentioned. You will also be given memories and persona information about one of the participants in the conversation, named <%= it.focusedCharacter.firstName %>. Your job is to identify one new piece of information in the conversation that is relevant to <%= it.focusedCharacter.firstName %>'s relationship with <%= it.targetCharacter.firstName %>. This can be information pertaining to <%= it.targetCharacter.firstName %>'s relationship with other characters (including but not limited to <%= it.focusedCharacter.firstName %>), general facts and hearsay about <%= it.targetCharacter.firstName %>, or information that <%= it.focusedCharacter.firstName %> would want to share with <%= it.targetCharacter.firstName %>.
+  public readonly defaultTemplateString = `You will be given a conversation transcript in which <%= it.targetCharacter.firstName %> <%= it.targetCharacter.lastName %> may have been mentioned. You will also be given memories and persona information about one of the participants in the conversation, named <%= it.focusedCharacter.firstName %>. Your job is to identify the most important new information in the conversation that is relevant to <%= it.focusedCharacter.firstName %>'s relationship with <%= it.targetCharacter.firstName %>. This can be any of:
+  - Plans or desires held by <%= it.focusedCharacter.firstName %> and relevant to <%= it.targetCharacter.firstName %>.
+  - Information pertaining to <%= it.targetCharacter.firstName %>'s relationship with other characters (including but not limited to <%= it.focusedCharacter.firstName %>).
+  - General facts and hearsay about <%= it.targetCharacter.firstName %>.
+  - Any other type of information relevant to <%= it.targetCharacter.firstName %>.
 
 Rules:
-- Identify and output at most one new piece of information relevant to <%= it.targetCharacter.firstName %> <%= it.targetCharacter.lastName %>.
 - The information should be something that can help color <%= it.focusedCharacter.firstName %>'s future interactions with <%= it.targetCharacter.firstName %>, or their future conversations about <%= it.targetCharacter.firstName %>.
 - Prioritize information that provides narrative momentum, such as relationship details between <%= it.targetCharacter.firstName %> and other characters, actionable intentions between characters, plans, insights, or facts. Anything that would make for good "gossip" is valuable.
 - If the information is hearsay or inferred rather than explicit, include appropriate hedging and qualifications in the output.
 - Consider <%= it.focusedCharacter.firstName %>'s unique personality and what kind of information they might want to take into their next conversation with or about <%= it.targetCharacter.firstName %>.
-- The information must come from the conversation transcript.
+- The information must come from the conversation transcript, but you must provide sufficient context that the information can be understood without reference to the conversation transcript.
 
 Output format:
 - Output a single plain string containing only the information.
diff --git a/client/src/engine/prompt_templates/memories/offscreen_memory_update_conversation_goal.ts b/client/src/engine/prompt_templates/memories/offscreen_memory_update_conversation_goal.ts
index 4682770..4a26b18 100644
--- a/client/src/engine/prompt_templates/memories/offscreen_memory_update_conversation_goal.ts
+++ b/client/src/engine/prompt_templates/memories/offscreen_memory_update_conversation_goal.ts
@@ -7,15 +7,15 @@ import { offscreenMemoryUpdateConversationGoalContextSchema } from '../prompt_te
 class OffscreenMemoryUpdateConversationGoalSystemTemplate extends PromptTemplateBase<
   z.infer<typeof offscreenMemoryUpdateConversationGoalContextSchema>
 > {
-  public readonly defaultTemplateString = `Your job is to decide whether newly learned information should change <%= it.focusedCharacter.firstName %>'s next conversation goal with <%= it.targetCharacter.firstName %>. You will be given <%= it.focusedCharacter.firstName %>'s current memories of <%= it.targetCharacter.firstName %>, their existing goal towards them (if any), and one new piece of information that <%= it.focusedCharacter.firstName %> just learned regarding <%= it.targetCharacter.firstName %>.
+  public readonly defaultTemplateString = `Your job is to decide whether newly learned information should change <%= it.focusedCharacter.firstName %>'s next conversation goal with <%= it.targetCharacter.firstName %>. You will be given <%= it.focusedCharacter.firstName %>'s current memories of <%= it.targetCharacter.firstName %>, their existing goal towards them (if any), and some new information that <%= it.focusedCharacter.firstName %> just learned regarding <%= it.targetCharacter.firstName %>.
 
-If the new piece of information suggests a more important goal for <%= it.focusedCharacter.firstName %> to pursue with <%= it.targetCharacter.firstName %>, you should write a new goal. Otherwise, you should keep the old goal.
+If the new piece of information suggests a more important goal for <%= it.focusedCharacter.firstName %> to pursue with <%= it.targetCharacter.firstName %>, you should output a new goal. Otherwise, you should keep the old goal.
 
 If you decide to keep the old goal:
 - Output only "KEEP_OLD_GOAL" exactly.
 
-If you decide to write a new goal for <%= it.focusedCharacter.firstName %> to pursue with <%= it.targetCharacter.firstName %>:
-- Write a goal that provides strong narrative momentum.
+If you decide to output a new goal for <%= it.focusedCharacter.firstName %> to pursue with <%= it.targetCharacter.firstName %>:
+- Output a goal that provides strong narrative momentum.
 - Prioritize taking decisive action rather than just planning.
 - Be specific and provide sufficient context.
 - Output only the updated goal and nothing else`;
diff --git a/client/src/engine/prompt_templates/memories/relationship_descriptor_update.ts b/client/src/engine/prompt_templates/memories/relationship_descriptor_update.ts
index bdd1c42..c434302 100644
--- a/client/src/engine/prompt_templates/memories/relationship_descriptor_update.ts
+++ b/client/src/engine/prompt_templates/memories/relationship_descriptor_update.ts
@@ -11,12 +11,12 @@ class RelationshipDescriptorUpdateSystemTemplate extends PromptTemplateBase<
 1. A list of summaries of recent conversations that have taken place between <%= it.focusedCharacter.firstName %> and <%= it.targetCharacter.firstName %> (if any).
 2. A list of secondhand information that <%= it.focusedCharacter.firstName %> has heard about <%= it.targetCharacter.firstName %> (if any).
 3. A consolidated summary of <%= it.focusedCharacter.firstName %>'s memories towards <%= it.targetCharacter.firstName %> (if any).
-4. What <%= it.targetCharacter.firstName %> currently sees <%= it.focusedCharacter.firstName %> as being, in a broad descriptive sense (e.g. "friend", "rival", "jerk", "helper", "romantic interest", etc).
+4. What <%= it.focusedCharacter.firstName %> currently sees <%= it.targetCharacter.firstName %> as being, in a broad descriptive sense (e.g. "friend", "rival", "jerk", "helper", "romantic interest", etc).
 
-Your job is to use the available information to determine what <%= it.targetCharacter.firstName %> now sees <%= it.focusedCharacter.firstName %> as being, in a broad sense.
+Your job is to use the available information to determine what <%= it.focusedCharacter.firstName %> now sees <%= it.targetCharacter.firstName %> as being, in a broad sense.
 
 Rules:
-- Output just 1-3 words that represent what <%= it.focusedCharacter.firstName %> sees <%= it.targetCharacter.firstName %> as being now.
+- Output just 1-5 words that represent what <%= it.focusedCharacter.firstName %> sees <%= it.targetCharacter.firstName %> as being now.
 - Examples: "Friend", "Rival", "Hated Enemy", "Boyfriend", "Mentor".
 - If the existing descriptor is already adequate, you may output that as-is.`;
   public readonly contextSchema = targetedConversationExecutionContextSchema;
diff --git a/client/src/engine/prompt_templates/memories/rolling_pairwise_memory_rewrite.ts b/client/src/engine/prompt_templates/memories/rolling_pairwise_memory_rewrite.ts
index f89a507..b95a923 100644
--- a/client/src/engine/prompt_templates/memories/rolling_pairwise_memory_rewrite.ts
+++ b/client/src/engine/prompt_templates/memories/rolling_pairwise_memory_rewrite.ts
@@ -7,21 +7,21 @@ import { targetedConversationExecutionContextSchema } from '../prompt_template_c
 class RollingPairwiseMemoryRewriteSystemTemplate extends PromptTemplateBase<
   z.infer<typeof targetedConversationExecutionContextSchema>
 > {
-  public readonly defaultTemplateString = `You will be given the following types of information:
-1. An existing consolidated summary of <%= it.focusedCharacter.firstName %>'s memories towards <%= it.targetCharacter.firstName %> (if any).
-2. A list of summaries of recent conversations that have taken place between <%= it.focusedCharacter.firstName %> and <%= it.targetCharacter.firstName %> (if any).
-3. A list of secondhand information that <%= it.focusedCharacter.firstName %> has heard about <%= it.targetCharacter.firstName %> (if any).
-4. A goal for <%= it.focusedCharacter.firstName %> in their next interaction with <%= it.targetCharacter.firstName %> (if any) 
+  public readonly defaultTemplateString = `Your job is to read a list of past interaction summaries and use it to synthesize a consistent internal memory state for <%= it.focusedCharacter.firstName %> to bring into their future interactions with <%= it.targetCharacter.firstName %>. You will also have access to <%= it.focusedCharacter.firstName %>'s existing internal memory state, persona information, and immediate goal in their next interaction with <%= it.targetCharacter.firstName %>.
 
-Your job is to use the available information to update <%= it.focusedCharacter.firstName %>'s consolidated memory about <%= it.targetCharacter.firstName %>. The existing consolidated memory is now stale and needs updating to include newer details.
+Consider not only what happened, but the order it happened in, and how it shows evolution or insights into <%= it.focusedCharacter.firstName %>'s relationship with <%= it.targetCharacter.firstName %> and their goals towards <%= it.targetCharacter.firstName %>.
+
+The purpose of the new internal memory state will be to inform the behavior of a roleplayer who will roleplay as <%= it.focusedCharacter.firstName %> in future interactions with <%= it.targetCharacter.firstName %>. Consider what information the roleplayer should know in order to accurately roleplay as <%= it.focusedCharacter.firstName %> in future interactions with <%= it.targetCharacter.firstName %>.
+
+The existing internal memory state that will be provided was previously generated based on an older version of the same rolling list of recent interaction summaries.
 
 Rules:
-- Your goal is to crystallize the current state of <%= it.focusedCharacter.firstName %>'s relationship with <%= it.targetCharacter.firstName %> based on the provided logs.
-- First, prioritize information that is relevant to <%= it.focusedCharacter.firstName %>'s goal in their next interaction with <%= it.targetCharacter.firstName %> (if any), without restating the goal.
-- Second, prioritize <%= it.focusedCharacter.firstName %>'s broader goals and intentions towards <%= it.targetCharacter.firstName %>, relationship status, memories, and emotional trajectory relevant to the relationship.
-- From the existing consolidated memory, keep important details that remain plausible, even if they are not substantiated in the most recent conversation summaries.
-- Write in third person. Be specific and direct.
-- Output only the updated memory.`;
+- Prioritize actionable information that can be used to guide <%= it.focusedCharacter.firstName %>'s future behavior towards <%= it.targetCharacter.firstName %>.
+- Reference <%= it.focusedCharacter.firstName %>'s persona to guide prioritization and emotional valence.
+- Only include experientially earned information that is distinct from <%= it.focusedCharacter.firstName %>'s persona information (the roleplayer will be provided the persona information separately).
+- Provide sufficient context and reasoning for any goals or intentions.
+- Newer (bottom-most) conversation summaries should be weighted more heavily.
+- Output only the new internal memory state, nothing else.`;
   public readonly contextSchema = targetedConversationExecutionContextSchema;
 
   public readonly templateName = 'Rolling Pairwise Memory Rewrite (System)';
@@ -35,13 +35,19 @@ Rules:
 class RollingPairwiseMemoryRewriteUserTemplate extends PromptTemplateBase<
   z.infer<typeof targetedConversationExecutionContextSchema>
 > {
-  public readonly defaultTemplateString = `<%= it.focusedCharacter.firstName %>'s existing consolidated memory about <%= it.targetCharacter.firstName %>:
+  public readonly defaultTemplateString = `<%= it.focusedCharacter.firstName %>'s persona:
+<persona>
+<%= it.focusedCharacter.internalDescription %>
+
+</persona>
+
+<%= it.focusedCharacter.firstName %>'s existing internal memory state towards <%= it.targetCharacter.firstName %> (this is what you need to output a new version of):
 <existing_memory>
 <%= it.targetCharacterRelationship.memory || (it.focusedCharacter.firstName + ' has no memories about ' + it.targetCharacter.firstName + ' yet.') %>
 
 </existing_memory>
 
-Recent specific interactions with and information about <%= it.targetCharacter.firstName %> that <%= it.focusedCharacter.firstName %> remembers (oldest first):
+Recent summarized interactions with and information about <%= it.targetCharacter.firstName %> from <%= it.focusedCharacter.firstName %>'s perspective (oldest first):
 <%= it.targetCharacterFormattedRollingMemoriesText %>
 
 
@@ -52,7 +58,7 @@ Recent specific interactions with and information about <%= it.targetCharacter.f
 </goal>
 
 
-Output the updated memory now, prioritizing more recent information.`;
+Output the updated internal memory state for <%= it.focusedCharacter.firstName %> to bring into future interactions with <%= it.targetCharacter.firstName %>.`;
   public readonly contextSchema = targetedConversationExecutionContextSchema;
 
   public readonly templateName = 'Rolling Pairwise Memory Rewrite (User)';
diff --git a/client/src/state/template_render_log_store.ts b/client/src/state/template_render_log_store.ts
index 39ac213..6c60b8a 100644
--- a/client/src/state/template_render_log_store.ts
+++ b/client/src/state/template_render_log_store.ts
@@ -22,6 +22,7 @@ type TemplateRenderLogEntry = {
   completions?:
     | {
         rawResponse: string;
+        reasoning?: string | undefined;
       }
     | undefined;
   parser?:
@@ -43,6 +44,7 @@ type TemplateRenderLogStoreState = {
     template?: TemplateRenderLogRenderedTemplate;
     completions?: {
       rawResponse: string;
+      reasoning?: string | undefined;
     };
     parser?: {
       parsedResponse: unknown;
diff --git a/docs/docs/reasoning-models.md b/docs/docs/reasoning-models.md
index a908c63..5570e83 100644
--- a/docs/docs/reasoning-models.md
+++ b/docs/docs/reasoning-models.md
@@ -10,8 +10,94 @@ keywords:
   - feedback
 ---
 
-You can use reasoning models in Yozakura if you want. They might do better at certain tasks, like memory generation or next-speaker selection, and you can [use different models on a per-prompt basis](how-to-different-models-per-prompt.md) if you want.
+You can use reasoning models in Yozakura if you want. They might do better at certain tasks, like memory generation or next-speaker selection, and you can [use different models or configuration on a per-prompt basis](how-to-different-models-per-prompt.md). Reasoning tends to use a lot more tokens and take a lot longer, but it might be a worthwhile tradeoff depending on how you like to use Yozakura.
 
-But you will need to increase the default `max_tokens` settings. You can do that in [LLM Settings](yozakura://?settings=true&settingspath=llm). Go through all of those settings (or at least the ones you intend to use a reasoning model for) and either remove the `max_tokens` to make it unlimited, or increase it by a couple thousand.
+Below we will walk through two examples of using a reasoning model. The details might be different for other models and host software. Last, we'll go over a few tips and tricks.
 
-The reason you have to do this is because reasoning tokens count towards the `max_tokens` budget, making it much easier to hit the default max values if you're using a reasoning model.
+## Local: Gemma 4 26B A4B on KoboldCpp
+
+**Make sure you have the latest version of KoboldCpp**. Some of the features used below are very new at the time of this writing. I am using v1.117.1.
+
+Gemma 4 26B A4B is an excellent model that runs pretty well on many consumer GPUs and has reasoning capability. I find that using reasoning for memory generation in Yozakura does significantly improve memory quality with this model, at the cost of taking much longer when a conversation ends. It's a very verbose reasoner.
+
+When loading the model in KoboldCpp, just enable the `Use Jinja` checkbox on the `Quick Launch` tab. Other than that, launch KoboldCpp normally.
+
+To enable reasoning for memory generation only, go to [LLM Settings](yozakura://?settings=true&settingspath=llm) in Yozakura and edit all of the items that begin with `Chat Memory:`.
+
+For each one, you'll want to add `chat_template_kwargs.enable_thinking: true`, specify a `thinking_budget_tokens`, and increase `max_tokens` under `LLM Meta Options (JSON)`. Don't forget to click `Save`.
+
+**Example:** By default, the `LLM Meta Options (JSON)` for `Chat Memory: Summarize Conversation` looks like this:
+
+```json
+{
+  "max_tokens": 500
+}
+```
+
+To enable reasoning, I change it to this:
+
+```json
+{
+  "max_tokens": 1515,
+  "chat_template_kwargs": {
+    "enable_thinking": true
+  },
+  "thinking_budget_tokens": 1000
+}
+```
+
+This allows the model to use up to 1000 tokens for reasoning, and then the rest of its 1515 max_tokens budget for the actual output. I changed max_tokens to 1515 instead of 1500 to provide a little extra buffer, because when the thinking budget is exhausted, KoboldCpp injects some extra tokens like `"Thinking budget exhausted, time to answer!"`.
+
+Note that it's possible for the model to decide not to do any reasoning, and then it could output a memory of size ~1515 tokens, instead of the ~500 max that I want. I'm not aware of any way to avoid that in the current version of KoboldCpp, but I also haven't seen it be a problem in practice.
+
+## OpenRouter: DeepSeek V4 Flash
+
+To use DeepSeek V4 Flash via OpenRouter, first open [LLM Settings](yozakura://?settings=true&settingspath=llm) in Yozakura and edit the `Base Defaults`. Set the `Model` field to `deepseek/deepseek-v4-flash`. If you haven't already, make sure the `Completions API URL` is pointing to the correct URL for OpenRouter (`https://openrouter.ai/api/v1/chat/completions`). Don't forget to click `Save`.
+
+### Disabling Reasoning By Default
+
+When using reasoning models via OpenRouter (or at least this one), reasoning is enabled by _default for all requests_. Unless you actually want to use reasoning for all types of prompts, you should disable it by default. To do so, add a `reasoning` section to the bottom of `LLM Meta Options (JSON)` under `Base Defaults` in Yozakura's [LLM Settings](yozakura://?settings=true&settingspath=llm). Don't forget to click `Save`.
+
+**Example:** Here's the default `LLM Meta Options (JSON)` settings, plus a `reasoning` section I added to disable reasoning:
+
+```json
+{
+  "temperature": 0.3,
+  "min_p": 0.035,
+  "dry_multiplier": 0.8,
+  "dry_base": 1.75,
+  "dry_allowed_length": 2,
+  "xtc_threshold": 0.1,
+  "xtc_probability": 0.5,
+  "max_tokens": 1000,
+  "model": "deepseek/deepseek-v4-flash",
+  "reasoning": {
+    "enabled": false
+  }
+}
+```
+
+### Enabling Reasoning For Specific Prompts
+
+Now update the prompt settings in Yozakura's [LLM Settings](yozakura://?settings=true&settingspath=llm) for all of the prompts that you _do_ want to use reasoning (probably at least all the ones starting with `Chat Memory:`, but it's up to you).
+
+**Example:** Here's the updated `LLM Meta Options (JSON)` I used to enable reasoning for the `Chat Memory: Summarize Conversation` prompt:
+
+```json
+{
+  "max_tokens": 1515,
+  "reasoning": {
+    "enabled": true,
+    "max_tokens": 1000
+  }
+}
+```
+
+This allows the model to use up to 1000 tokens for reasoning. Note, I also had to increase the top-level `max_tokens` to 1515 to fit the 1000 reasoning tokens, plus the ~500 max output tokens I want. The extra 15 in `1515` is a little extra buffer for the formatting tags that reasoning often uses internally.
+
+## Tips
+
+1. I've found it works pretty well to give a thinking budget that's either 1000 tokens, or double the max desired output size, whichever is larger. Different models will likely work best with different numbers.
+2. Bigger is not always better. Reasoning models, especially weaker ones, might get into loops where they second-guess themselves unnecessarily, and output gets worse instead of better.
+3. Consider editing the prompt templates to instruct the model on _how_ to think. You may be able to improve behavior by doing so, though I haven't experimented much myself.
+4. You can read the reasoning step output in the [Template Render Log](yozakura://?settings=true&settingspath=prompt-templates%2Ftemplate-render-log) in Yozakura's `Prompt Templates` settings.
diff --git a/docs/docs/suggested-models.md b/docs/docs/suggested-models.md
index d29bca8..53bd0e0 100644
--- a/docs/docs/suggested-models.md
+++ b/docs/docs/suggested-models.md
@@ -19,13 +19,13 @@ Smaller models are of course "stupider" and more prone to hallucination, misattr
 
 Below are some local models I've tried or have heard reports about (and if you find a particularly good model, please share your report too, you can contact via the [links page](links.md))
 
-| Model                                                                                   | Size                | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| --------------------------------------------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [Gemma 4 26B A4B](https://huggingface.co/google/gemma-4-26B-A4B)                        | 26B (but see notes) | This is my new daily driver now and I find it radically smarter than 12B models. This model runs exceptionally well with layers offloaded to CPU, so it can run on weaker hardware than you might expect. I run the K_4_M quant on 12GB of VRAM with only 17 layers on the GPU, and get close to 20 tokens per second. That can feel a little slow at the memory generation stage, but I find it's worth it. I run an SDXL image model alongside this, so if you're not doing that, you can probably do this on 10GB VRAM or maybe even 8. If you're in that range, try it out, you might be surprised. |
-| [Gemma 4 12B IT](https://huggingface.co/google/gemma-4-12B-it)                          | 12B                 | It's not as strong as the 26B model, which is to be expected, but it might be the best 12B model for coherence. At the same time, it might be a little less creative and entertaining than some other 12B models.                                                                                                                                                                                                                                                                                                                                                                                       |
-| [NemoMix Unleashed 12B](https://huggingface.co/MarinaraSpaghetti/NemoMix-Unleashed-12B) | 12B                 | This was my clear favorite 12B model before Gemma 4, providing a good mixture of believable character behavior and memory correctness. It can be funnier than Gemma 4. If you're looking for a 12B model, my recommendation would be to give both Gemma4 and NemoMix Unleashed a shot and see which you prefer.                                                                                                                                                                                                                                                                                         |
-| [Mag Mell R1](https://huggingface.co/inflatebot/MN-12B-Mag-Mell-R1)                     | 12B                 | Another 12B model that's a long-time favorite in the RP community. It can be pretty aggressive and I find it a bit much, but it can be hilarious sometimes in a way that other models don't match. Worth a shot if you value spontaneity, but hard to recommend broadly.                                                                                                                                                                                                                                                                                                                                |
-| [Llama 3.1 8B Instruct](https://huggingface.co/meta-llama/Llama-3.1-8B-Instruct)        | 8B                  | A workhorse model. A little plain, but does a good job mechanically. There are a lot of finetunes out there that might give a more interesting experience, but some of the RP-specialized ones do poorly on generating memories and sometimes fail to understand that they're supposed to be generating memories and instead try to continue the conversation or something.                                                                                                                                                                                                                             |
-| [Gemma 4 E2B](https://huggingface.co/google/gemma-4-E2B-it-qat-q4_0-gguf)               | 5B                  | Yes you can use this tiny model for Yozakura and it's surprisingly good. From what I saw in my limited time with it, I think it's at least as good as Llama 3.1 8B, and may even approach 12B models. You may not even need a GPU for this model, many machines can get acceptable performance purely from CPU inference.                                                                                                                                                                                                                                                                               |
+| Model                                                                                   | Size                | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| --------------------------------------------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [Gemma 4 26B A4B](https://huggingface.co/google/gemma-4-26B-A4B)                        | 26B (but see notes) | This is my new daily driver now and I find it radically smarter than 12B models. This model runs exceptionally well even with some CPU offloading, so it can run on weaker hardware than you might expect. I run the K_4_M quant on my 3080 Ti using KoboldCpp's default configuration, and get around 30 tokens per second. That can feel a little slow at the memory generation stage, but I find it's worth it. If you're in the 8-12 GB VRAM range, try it out, you might be surprised. |
+| [Gemma 4 12B IT](https://huggingface.co/google/gemma-4-12B-it)                          | 12B                 | It's not as strong as the 26B model, which is to be expected, but it might be the best 12B model for coherence. At the same time, it might be a little less creative and entertaining than some other 12B models.                                                                                                                                                                                                                                                                           |
+| [NemoMix Unleashed 12B](https://huggingface.co/MarinaraSpaghetti/NemoMix-Unleashed-12B) | 12B                 | This was my clear favorite 12B model before Gemma 4, providing a good mixture of believable character behavior and memory correctness. It can be funnier than Gemma 4. If you're looking for a 12B model, my recommendation would be to give both Gemma4 and NemoMix Unleashed a shot and see which you prefer.                                                                                                                                                                             |
+| [Mag Mell R1](https://huggingface.co/inflatebot/MN-12B-Mag-Mell-R1)                     | 12B                 | Another 12B model that's a long-time favorite in the RP community. It can be pretty aggressive and I find it a bit much, but it can be hilarious sometimes in a way that other models don't match. Worth a shot if you value spontaneity, but hard to recommend broadly.                                                                                                                                                                                                                    |
+| [Llama 3.1 8B Instruct](https://huggingface.co/meta-llama/Llama-3.1-8B-Instruct)        | 8B                  | A workhorse model. A little plain, but does a good job mechanically. There are a lot of finetunes out there that might give a more interesting experience, but some of the RP-specialized ones do poorly on generating memories and sometimes fail to understand that they're supposed to be generating memories and instead try to continue the conversation or something.                                                                                                                 |
+| [Gemma 4 E2B](https://huggingface.co/google/gemma-4-E2B-it-qat-q4_0-gguf)               | 5B                  | Yes you can use this tiny model for Yozakura and it's surprisingly good. From what I saw in my limited time with it, I think it's at least as good as Llama 3.1 8B, and may even approach 12B models. You may not even need a GPU for this model, many machines can get acceptable performance purely from CPU inference.                                                                                                                                                                   |
 
 The only cloud model I've done much with is `deepseek/deepseek-chat-v3` which is excellent.