The Livingrimoire advantage: a tiny “welcome back” skill that LLMs can’t match

The Livingrimoire advantage: a tiny “welcome back” skill that LLMs can’t match

Everyone’s trying to build “AI agents” with LLMs alone.

But there’s a hard limit most people ignore:

LLMs generate text.

They don’t generate behavior.

To show what I mean, here’s a tiny Livingrimoire skill called DiOkaeri.

It does something that sounds simple, but is actually impossible to do reliably with an LLM alone:

• When the user leaves, it says goodbye
• When the user comes back, it greets them differently depending on how long they were gone
• You can bolt on extra behavior like “don’t forget your umbrella” if it’s going to rain

This is where architecture beats prompts.

---

1. The idea: time‑aware “welcome back”

The DiOkaeri skill has one job:

Track when the user leaves, and when they come back, respond based on the time gap.

Examples:

• Gone for 30 seconds → “That was quick!”
• Gone for 5 minutes → “Welcome back!”
• Gone for 3 hours → “Welcome back — been a little while!”
• Gone for more than a day → “You were gone a long time — welcome home.”

That’s not just “fancy wording”.

It’s logic + state + time.

An LLM can describe this behavior.

A Livingrimoire skill can be this behavior.

---

2. The skill itself

Here’s where you paste the actual skill code so readers can see it in full:

import time
import random

from LivinGrimoirePacket.LivinGrimoire import Skill


class DiOkaeri(Skill):
    """
    Itekimase / Okaeri skill — English edition.
    Says goodbye when the user leaves, and welcomes them back
    with a greeting that scales to how long they were away.

    Triggers:
      Leave : ear contains any of BYE_WORDS  (e.g. "bye", "see you", "brb")
      Return: ear contains any of BACK_WORDS (e.g. "hi", "back", "i'm back")
    """

    BYE_WORDS = {"bye", "goodbye", "see you", "later", "be right back", "going", "leaving", "cya"}
    BACK_WORDS = {"i am back", "i'm back", "im back", "returned"}

    # (max_seconds, [reply options])
    TIERS = [
        (60, [
            "That was quick!",
            "Back already? Missed you for those few seconds.",
            "Wow, speed run!",
        ]),
        (600, [
            "Welcome back!",
            "Hey, you're back!",
            "Good to see you again.",
        ]),
        (3600, [
            "Welcome back — been a little while!",
            "There you are! Have a good break?",
            "Back after a bit — hope it was relaxing.",
        ]),
        (28800, [
            "Welcome back! Been a few hours.",
            "Good to have you back — get some rest?",
            "You were gone a while. Everything okay?",
        ]),
        (86400, [
            "Welcome back! Missed you today.",
            "There you are — it's been most of the day!",
            "Glad you're back. Long day?",
        ]),
        (None, [
            "Okaeri! You were gone for a long time — welcome home.",
            "Welcome back! It's been over a day, I was starting to wonder.",
            "You're back! Feels like forever. Good to have you here again.",
        ]),
    ]

    GOODBYE_REPLIES = [
        "See you later!",
        "Take care — I'll be here when you get back.",
        "Bye! Come back soon.",
        "Itterasshai! Safe travels.",
        "Later! I'll keep the lights on.",
    ]

    def __init__(self):
        super().__init__()
        self._away_since: float | None = None  # timestamp of departure, None = user is present

    def input(self, ear: str, skin: str, eye: str):
        ear_lower = ear.lower().strip()

        if self._matches(ear_lower, self.BACK_WORDS):
            if self._away_since is not None:
                elapsed = time.time() - self._away_since
                self._away_since = None
                reply = self._pick_return_reply(elapsed)
                self.setVerbatimAlg(3, reply)
            # if they say hi but never said bye, just ignore (don't double-greet)

        elif self._matches(ear_lower, self.BYE_WORDS):
            self._away_since = time.time()
            self.setVerbatimAlg(3, random.choice(self.GOODBYE_REPLIES))

    # ------------------------------------------------------------------ helpers

    @staticmethod
    def _matches(text: str, word_set: set) -> bool:
        """True if any trigger word/phrase appears in the input."""
        return any(w in text for w in word_set)

    def _pick_return_reply(self, elapsed_seconds: float) -> str:
        for max_secs, replies in self.TIERS:
            if max_secs is None or elapsed_seconds < max_secs:
                return random.choice(replies)
        return random.choice(self.TIERS[-1][1])

    # ------------------------------------------------------------------ meta

    def skillNotes(self, param: str) -> str:
        if param == "notes":
            return (
                "Itekimase/Okaeri skill (English). Says goodbye when user leaves "
                "and welcomes them back with a reply scaled to how long they were away. "
                "6 tiers: <1min, 1-10min, 10-60min, 1-8hr, 8-24hr, 24hr+."
            )
        elif param == "triggers":
            return (
                f"Leave : {self.BYE_WORDS}\n"
                f"Return: {self.BACK_WORDS}"
            )
        return "note unavailable"

Above this line: explanation.

Below this line: what it enables.

---

3. What this skill does that LLMs can’t

Let’s break down why this tiny thing is a big deal.

3.1 Duration‑based greeting

The skill:

1. Detects when the user says something like “bye”, “see you”, “brb”, etc.
2. Stores the exact timestamp of that moment.
3. When the user later says “I’m back” (or similar), it:
   • Calculates how many seconds/minutes/hours passed
   • Picks a reply from the correct “time tier”
   • Sends a greeting that matches how long they were away

This requires:

• State (remembering they left)
• Time (knowing how long they were gone)
• Deterministic logic (same input → same behavior)

LLMs don’t have that.

They don’t track time.

They don’t maintain internal state between turns in a reliable, controllable way.

A Livingrimoire skill does.

---

3.2 Consistent behavior

The DiOkaeri skill is:

• Predictable
• Testable
• Repeatable

If you say:

• “bye” → it always logs the time and says goodbye
• “I’m back” after 2 minutes → it always picks from the same 1–10 minute tier
• “I’m back” after 5 hours → it always picks from the 1–8 hour tier

No “mood”.

No “sometimes it works, sometimes it doesn’t”.

No hallucinations.

LLMs can approximate this with clever prompting, but they can’t guarantee it.

---

3.3 Addable features (real extensibility)

Here’s where Livingrimoire really pulls away from LLM‑only setups.

Because DiOkaeri is a real skill, you can extend it with actual logic, for example:

• Weather reminders

  • “Don’t forget your umbrella, it’s going to rain.”
  • “It’s cold outside, grab a jacket.”

• Self‑care nudges

  • “While you’re up, grab some water.”
  • “Stretch your legs a bit.”

• Personality flavor

  • Cute: “Come back safe, I’ll guard the place.”
  • Stoic: “Understood. I’ll be here when you return.”
  • Tsundere: “Hmph. Don’t take too long… idiot.”

You’re not “prompt‑engineering” this.

You’re adding behavior.

LLMs can’t extend themselves.

They can only pretend.

---

4. Livingrimoire vs LLMs in one sentence

If I had to summarize the difference:

LLMs generate language.

Livingrimoire generates behavior.

LLMs are amazing at:

• Explaining things
• Rewriting text
• Brainstorming
• Acting as a flexible interface

But they are not:

• A state machine
• A scheduler
• A behavior engine
• A modular skill system

The Livingrimoire is.

---

5. Why this matters

Everyone wants “AI companions”, “agents”, “assistants”, “NPCs”, “waifubots”, whatever.

If you build them on LLMs alone, you hit walls:

• No real memory of time
• No guaranteed consistency
• No modular skills
• No real extensibility
• No way to test behavior like normal software

With a Livingrimoire skill like DiOkaeri, you get:

• Duration‑based greetings
• Consistent reactions
• Pluggable features (like umbrella reminders)
• A clear place to add more logic later

It’s a tiny example, but it proves the point:

This is something a Livingrimoire can do that an LLM alone cannot.

And once you see that, you stop trying to make prompts do the job of architecture.