AtlasWolfy

In JanitorAI (and similar NSFW bot platforms), memory operates through a combination of the bot's built-in setup and the AI model's context window, which is limited by tokens. Here's a breakdown:

How Memory Works

- Core Bot Memory (Permanent Tokens): This is the fixed foundation defined by the bot creator, including the character's personality, backstory, traits, and initial scenario. It's always included in every interaction and doesn't change unless the creator updates the bot. It forms the "permanent" knowledge the AI references.

- Chat Memory (User-Added): This is a customizable feature where you, as the user, can add extra details that persist across the conversation. It acts like a "lore book" or knowledge bank the bot can draw from. For example, you can input key events, relationships, or reminders (e.g., "{{user}} is a vampire hunter; {{char}} has a scar from their last fight"). This gets added as additional permanent tokens, helping the bot recall user-specific info without relying solely on chat history.

- Context Window and Temporary Memory: The AI model (often JLLM or similar LLMs) has a total token limit (typically 8k–32k tokens, depending on the model). This includes permanent tokens, chat memory, the current user input, and recent chat history. As the conversation grows, older messages are automatically dropped (forgotten) to stay under the limit, leading to loss of context. This is why bots "forget" details from early in the chat or start looping—repeating phrases or actions because they lose track of prior events and fall back on generic responses from their core definition.

- Looping Causes: Beyond forgetting, looping can stem from overfilled context (causing degraded recall), poor bot design (e.g., repetitive prompts in the definition), or the AI model's tendencies under high token loads. JLLM, in particular, struggles with larger contexts compared to bigger models like those from OpenAI.

In short, memory isn't infinite; it's a sliding window of recent + permanent info. When it overflows, continuity breaks.

Ways to Maintain Chat Continuity and Prevent Forgetting/Looping

Here are practical strategies based on community advice (primarily from JanitorAI users on Reddit). These focus on token management, proactive reminders, and interaction techniques:

1. Use and Structure Chat Memory Effectively:

- Access it via chat settings (three lines icon > Chat Memory).

- Add concise summaries of key events every 5–10 messages or after major plot points. For example: "Summary: {{user}} and {{char}} escaped the castle; {{char}} confessed love; Current location: forest hideout."

- Organize into sections for better AI recall: e.g., "Core Relationship: [details]", "Recent Events: [bullet points]", "Temporary Details: [short-term info]". Keep it under 1,000–2,000 tokens to leave room for history (total available = 4,000–13,000 minus bot's permanent tokens).

- Update it manually—avoid auto-summaries, as they often skip details or bloat text. Use OOC (out-of-character) prompts in-chat like "(OOC: Summarize the last 5 events for chat memory)" to generate ideas, then copy-paste into memory.

- This turns short-term history into long-term "permanent" knowledge, reducing forgetting.

2. Manage Message Length and Chat Flow:

- Keep your responses detailed but concise (1–2 paragraphs) to provide context without burning tokens quickly. Detailed inputs help the bot generate varied replies and avoid loops.

- Use shorter bot responses if possible by regenerating (swipe or edit) until you get non-repetitive ones.

- Periodically remind the bot in your messages: e.g., "Remember, we just escaped the castle—let's continue from there without repeating."

3. Handle Long Chats Proactively:

- Start new chats with a summary prompt: Copy key history into the first message or chat memory to "reset" without full loss.

- Every 20–50 messages, insert an OOC command like "(OOC: Maintain continuity; do not loop actions; reference chat memory)".

- If looping persists, add anti-repetition instructions to chat memory: e.g., "{{char}} WILL NOT repeat phrases or actions; vary responses; advance the story."

4. Regeneration and Editing Tricks:

- Swipe to regenerate bot replies multiple times—often the second or third version breaks loops by pulling different context.

- Edit your own previous messages to refine details, which can steer the bot back on track.

- If the bot forgets a specific detail, reintroduce it explicitly in your next input: e.g., "As we discussed earlier, I'm allergic to garlic—how does that affect our plan?"

5. Advanced Tips for Persistent Issues:

- Check token usage in settings; aim to stay under 80% of the limit to preserve recall quality.

- For very long roleplays, divide into "chapters": End one chat, summarize in memory, and start a new one referencing the summary.

- Experiment with different models if available (e.g., switch proxies or APIs for larger context windows).

- Community hacks: Use templates in chat memory like "[Do not speak for {{user}}]; [Progress plot uniquely]" to enforce better behavior.

These methods can extend effective memory significantly, but they're workarounds for inherent LLM limits. If issues are bot-specific, check the creator's notes or report in communities like Reddit's r/JanitorAI_Official for tailored fixes.

Elaborating on Dividing Long Roleplays into "Chapters" in JanitorAI

Dividing long roleplays (RPs) into "chapters" is a popular workaround in JanitorAI to manage memory limits and prevent the bot from forgetting key details or looping as conversations extend beyond the context window (typically 8k–16k tokens, depending on the model). The core idea is to treat each "chapter" as a separate chat session while preserving continuity through summaries stored in Chat Memory. This method leverages the platform's features to "archive" past events without bloating the active history, allowing for multi-session stories that feel seamless.

Here's a step-by-step guide on how to implement this, based on common user practices:

1. Recognize When to "Chapter" Your RP:

- Monitor the chat's length: If you're approaching 50+ messages or noticing forgetting/repetition, it's time. Check token usage in chat settings (three lines icon > Advanced > Token count) to confirm if you're near the limit.

- Decide on natural breaks: End a chapter at plot milestones, like after a major event, location change, or character development (e.g., end of a battle, start of a new arc).

2. Summarize the Current Chapter:

- Use an Out-of-Character (OOC) prompt in your last message to generate a summary. For example: "(OOC: Summarize the entire story so far in 300-500 words, focusing on key events, character relationships, current status, and unresolved plot points. Format as a neutral narrative.)"

- The bot will respond with a summary. Copy this text (edit if needed for conciseness to save tokens).

- Alternatively, manually write your own summary if the bot's is off—keep it factual and spoiler-free for future reference.

3. Store the Summary in Chat Memory:

- Go to chat settings (three lines icon > Chat Memory).

- Paste the summary into the memory field. Structure it for clarity, e.g.:

- Use headings like "Chapter 1 Summary:" or "Previous Events:".

- Include placeholders like "{{user}} is [status]; {{char}} feels [emotion] about [event]."

- Keep the total Chat Memory under 1,000-2,000 tokens to leave room for new content. You can add multiple summaries for ongoing RPs (e.g., stack Chapter 1, then Chapter 2).

4. End the Current Chat and Start a New One:

- Save or screenshot the final messages if needed for reference.

- Exit the chat and start a new one with the same bot (or create a duplicate if you want variations).

- In the new chat's first message, reference the summary to "load" the context: E.g., "Continuing from our last adventure: [brief recap or direct paste of key summary points]. Let's pick up where we left off—[describe the starting scene]."

5. Maintain Continuity in the New Chapter:

- Update Chat Memory as the new chapter progresses with mini-summaries every 10-20 messages.

- Remind the bot in inputs: E.g., "Remember from previous chapters: [quick detail]."

- If using multiple chapters, reference all prior summaries in memory, but prioritize the most recent one in prompts.

This approach effectively "resets" the token-heavy history while keeping the story's essence in permanent memory, allowing RPs to span hundreds of messages across sessions without losing coherence.

Example: Fantasy RP with a Dragon Companion Bot

Scenario: You're RPing as an adventurer with a dragon bot named Drakon. The story has built up over 40 messages: You've met Drakon, formed an alliance, fought bandits, and discovered a hidden temple. Now, the chat is lagging—Drakon forgets the alliance and loops on "Who are you?"

1. Summarize the Current Chapter:

- Your OOC prompt: "(OOC: Summarize our RP so far in 400 words: Key events, our relationship, items acquired, and current location.)"

- Bot's response (example summary): "In this tale, {{user}} the brave adventurer encountered Drakon, the ancient dragon, in the misty mountains. Initially wary, they forged an alliance after {{user}} saved Drakon's egg from poachers. Together, they battled a bandit horde, acquiring a magical sword and a map to the Lost Temple. Drakon now trusts {{user}} as a rider and companion. Current status: Resting at the temple entrance, planning to enter at dawn. Unresolved: The temple's guardian curse and Drakon's hidden weakness to silver."

2. Store in Chat Memory:

- Paste into Chat Memory:

Chapter 1 Summary:

In this tale, {{user}} the brave adventurer encountered Drakon... [full summary].

Ongoing Details: {{user}} wields magical sword; Drakon is bonded to {{user}}; Location: Temple entrance.

3. Start New Chat (Chapter 2):

- New chat first message from you: "Picking up from our alliance: We've rested at the temple entrance after fighting the bandits. Drakon, with our bond strong and the magical sword in hand, let's enter the temple and face the guardian curse. What do you sense ahead?"

The bot should now reference the summary from memory, continuing seamlessly (e.g., "As your trusted companion, I sense dark magic within..."). If it slips, add reminders like "Recall our bond from the mountains" in future inputs.

This method has helped users sustain epic, multi-chapter stories—experiment and adjust based on your bot's model.