
Weekend Creative Agent Challenge: QuestForge
I turned QuestForge, my AI-powered text adventure, into an always-on creative agent that generates a new adventure every morning before anyone opens the app.
Vision & What It Does
Last weekend, I built QuestForge, a browser-based AI text adventure where the player becomes part of an unfolding story.
The idea was simple: choose a genre, choose a character archetype, and start playing. The AI creates the story as you go, gives you choices, and reacts to what you decide to do.
But I didn't want QuestForge to feel like another chatbot that simply generates text and forgets everything a few messages later. I wanted the world itself to remember.
QuestForge keeps track of things like the player's health, gold, reputation, inventory, NPC relationships, and discovered secrets. If you betray a merchant early in the story, that decision can affect what happens later.
The main idea behind the project is:
The model writes the story. The application owns the state.
For this week's challenge, I took QuestForge one step further and turned part of it into an always-on creative agent.
QuestForge now has a Quest of the Day. Every morning, a scheduled AWS process runs without the player opening the application or clicking anything. It generates a completely new adventure, including a title, tagline, genre, archetype, and opening story, and saves it to DynamoDB.
When someone eventually opens QuestForge, today's adventure is already waiting for them.
That's what I liked about this challenge. Instead of making the user ask the AI to create something, I wanted the application to create something before the user even arrives.
How I Built It
The original QuestForge gameplay works through a simple loop.
A player selects a genre and character archetype and starts an adventure. When they make a choice, the backend loads the current game state from DynamoDB and sends the relevant context to the language model.
The model receives the genre and character information, the player's current stats and inventory, NPC relationships, a summary of the story so far, recent scenes, and the player's latest action.
It then generates the next part of the story and returns the available choices and any state changes.
I use OpenAI for the generation layer in this version. I had originally experimented with Amazon Bedrock, but I had already reached the Bedrock usage limit I was working with, so I used OpenAI to keep development moving. AWS still handles the infrastructure, compute, storage, scheduling, and application state.
The more interesting part for this challenge was adding the Daily Quest Agent.
I created a separate Lambda function specifically for generating the daily adventure. Amazon EventBridge Scheduler invokes this function every morning at 6:00 AM UTC. There is no frontend request and no player interaction involved.
The Lambda determines the day's theme, sends a generation prompt to OpenAI, receives the creative output, and saves the result to DynamoDB.
The frontend simply asks for the current daily quest when the application loads.
This means the expensive or slow creative generation doesn't happen when the player is waiting on the landing page. It already happened in the background.
The scheduled function looks roughly like this:
EventBridge Scheduler ↓Daily Quest Lambda ↓ OpenAI ↓ Generated Quest ↓ DynamoDB ↓QuestForge Landing PageThe schedule is defined as infrastructure rather than something I manually run:
DailySchedule:
Type: AWS::Scheduler::Schedule
Properties:
ScheduleExpression: cron(0 6 * * ? *)
FlexibleTimeWindow:
Mode: FLEXIBLE
MaximumWindowInMinutes: 15
Target:
Arn: !GetAtt DailyAgentFunction.Arn
RoleArn: !GetAtt DailyAgentFunctionDailyScheduleRole.ArnThe important part here is that the Lambda isn't waiting for a user to request a quest. EventBridge invokes it automatically, the result gets persisted, and the next player sees the result when they arrive.
That was the main change I wanted to make for this challenge: turning QuestForge from an application that responds to creativity requests into an application that creates something on its own.
AWS Services Used / Architecture Overview
QuestForge uses a serverless AWS architecture:
- AWS Amplify Hosting — hosts the React frontend and handles deployment from GitHub.
- Amazon API Gateway — provides the HTTP API used by the frontend.
- AWS Lambda — handles the game API as well as the Daily Quest Agent.
- Amazon DynamoDB — stores game sessions, player state, chapter history, and generated daily quests.
- Amazon EventBridge Scheduler — triggers the Daily Quest Agent automatically every morning.
- AWS Systems Manager Parameter Store — stores the OpenAI API key securely rather than hardcoding it into the application.
- OpenAI GPT-4o-mini — generates the interactive story content and daily creative quests.
The architecture is intentionally simple. AWS handles the infrastructure and orchestration, while the language model is responsible for the creative part.

The scheduled workflow runs through EventBridge Scheduler, invokes the Lambda automatically, and stores the generated quest in DynamoDB before it appears in the application.
What I Learned
The biggest thing I learned from this challenge is that an agent doesn't necessarily need to be complicated to be useful.
My first version of QuestForge waited for the player to make a request before anything happened. The new version flips that around.
EventBridge Scheduler triggers the process, Lambda handles the work, OpenAI generates the creative content, and DynamoDB stores the result. By the time the user arrives, something new is already waiting for them.
That made me think differently about what "always-on" actually means. It isn't just having an AI model behind an API endpoint. The important part is removing the need for the user to initiate the process.
I also got more comfortable working with scheduled AWS workloads and connecting them to an existing application without disrupting the original gameplay system.
Another lesson was keeping responsibilities separate. I don't rely on the language model to manage the game's actual state. The application handles health, inventory, reputation, and other game mechanics, while the model focuses on generating the creative content.
For me, that separation makes QuestForge much easier to reason about and gives me a better foundation to build on later.
Link to App or Repo
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article