AWS Builder Center

Weekend Creative Agent Challenge: Mystery Drop

What if a new mystery appeared every morning without you asking for it? Mystery Drop is an autonomous creative agent built with AWS Lambda and Amazon Event Bridge Scheduler. Every day, it automatically creates a fresh fictional mystery with suspects, clues, questions, and a hidden solution. In this article, I share how I built it, how the automation works, and how AWS enables creativity to happen without manual input.

Turning Ideas into Life | AI & Cloud Builder | Data Science Student

Vision & What It Does

What if you could come back every morning and discover that a mystery had been created while you were away?
That is the idea behind Mystery Drop, an autonomous creative mystery-generation agent designed for the AWS Builder Center Weekend Creative Agent Challenge.
Most creative applications are interactive: a user opens the application, enters a prompt, presses a button, and waits for the result. Mystery Drop takes the opposite approach. The user doesn't need to open an application or provide a prompt every day. Instead, the agent wakes up automatically on a schedule and creates a brand-new fictional mystery on its own.
Every Mystery Drop case contains a unique case ID, title, location, incident, suspects, clues, central question, and hidden solution. The mysteries are generated procedurally by combining different story themes and narrative elements while maintaining a structured mystery format.
A typical mystery might begin with a strange event such as a locked room containing an object that could not possibly have entered it. The agent then creates suspects, clues, and a final explanation that gives the reader enough information to investigate the case.
For example:
MYSTERYDROP — The Missing Letter in the SafeAt exactly 11:42 PM, a sealed envelope appeared inside a locked room. Nobody entered the room, the security camera recorded continuously, and yet the evidence suggested that someone had been there.
The goal isn't simply to generate random text. Mystery Drop creates a complete little investigation that the user can discover and solve.
The most important part is that the user doesn't initiate each mystery. Amazon Event Bridge Scheduler automatically invokes the Lambda function according to the configured schedule. Event Bridge Scheduler supports recurring schedules and invokes Lambda asynchronously, making it well suited for this unattended workflow.

How I Built It

I intentionally kept Mystery Drop extremely lightweight.
Instead of building a large application with a database, API, frontend, and multiple integrations, I focused on the core idea of an always-on creative agent.
The first component is an AWS Lambda function running Node.js. Lambda contains the creative generation logic and doesn't require any external packages, API keys, databases, or environment variables.
The Lambda function contains collections of narrative elements such as mystery themes, locations, suspects, unusual events, objects, clues, and possible explanations. When Lambda executes, it selects and combines these elements to construct a new mystery.
Each execution creates a unique case ID based on the execution date and time. The function then produces the complete mystery and logs it to CloudWatch.
One of the biggest design decisions was deliberately avoiding unnecessary infrastructure. I initially considered a more complicated architecture involving additional AWS services, but that would have added deployment complexity without improving the core challenge requirement.
The final design focuses on one important question:
Can my application create something creative automatically while I'm away?
The answer is yes.
I also added detailed logging to make the autonomous behavior easy to demonstrate. Each execution logs the invocation time, event source, case ID, selected theme, number of clues, number of suspects, generated title, complete mystery, and completion status.
For testing, I first invoked Lambda manually to make sure the creative engine worked correctly. The successful test generated a complete case titled “The Missing Letter in the Safe”, with three suspects and four clues.
After verifying the Lambda function, I connected it to Amazon Event Bridge Scheduler. The scheduler is configured to invoke the Lambda automatically on a recurring daily schedule.
This separation made debugging much easier: first I verified the creative engine, then I verified the autonomous scheduling mechanism.

AWS Services Used

Mystery Drop intentionally uses a very small AWS architecture.

AWS Lambda

AWS Lambda runs the Mystery Drop creative engine.
It:
  1. Receives the scheduled invocation.
  1. Generates a unique case ID.
  1. Selects a mystery theme.
  1. Creates the story.
  1. Generates suspects and clues.
  1. Creates the investigation question.
  1. Produces the hidden solution.
  1. Logs the complete result.

Amazon Event Bridge Scheduler

Event Bridge Scheduler is responsible for making the application autonomous.
Instead of waiting for me to click the Lambda Test button, the scheduler invokes  MysteryDropAgent  automatically according to its recurring schedule. AWS documents Event Bridge Scheduler as a serverless scheduler capable of recurring rate-based invocations of Lambda.

Amazon CloudWatch Logs

Lambda automatically sends its execution logs to CloudWatch. I use those logs as evidence that the agent executed and generated creative output.

Architecture

DAILY SCHEDULE │ ▼ ┌─────────────────────────┐ │ Amazon EventBridge │ │ Scheduler │ └────────────┬────────────┘ │ │ automatic invocation ▼ ┌─────────────────────────┐ │ AWS Lambda │ │ MysteryDropAgent │ │ │ │ Creative Generator │ └────────────┬────────────┘ │ ▼ ┌─────────────────────────┐ │ Generated Mystery │ │ │ │ • Case ID │ │ • Story │ │ • Suspects │ │ • Clues │ │ • Question │ │ • Solution │ └────────────┬────────────┘ │ ▼ ┌─────────────────────────┐ │ CloudWatch Logs │ │ Execution Evidence │ └─────────────────────────┘
The architecture is intentionally small: the application only needs Lambda and Event Bridge Scheduler for its core functionality.

What I Learned

The biggest lesson from building Mystery Drop was that an autonomous agent doesn't necessarily need to be complicated.
My initial instinct was to add more services and more infrastructure. However, the challenge helped me focus on the actual behavior I wanted to demonstrate: something useful or creative happening without a person initiating every run.
I learned how to deploy a Node.js Lambda function, configure its execution role, test Lambda through the AWS Console, inspect CloudWatch execution logs, and connect Lambda to Amazon Event Bridge Scheduler.
I also learned the difference between a normal application workflow and an autonomous workflow.
A normal creative application might look like:
User ↓Open App ↓Enter Prompt ↓Click Generate ↓Creative Output
Mystery Drop works differently:
Time ↓EventBridge ↓Lambda ↓Creative Generation ↓New Mystery
That change in architecture completely changes the user experience. The user doesn't have to remember to use the application. The application simply does its job and creates something new.
I also learned the importance of designing for evidence. An autonomous application isn't very convincing if you only say that it runs automatically. The Event Bridge schedule and CloudWatch logs provide visible evidence of the scheduled execution and generated output.
Most importantly, this challenge taught me that simplicity can be a feature. Instead of building a huge system, I built a tiny autonomous creative engine that has one clear purpose: create a new mystery while I'm away.

Repository

MysteryDrop/│├── index.mjs├── README.md└── DEPLOYMENT.md
The repository contains the source code and deployment instructions for the Mystery Drop autonomous creative agent.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article