Introduction
Large Language Models (LLMs) such as ChatGPT can do far more than simply chat or perform text‑processing tricks.
In this tutorial you will build an artificial‑intelligence‑powered game called “Guardian of History.”
The AI will act as the Game Master, controlling all interactions with the player. Because the AI responds to the player’s unique choices, every play‑through feels fresh and completely personalized.
This game is an entirely new game designed by the CreatiCode team. Here are some high-level explanations on how this game works:
-
Background — A villain has stolen a time‑travel machine and journeyed into the past to tamper with human history. They secretly “hijack” the mind of a historical figure, force that person to act differently, and thereby disrupt a major historical event.
-
Goal of the Game — The player is a “Guardian of the True Timeline.” To win, they must figure out who was hijacked and what action that person took under mind control. Once identified, the timeline can be repaired.
-
Helper Tool — The player has access to a time‑travel console named TESSA. TESSA can answer any question about the true or altered timeline — but it does not know the identity of the hijacked person either. That detective work is up to the player.
Here is a preview of the game play:
Besides being fun, this game strengthens historical knowledge, logical reasoning, and debugging skills as the player searches for clues in the altered past.
Tutorial Structure
This project leans heavily on widget blocks to build the game’s user interface (UI). Because coding the complete UI step‑by‑step would be extremely long, and our focus is really on the AI portion, you will start from a template project that already contains all non‑AI code.
The tutorial is split into two large parts:
- Part 1 A rapid walkthrough of the provided UI code. You will see how every sprite and block fits together so you can customize the visuals later if you wish.
- Part 2 A detailed, step‑by‑step guide for adding the AI logic. Here you will write and fine‑tune the complex prompts that power the game.
Part 1 - Starting Project Explained
This part will help you understand the code given in the starting project, so you can easily change it or extend it, and also you will understand how the AI related code fit into the flow.
1 - Remix the project template
You can find the project at this link:
play.creaticode.com/projects/682bc7628baa30c98a62551a
Please remix it into your own.
2 - The Stage and 3 Sprites
There are 4 components in this project:
- Stage: A static backdrop for the game.
- “Initial Screen” Sprite: Displays the initial screen when the game starts.
- “Game Screen” Sprite: Manages the in‑game chat window and buttons used during play.
- “AI” Sprite: Holds all the code that uses AI to run the game. This will be the focus of part 2.
3 - The Stage Backdrop
The stage only has one backdrop, which is composed of 3 layers:
- Background image — You can generate one with any AI image tool. After importing, convert it to vector mode.
- Title — A bold heading at the top reading “Guardian of History.”
- Semi‑transparent dialogue area — A see‑through rectangle in the middle where text will appear.
4 - Initial Screen Sprite - Show 3 Main Buttons
Now let’s look at the “Initial Screen” sprite. When the green flag is clicked, this sprite:
- Loads any saved game so the player may replay a previous mission.
- Shows an “Instructions” button that explains the rules.
- Shows a “New Game” button that asks the AI to create a brand‑new plot.
- Displays a “Replay Game” button only if a prior game was loaded successfully.
5 - Initial Screen Sprite - Handle the “Instructions” Button
When Instructions is clicked:
- A read‑only rich‑text box appears as an overlay.
- Its text is pulled from the variable
instructions, which is easy to fill with multi‑line content.
- A Back button is added under the text.
- Clicking Back removes both the overlay and the button.
6 - Initial Screen Sprite - Handle the “New Game” Button
When New Game is pressed:
- The player sees a label and a text box asking for an interesting historical event. This lets them tailor the adventure to any topic — maybe the French Revolution or the Space Race.
- For example, we might enter Invention of the Spinning Jenny (UK) in 1764.
- A “Generate New Game” button then appears. Clicking it instructs the AI to craft a unique plot using the chosen event.
7 - Initial Screen Sprite - Handle the “Generate New Game” Button
When the player clicks “Generate New Game”:
-
Saves the typed event in event input.
-
Clears every widget on screen and shows a single label that says “Creating game …”.
-
Broadcasts “generate new game” to the AI sprite and waits. The AI will eventually populate 3 key variables:
true history – contains the list of people involved in the given event in history.altered history – contains a list of events that lead to a different outcome in the altered history.game intro – a welcome paragraph that sets up the mission.
-
Stores true history, altered history, game intro, and event input so the game can be replayed later.
-
Removes all widgets because we are switching to the main game screen.
-
Broadcasts “start game” to let the “Game Screen” sprite take over.
8 - Initial Screen Sprite - Load the Saved Game Info
The “load saved game” block (run at project start) works like this:
- Retrieves
event input, true history, altered history and game intro from local storage.
- Extract the first line of
altered history into the variable hijacked person. This will be used as the final answer for checking against the player’s guess.
A real AI‑generated example of altered history looks like this, with the hijacked person’s action in the first line, followed by a series of chain reactions that lead to the disruption of the historical event:
1. Thomas Highs, instead of employing Hargreaves, decided to focus on improving his own weaving business and invested heavily in new loom technology.
2. Without Highs's support or workshop, James Hargreaves lacked the resources and collaborative environment to develop the spinning jenny efficiently.
3. Robert Kay's flying shuttle still increased yarn demand, but without the spinning jenny, the pressure fell on existing spinning methods, leading to yarn shortages and price increases.
4. John Wyatt and Lewis Paul's earlier spinning machine designs remained largely unexploited, as no other inventor stepped forward to significantly improve upon them.
5. Daniel Defoe's advocacy for textile innovation went unheeded, as the focus shifted to optimizing existing hand-spinning techniques rather than pursuing radical mechanization.
6. The textile industry experienced slower growth, with weaving outpacing spinning. This imbalance led to economic inefficiencies and delayed the onset of the Industrial Revolution in textile production.
7. Ultimately, the invention of the spinning jenny was significantly delayed, potentially allowing other countries or inventors to develop alternative solutions for increasing yarn production first.
9 - Initial Screen Sprite - Handle the “Replay Game” Button
Because the variables were already loaded, pressing Replay Game simply removes the current widgets and broadcasts “start game.” No AI call is necessary.
10 - Game Screen Sprite - Responding to “start game”
Now let’s switch to the “Game Screen” sprite. When it receives the “start game” message:
- Clear the “messages” list, which keeps a running log of player/AI chat.
- Run the “add chat” block to add a chat window.
- Run the “add command buttons” block to insert three action buttons below the chat.
- Run the “add input box” block to prepare a hidden overlay for player text entry.
The finished game screen initially looks like this:
11 - Game Screen Sprite - “add chat”
Within add chat the sprite:
- Adds the chat window.
- Covers the chat’s own input area with a blank label. (We supply our own input dialogue later, which is more reliable than asking the AI to guess each message’s purpose.)
- Inserts
game intro as TESSA’s very first message.
- Saves that same message in the
messages list.
If you run only add chat, the screen would appear like this:
12 - Game Screen Sprite - “add command buttons”
This block simply drops three buttons onto the bottom edge:
13 - Game Screen Sprite - “add input box”
This custom block creates—but immediately hides—a reusable overlay dialogue. It contains:
- A purple label that darkens the background.
- A read‑only textbox that shows a short instruction.
- A second textbox where the player will type their command.
- Two buttons: Cancel and Send.
If you displayed them without hiding, they would look like this:
14 - Game Screen Sprite - “show command input”
This helper toggles the visibility of the overlay input box:
- If
visible = 1, every widget is shown and the input textbox is cleared.
- If
visible = 0, the five widgets are hidden.
15 - Game Screen Sprite - Handling the “True History” Button
Clicking True History (factbutton) does three things:
- Sets a variable
current mode to “check true history.”
- Changes the instruction text so the player knows they should ask about the original timeline.
- Calls
show command input (1) to reveal the overlay.
It would look like this:
16 - Game Screen Sprite - Handling the “Altered History” Button
Clicking Altered History (querybutton) follows the same logic, but the instruction now asks about the altered timeline:
17 - Game Screen Sprite - Handling the “Guess” Button
Pressing Guess changes the instruction to tell the player they must name the hijacked person and the altered action:
18 - Game Screen Sprite - Handling the “Cancel” Button
If a player opens the overlay but clicks Cancel, show command input (0) hides the dialogue box. Nothing else happens.
19 - Game Screen Sprite - Handling the “Send” Button
When Send is clicked the sprite:
- Calls
show command input (0) to hide the overlay.
- If the input box is blank, it exits — identical to pressing Cancel.
- Otherwise it appends the player’s message to the chat.
- Inserts a placeholder response “…” from TESSA so the user knows the AI is thinking.
- Broadcasts “handle command” to the AI sprite and waits.
- Replaces “…” with whatever text the AI stores in the variable
command result.
- If
command result reads “You won”, then the player guessed correctly. The three command buttons are hidden so the conversation ends.
- If the player has not won, both the player’s message and TESSA’s answer are appended to the
messages list.
- If the “messages” list becomes too long (more than 31 messages logged), then trim it by removing the 2 oldest messages at the beginning.
20 - AI Sprite - Placeholders for Now
Finally, let’s peek at the AI sprite. It currently reacts to only two broadcasts:
-
“generate new game” – It must invent a full storyline (hijacked person, true history, altered timeline) based on the historical event the player typed. It also needs to compose the introductory game intro.
-
“handle command” – Depending on current mode, the sprite will run exactly one of three blocks:
- query true history – Answer a question about the original timeline.
- check altered history – Answer a question about the sabotaged timeline.
- submit a guess – Judge whether the player’s guess is correct.
We will build these blocks — complete with robust prompts — in Part 2.
Part 2 - Step‑by‑Step Guide for Adding the AI Logic
Now that you have a solid grasp of the player experience and the template code, it is time to fill in the missing AI pieces.
Throughout this section, we will iteratively craft long, detailed prompts and apply best‑practice techniques (including the T.I.R.E. prompting method) so the AI consistently produces correct and interesting replies.
Step 1 - Generating the “true history”
When the AI sprite receives the broadcast “generate new game,” it must invent an entirely new plot.
The only input available is the player’s event input, for example — “Invention of the Spinning Jenny (UK) in 1764” or “The Declaration of Independence.”
From that single line, the AI must output 2 items: what happened in the true history and how that’s disrupted in the altered timeline.
Let’s focus on the true history first. It is simply a list of key historical figures closely related to the event specified by the player. For some events, these people might be well documented. However, if the player has specified a less well-known event, the AI might have to “invent” some people to create a complete story.
For a simple start, we can try this:
Note: Use the LLM reporter rather than ChatGPT — the LLM block is more suitable for complex tasks.
And here is a likely output in the console panel:
Okay, here are some people whose actions were important leading up to the invention of the Spinning Jenny in 1764:
* **John Kay:** His invention of the flying shuttle in 1733 significantly sped up the weaving process. This created a demand for more yarn, which, in turn, spurred innovation in spinning technology.
* **Lewis Paul and John Wyatt:** They patented a roller spinning machine in 1738 and 1748. Although their inventions weren't commercially successful, they demonstrated the potential for mechanized spinning and inspired later inventors.
* **James Hargreaves:** As the inventor of the Spinning Jenny, he is the person most directly responsible for its creation. His personal experience as a weaver likely informed his understanding of the need for a better spinning solution.
Before continuing to the next step, try running these blocks a few times to observe any issues. You should try different “event input” as well.
Step 2 - Adding Some Instructions
Here are some issues with the blocks added above:
-
There are often unnecessary sentences before or after the list, such as “OKay, here are …” or “If you need anything else, let me know …”. These are often called “pleasantries.” They are meant to make a chat message more natural, but since we are not in a chat, they become unnecessary.
-
The output list often only contains 3 to 4 people. We need more people to create a rich story.
Now, can you try to refine this prompt by adding some instructions for the output?
For a hint, you can build a longer prompt by joining 2 or 3 variables like this:
Here is an example of a refined prompt in 3 parts:
## Task
Generate a list of 6 most important people in history whose actions directly led to this event:
- Part 2: The variable
event input (note that you need to run the game at least once to populate this variable with an event)
## Instructions
* If historical records are incomplete, invent plausible figures to fill gaps in the story.
* Briefly explain each's role in the event.
* You must assign a name in English for each person.
* Avoid all pleasantries. Only return the list and say nothing else.
Here are the blocks:
Important observations:
-
We are asking the AI to list exactly 6 people to ensure the true history is not too short or too long.
-
We encourage the AI to “invent” some people if the event is not well-documented.
-
The ## headings make it easy for the AI to locate relevant instructions.
-
The event input is a dynamic component that will be provided by the player, which makes the game highly customizable. For this tutorial, please keep using the default value of “Invention of the Spinning Jenny (UK) in 1764” as an example.
-
We require the AI to “avoid all pleasantries” and only output the list. If you did not include this, most likely you will get unnecessary sentences before or after the list.
When you test run this script, the output in the console may look like this:
* **James Hargreaves:** Inventor of the Spinning Jenny.
* **Thomas Highs:** Possible early inventor of a similar spinning machine.
* **Robert Kay:** Inventor of the flying shuttle, which increased demand for yarn.
* **John Kay (of Bury):** Improved upon the carding process, preparing cotton fibers for spinning.
* **Daniel Defoe:** Writer whose observations highlighted the existing domestic system of textile production and the need for efficiency.
* **Lydia Bancroft:** A skilled weaver whose efficiency highlighted the disparity between yarn production and weaving capacity.
Try to run this new stack a few times, and observe how the list changes. You will find that people on top of the list usually don’t change much, but the remaining people may change between runs.
Step 3 - Generating the “altered history”
Next, we need to generate an altered history based on the true history above. The idea is to randomly pick a person from the list as the person to be “hijacked”, and ask the AI to change that person’s action to disrupt the historical event. We will need a list of chain reactions that lead to the disruption of the historical event.
Now try to add code to generate this altered history. You can use the LLM block to “continue” the conversation above, so you don’t have to repeat the event or true history again.
Here is an example implementation:
We start by asking the AI to “imagine person X from the list was hijacked by a time traveler to disrupt the event”, and X can be a random number between 2 and 6. We did not include the first person, since that’s almost always the main character of the event, and it would be too easy to guess.
Next, we specify the task and instructions. The complete text for prompt2 is:
from the list was hijacked by a time traveler to disrupt the event.
## Instructions
* Only output a list of chain reactions, starting with that person's action and continuing with how other people may react and how the event was disrupted.
* The first line must be what the hijacked person did
* Never mention what happened in the original history. Describe the updated events as if they actually happened in history.
* Avoid any pleasantries and say nothing else except the list of chain events
## Output Format Example
1. Isaac Newton walked away from the apple tree, so he ignored apples falling from trees.
2. ...
A few important details:
-
The text starts with a SPACE before “from the list”, so that there is a space after the random number when they are joined.
-
We emphasize that the first line must be about the hijacked person since we are extracting that into the variable hijacked person, which will be the game’s final answer.
-
We also include an example output to further make sure the output starts with the action of the hijacked person. This is the “E” part in the T.I.R.E. method.
Here is an example output:
1. John Kay sabotaged the carding machines in his region and spread misinformation about their reliability.
2. Textile producers became wary of using carding machines, preferring manual methods of preparing cotton fibers.
3. James Hargreaves struggled to find a reliable supply of prepared cotton for his Spinning Jenny prototype.
4. Robert Kay's flying shuttle was not as effective due to the uneven quality of hand-carded yarn.
5. Daniel Defoe documented the continued inefficiency of textile production, blaming the unreliable fiber preparation methods.
6. Lydia Bancroft's weaving speed was limited by the inconsistent quality of yarn, reducing overall output.
7. The Spinning Jenny's adoption was slowed by the lack of efficiently prepared cotton, hindering its impact on textile production.
Again, run this part of the code a few times, and notice when different people are chosen as the hijacked person, the timeline varies quite a lot.
Step 4 - Generating the Opening Message (“game intro”)
TESSA’s first message should greet the player, summarize the danger, and invite questions—no more than ~80 words. We again build a three‑part prompt:
- Part 1 — fixed text introducing TESSA and the disrupted event (see below).
- Part 2 — the dynamic
event input.
- Part 3 — instructions demanding a concise, markdown‑formatted greeting.
For example:
You are TESSA, a robot in a time-travel detective game. A rogue time traveler has gone back to the past to secretly take over a real person. This person was not famous, but they did something different, changing history in a big way.
The player is a guardian protecting the actual history. With your help, the player will discover which person was taken under control and what they did.
Through you, the player can ask about what happened in the original and altered history, so that the player can discover the rogue traveler.
So far, you know the rogue agent aims to sabotage this event:
---
---
Now, please generate a short greeting message within 80 words to the player explaining the situation and ask the player to ask questions to catch the rogue traveler.
Use a markdown format to emphasize key information.
Note that we are asking the AI to use the markdown format, which usually makes the output easier to read. This is important, since this game is mostly presented by chat messages, it will be exhausting if the player has to read big chunks of text.
Below is the code for composing this 3-part prompt and send it to AI:
Note that we are using a “new chat” session type. Since all the information is included in the current prompt, the AI does not need any previous messages to generate the new message.
After this step, when the player generates a new game, they will be greeted with a new message like this:
Step 5 - Handling Query on the True Timeline
Next, let’s address the player’s question about what actually happened. This will be a complex prompt that we can develop in a few steps.
For an initial version of the prompt, let’s keep it relatively simple:
- Explain how the game works and the key event
- Tell the AI that its task is to answer the player’s question
Please add code to “query true history” to compose the prompt above and query the AI. You can test with this question: “Who invented the Jenny?”
Based on the discussion above, this prompt will contain 5 parts:
You are TESSA, an AI time machine in a time-travel detective game: a bad time traveler has gone back to the past, secretly taken over a real person to alter their action. The player's job is to guess which person was hijacked and what change in action was made.
Specifically, the current game plot is about protecting the truth of this event:
## Task
Your current task is to answer a question about the true history from the player:
- Part 4: the variable “
player input”, which contains the question.
Below is the code to compose these 4 parts into the prompt and query the AI:
Here is an example response we get:
Step 6 - Adding Recent Messages for Context
When answering player questions, we are doing something very different: we always choose the “new chat” session type instead of “continue”.
Here is why. When we use the “continue” type, the CreatiCode server will help save all the messages between the user and the AI, and automatically attach them to the next request, so the AI model understands the context.
However, for this project, there may be hundreds of messages between the player and the AI, so soon there will be too many messages in the context, and the AI model won’t be able to handle them anymore.
Therefore, we are going to use the “new chat” type and provide the most recent messages ourselves in each request. The benefit is that the player can keep chatting forever if they want to. However, since only the most recent conversation is saved, the AI model will not “remember” earlier messages, though the player can still check them in the chat window themselves.
To insert the recent messages into the prompt, we can insert another section into our prompt:
Note that when we use “messages” as a reporter, it will join all the items in that list as one text.
The value of “prompt2” above is the following:
## Recent Messages
For context, here is the most recent conversation between you and the player:
We can test it by asking 2 questions one by one:
- “Who invented the Jenny?”
- “How old was he in 1764?”
Because we are inserting the messages into the prompt, the AI model can infer “he” refers to “James” in the second question:
Step 7 - Adding the True History as Refrence
Although we can simply make the AI answer these questions based on its existing knowledge of the actual history, it is better to “ground” it with the “true history” we have generated earlier. This way, it will generate consistent answers, and it will automatically include these key people in its answers, which can serve as clues for the player.
To do that, we can insert these blocks when composing the prompt for the true history:
The content of the “prompt2” is the following:
## Reference
Some additional details related to the event that you can use as reference:
Step 8 - Output Instructions
Although our code works for basic questions, there are a few issues that need to be addressed:
- It may include unnecessary pleasantries.
- It might be “too eager to help” and leak the secret identity of the hijacked person.
Therefore, we need to add a new section “Output Instructions” to improve the output. This prompt can be refined over time, but here is a good starting point:
## Output Instructions
Now return the answer as if you are talking to the player directly.
* Always assume the player is asking about the true history.
* Try to include other people from history in your answer besides the reference to make it harder to guess who are important.
* Be concise. No need for pleasantries. Just answer directly.
* If the player's question is not clear, you can ask a clarifying question instead.
* Use markdown format to organize your answer to make it concise and easy to understand.
* For any questions on the rogue traveler, say they have no impact on the true history.
* For questions on who was hijacked or what was changed, say you have no information.
* Reject inappropriate inputs.
This section can be inserted like this:
Step 9 - Handling Questions about the Altered History
The logic for answering questions about the altered history is actually very similar to that for the true history.
Can you give it a try first? Duplicate the blocks from the “query true history” block into the “query altered history” block, then make all necessary changes.
Here are the blocks you need:
The changes are:
- For “Task”, it needs to be updated like this:
## Task
Your current task is to answer a question about the altered history from the player:
## Altered History
The following events happened in the altered history. You should base your answers on these events instead of the actual history:
- For “Output Instructions”, you need to specify that the answers should be about the altered history:
## Output Instructions
Now return the answer as if you are talking to the player directly.
* Always assume the player is asking about the altered history.
* Use the reference to help you answer, and fill in more details and bridge any gaps to make your answer logical and consistent as if they really happened. You can add additional people in the explanations, so long as they make sense.
* Be concise. No need for pleasantries. Just answer directly.
* If the player's question is not clear, you can ask a clarifying question instead.
* Use markdown format to organize your answer to make it concise and easy to understand.
* For questions on the rogue traveler, who was hijacked or what was changed, say you have no information.
* Reject inappropriate inputs.
Try a few questions on the altered history. Do you see any issues?
Step 10 - Enhancing the Output Instructions
One obvious and serious issue is that the AI is “too eager to share”. For example:
This is a critical issue. If the AI keeps spilling out clues like this, the game will be boringly easy to play.
To make the game more challenging, we need to force the AI to say less. Here are some new instructions we can add:
## Output Instructions
Now return the answer as if you are talking to the player directly.
* Always assume the player is asking about the altered history.
* * Use the reference to help you answer, and fill in more details and bridge any gaps to make your answer logical and consistent as if they really happened. You can add additional people in the explanations, so long as they make sense.
* Be concise. No need for pleasantries. Just answer directly.
* If some event did not occur in the altered history, say it did not happen without explaining why.
* Avoid explaining why some event happend and avoid offering extra facts unless you have to.
* Be secretive and respond with the **minimum info**. Make it hard for the player to guess the hijacked person.
* If the player's question is not clear, you can ask a clarifying question instead.
* Use markdown format to organize your answer to make it concise and easy to understand.
* For questions on the rogue traveler, who was hijacked or what was changed, say you have no information.
* Reject inappropriate inputs.
After this change, the answer is less helpful (which is good):
Of course, this prompt can still be improved over time as you test with more events and questions.
Step 11 - Evaluating Player’s Guess
For the last part, we need to check if the player’s guess is correct. To do that, we need to explain the game to the AI, and ask the AI to compare the player’s guess against the secret information on the hijacked person. To avoid leaking any information by accident, we will simply make the AI respond with one word: “correct”, “partial” or “wrong”.
You can start by duplicating the blocks from “handle altered history”, and then updating the blocks/variables:
Here is an example solution:
The changes:
## Task
Your current task is to check if the player has guessed correctly who the hijacked person is and what they did to sabotage the event above. Here is the player's input:
## Output Instructions
Return a single word "correct", "partial" or "wrong" by comparing the player's input and the secret information below.
* Return "correct" if the player guessed the hijacked person's name, and is pretty close on what that person did to sabotage the key event.
* Return "partial" if the name was guessed correctly, but the action description is missing or far off.
* Return "wrong" if the name was not guessed correctly.
Step 12 - Converting the One‑Word Verdict into Friendly Feedback
Players deserve a human‑readable reply. In the Game Screen sprite, intercept the raw AI verdict and swap it for a nicer message:
Demo
That’s all the steps needed to complete a basic version of the game. Here is what it looks like in action:
Additional Challenges
Below are some creative extensions you can try to make the game more advanced, interesting, or accessible. These tasks are optional but highly recommended as practice to deepen your understanding of AI behavior and game design.
-
Refine the Prompts: Thoroughly test the game and look for bugs, inconsistencies, or loopholes. Then refine the AI prompts to fix those issues. For instance, if the player can easily trick the AI into revealing the correct answer, that would ruin the challenge, so make sure the prompts explicitly tell the AI not to leak any secret information unless asked directly.
-
Add Difficulty Levels: Let players choose a difficulty level when starting a new game. You can increase the challenge by having the AI generate more people involved in the event, so instead of 6 possible suspects, you might have 10 or even more. This adds complexity and makes guessing correctly much harder.
-
Add a Hint Button: For players who are younger or not familiar with history, the game may be too difficult. To help them out without spoiling the answer, you can add a fourth button labeled “Hint” on the game screen. When clicked, the AI can provide a small clue—such as a general time range, region, or a short list of suspicious individuals—that nudges the player in the right direction while still preserving the mystery.
-
Enable Conversations with Historical Characters: Currently, the player can only talk to TESSA to ask questions about the timeline. A major upgrade would be to allow the player to “mentally travel” into the timeline and speak directly with people from that era. You can implement this by asking the AI to role-play historical figures based on the time period and context. This will make the investigation more immersive, like interviewing eyewitnesses in a mystery story.
Tip: You could make the AI generate a different welcome message every time, but that would slow things down.
If the tab already exists, this block will do nothing — which is exactly what we want.
For example, if today is Wednesday, the “current day of the week” block will return 
