AWS Builder Center
Weekend Creative Agent Challenge: MoodVerse — An AI Agent That Turns Weather into Poetry

Weekend Creative Agent Challenge: MoodVerse — An AI Agent That Turns Weather into Poetry

MoodVerse is an always-on creative AI agent that transforms real-world weather into a fresh poem every day. Using Amazon Bedrock Nova Lite, AWS Lambda, EventBridge Scheduler, and DynamoDB, the agent automatically checks the weather, maps it to a mood, selects a creative spark word, generates a short poem, and stores it for users to discover. This project explores how autonomous, event-driven AI can create personalized and creative experiences without requiring constant user interaction.

Weekend Creative Agent Challenge:

MoodVerse — An Always-On AI Agent

That Turns Weather into Poetry

What if an AI agent could create something new every day without anyone having to ask it to?
For this week's Weekend Creative Agent Challenge, I extended MoodVerse into an always-on creative agent that combines real-world weather, generative AI, and serverless AWS services to create a new weather-themed poem every day.
Instead of waiting for a user to provide a prompt, MoodVerse Agent runs automatically on a schedule, checks the current weather, transforms that information into a mood, selects a creative spark word, generates a poem, and stores the result. When a user opens the application, the latest poem is already waiting for them.

Vision & What MoodVerse Agent Does

The idea behind MoodVerse Agent was to explore a different approach to generative AI applications: what if the AI could proactively create something instead of simply responding to a request?
The problem I wanted to solve was simple — creative content often requires someone to initiate the interaction. MoodVerse removes that step by making the creative process autonomous.
Once a day, the agent performs the following workflow:
  1. Checks the current weather for a fixed location.
  1. Maps the weather condition to an appropriate mood.
  1. Selects a random "spark word" to add an element of surprise.
  1. Sends the mood and creative context to Amazon Bedrock Nova Lite.
  1. Generates a short weather-themed poem.
  1. Stores the generated poem in Amazon DynamoDB.
  1. Makes the latest poem available through the web application.
For example, rain can lead to a cozy mood, thunderstorms can create a mysterious atmosphere, and clear skies can inspire something cheerful.
The application also retains the original on-demand functionality, allowing users to manually generate a poem using their own mood and spark word.
The result is an application where something new can be waiting every day — without requiring the user to click a "Generate" button first.

How I Built It

I built MoodVerse Agent by extending the serverless architecture from my previous MoodVerse project.
The main design decision was to make the agent event-driven and serverless. Rather than running a continuously active server, I used Amazon EventBridge Scheduler to trigger an AWS Lambda function once every day.
The scheduled Lambda function acts as the core of the agent. It retrieves weather information from Open-Meteo, a free public weather API that doesn't require an API key. It then maps the weather condition to a predefined mood and chooses a random spark word.
The resulting context is sent to Amazon Bedrock Nova Lite, which generates the poem. Once the poem is generated, the agent stores it in DynamoDB.
I designed the DynamoDB storage around two types of keys: a fixed  latest  item and dated archive items. This means the frontend can retrieve the current poem using a simple  GetItem  operation instead of scanning or querying the entire table.
The application uses three Lambda functions:
  • Agent Lambda — runs on schedule, fetches weather, generates the poem, and stores it.
  • Get Latest Lambda — retrieves the most recently generated poem.
  • Generate Lambda — handles manual poem generation based on a user's selected mood and spark word.
This separation keeps each function focused on a specific responsibility.
One useful development decision was making the scheduled agent independently testable. Instead of waiting for the daily schedule during development, I could manually invoke the agent Lambda and immediately verify the generated poem in DynamoDB.

AWS Services & Architecture

The application uses the following AWS services:
  • Amazon Bedrock (Nova Lite) — generates the weather-themed poems.
  • AWS Lambda — provides the serverless backend and runs the agent logic.
  • Amazon EventBridge Scheduler — triggers the creative agent once per day.
  • Amazon DynamoDB — stores the latest poem and the historical daily archive.
  • Amazon API Gateway — exposes HTTP endpoints for the frontend.
  • AWS Amplify — hosts the web frontend and provides deployment automation.
  • AWS IAM — controls permissions between the Lambda functions, Bedrock, and DynamoDB.
  • Amazon CloudWatch — supports monitoring and debugging of the serverless application.
The overall architecture can be summarized as:
EventBridge Scheduler → Agent Lambda → Weather API → Amazon Bedrock → DynamoDB
For the user-facing experience:
Browser → Amplify → API Gateway → Lambda → DynamoDB
The scheduled agent and user-facing API are therefore independent. The agent can generate content in the background, while the frontend simply retrieves whatever content is already available.
This creates a lightweight, fully serverless architecture without requiring a continuously running backend.

What I Learned

One of my biggest takeaways from this challenge was understanding that an AI agent doesn't necessarily need to be a complex system with many tools or a conversational interface. An agent can also be designed around autonomous action, external context, decision-making, and scheduled execution.
I learned how EventBridge Scheduler can trigger Lambda on a recurring schedule without requiring additional infrastructure. This made the "always-on" behavior of MoodVerse possible while keeping the architecture simple and cost-conscious.
I also learned more about designing DynamoDB access patterns before designing the data structure. Using a fixed  latest  key means the frontend can retrieve the current poem directly rather than performing an expensive scan.
Another useful lesson was integrating external real-world data into a generative AI workflow. Open-Meteo provides the weather context, while Bedrock transforms that structured information into creative output. This showed me how combining deterministic data with generative AI can produce more contextual experiences.
Finally, I gained more experience thinking about automation and asynchronous workflows. Instead of treating AI as something that only responds to a user request, I started thinking about how AI can proactively perform useful or creative tasks in the background.

Final Thoughts

MoodVerse Agent started with a simple question:
Can an AI application create something meaningful before the user even asks for it?
The result is a small experiment in autonomous creative AI. Every day, the weather becomes the starting point for a new creative experience. The agent handles the entire process — from gathering context to generating and storing the final poem.
Building this project helped me explore how generative AI, event-driven architecture, external data, and serverless AWS services can work together to create an application that feels alive rather than simply reactive.
The project is intentionally simple, but that simplicity is what makes the concept interesting. It demonstrates that autonomous AI experiences don't always need complicated infrastructure. Sometimes, a scheduled function, a little real-world context, a foundation model, and a creative idea are enough to build something new.

Try MoodVerse Agent

Live Application:  MoodVerse — Live Demo 
Source Code:  MoodVerse on GitHub 
#agents #AWS #AmazonBedrock #GenerativeAI #Serverless #AWSLambda #EventBridge #DynamoDB #AWSAmplify #CreativeAI
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