
Weekend Creative Agent Challenge: The Weather Muse
An always-on agent that paints and writes something new every day, built with AWS Lambda, Amazon Bedrock
The Problem With Most Creative Apps
Most creative apps wait for you. You open them, type a prompt, click generate, and then close the tab. That is a perfectly fine pattern, but it is not the most interesting one. The AWS Builder Center Weekend Challenge asked a different question: what if the best tool is the one you never have to open?
That single sentence changed how I thought about the project. Instead of building another prompt box, I built an agent that has no button at all. It wakes up once a day, looks at the weather, and quietly makes something. By the time I check on it, the work is already done.
I call it The Weather Muse.
Vision: What The Weather Muse Does
The Weather Muse is a small autonomous agent that writes one short poem every day, themed on the real weather in a fixed location. It does this without anyone asking it to.
Here is the daily loop, in plain terms:
- Check today's weather using a free weather API.
- Pick the next writing style from a rotating list, so the tone of the output slowly changes over time instead of repeating itself.
- Ask Amazon Nova Micro to write a short four line poem that matches the weather, the day, and the current style.
- Save the poem to a public gallery page. The problem it solves is a small but real one. Most of us walk past the weather every day without really noticing it. This agent notices it for you, and turns that noticing into a few lines you can actually read. Over weeks, the gallery becomes a kind of written diary of a place, one entry per day, drifting slowly through different tones.
Painting an artwork to go with each poem is on the roadmap. I am leaving the image generation step for a future version so this first release stays small and easy to reason about. More on that in the trade-offs section below.
Prerequisites
Before you try to build or run something like this yourself, here is what you need:
- An AWS account. Free Tier is enough to run this comfortably.
- Bedrock model access enabled for Amazon Nova Micro in your target region. This is a one time request in the Bedrock console and is usually approved instantly.
- Terraform version 1.5 or newer installed locally.
- AWS CLI configured with credentials that can create IAM roles, Lambda functions, S3 buckets, and EventBridge schedules.
- Basic comfort reading Python, since the agent's logic lives in one Lambda function.
How I Built It
I gave myself one constraint from the start. The whole thing had to come up with a single terraform apply. No console clicking, no manual setup steps left for later, no glue scripts I would forget about. That constraint shaped almost every decision.
Step 1: Solve the "always-on without a server" problem
An agent that runs all the time sounds like it needs a server running all the time. It does not. I used Amazon EventBridge Scheduler to call a Lambda function once a day. The agent does not exist between runs. It simply appears, does its work in a few seconds, and disappears again. This is what "serverless" actually buys you here: real autonomy without a bill for idle time.
Step 2: Give the agent a brain
The entire decision making logic lives in one Python 3.12 Lambda function. On each run it:
- Calls the Open-Meteo weather API (a free service that needs no API key) for a fixed latitude and longitude.
- Builds a text prompt combining today's weather, the day of the week, and the next tone in a rotation list such as calm and reflective, playful, melancholic, hopeful, and stormy.
- Calls Bedrock's Converse action for Amazon Nova Micro (a small, fast text model) to write the poem.
Nova Micro uses a simple, chat style
messagesarray, which made this part of the build genuinely quick. Most of my time went into shaping the prompt so the poem actually felt tied to the weather instead of reading generic, which turned out to matter more than the API call itself.
Step 3: Give the agent a memory, without a database
I did not want to bring in DynamoDB or any other database for something this small. Instead, I store two plain JSON files directly in S3:
-
manifest.json, a rolling list of the last thirty days of poems.
-
state.json, which holds nothing more than a counter for which tone comes next. Each run reads both files, updates them, and writes them back. It is a tiny amount of state, and S3 handles it without any extra moving parts.
Step 4: Give the agent a face
The gallery itself is a single static HTML page hosted directly from the same S3 bucket, using S3 static website hosting. The page fetches manifest.json in the browser with a simple fetch call and renders a card for each day: the weather, the temperature, and the poem. There is no backend serving this page. It is just files sitting in a bucket, which keeps hosting costs at essentially zero.
Challenges Faced and How I Resolved Them
Challenge 1: Making the agent actually autonomous, not just automated
At first I thought "automated" and "autonomous" meant the same thing here. They do not. A cron job that runs a script is automated. What the challenge asked for was something that runs, makes a decision, and produces creative output with nobody watching.
The fix was to separate the trigger from the logic completely. Amazon EventBridge Scheduler (a service that invokes a target on a schedule, without any server running in between) calls the Lambda function once a day. The Lambda does not know or care that it was called by a schedule instead of a person. This meant I could test the entire creative pipeline manually with the AWS CLI, then hand the exact same function over to the scheduler once it worked, with zero code changes.
Challenge 2: Giving the agent memory without adding a database
My first instinct was to reach for DynamoDB to track the rotation of writing tones and the history of past poems. That felt like overkill for something this small, and it also meant one more service to configure, monitor, and pay for.
I resolved this by storing two small JSON files directly in the same S3 bucket that hosts the gallery:
manifest.json for the rolling list of past poems, and state.json for a single counter tracking which tone comes next. Each Lambda run reads both files, updates them, and writes them back. It is not built for high concurrency, but for one invocation a day, it is more than enough, and it kept the whole project inside a single AWS service for storage.AWS Services Used and Architecture

Here is the full picture of what runs behind the scenes:
- Amazon EventBridge Scheduler: triggers the Lambda function once a day, which is what makes the agent "always-on" without any server running continuously.
- AWS Lambda: the agent's brain. One Python function does the weather lookup, the Bedrock call, and the S3 write.
- Amazon Bedrock (Nova Micro): the creative engine. It writes the poem.
- Amazon S3: stores the manifest and state files, and also hosts the static gallery website.
- AWS IAM: gives the Lambda function and the Scheduler only the exact permissions they need, nothing more.
- Amazon CloudWatch Logs: captures every run so I can see exactly what happened if something fails. In a simple flow:
EventBridge Scheduler calls Lambda once a day. Lambda calls the weather API, then Bedrock, then writes to S3. The static site in S3 reads the same files and shows them to anyone who visits.
Everything above is defined in Terraform. Running
terraform apply creates the bucket, uploads the site, creates the IAM roles, deploys the Lambda function, and sets up the schedule, all in one pass.Honest Trade-offs
I want to be upfront about the shortcuts I took, since this was built over a weekend and not meant to be a production system.
I did not add retry logic if a Bedrock call fails on a given day. If the model access has not been approved yet, or if there is a transient error, that day's entry simply does not appear, and the schedule tries again the next day. For a personal creative agent this felt like an acceptable trade-off, but it is the first thing I would fix if this needed to run reliably for a real audience.
The biggest deliberate cut was scope, not quality. The original idea paired each poem with a generated artwork from an image model. I chose to hold that back for a future version and ship the poem side first. Keeping the agent to a single Bedrock call made the Lambda function easier to reason about, easier to test, and cheaper to run while I got the scheduling and storage pattern right. Adding an image model back in later is mostly a matter of one more Bedrock call and one more field in
manifest.json , since the rest of the pipeline, the scheduler, the state file, and the gallery page, does not need to change shape to support it.I also kept the tone rotation simple. It is a fixed rotation through a list of moods rather than anything that learns from feedback. A more ambitious version could have the agent read yesterday's poem before writing today's, building actual continuity between entries instead of just cycling through a list. That, along with the artwork, is on my list of next steps.
Quick Checklist Before You Go Live
- Bedrock model access approved for Nova Micro in your target region.
- AWS CLI configured with sufficient permissions.
- Terraform initialized with
terraform init.
-
terraform applycompleted without errors.
- Gallery URL from the Terraform output loads and shows at least one entry.
- CloudWatch Logs show a successful run, ideally one triggered by the Scheduler rather than a manual invoke.
What I Learned
Building this reminded me that "autonomous" does not have to mean complicated. The hardest part was not the scheduling or the infrastructure, both of which are things I have built before. It was writing a prompt specific enough that the poem actually felt tied to today's weather instead of reading like a generic template. That took more iteration than the AWS side of the project.
I also learned to appreciate how little state an agent like this actually needs. It would have been easy to reach for a database out of habit. Two small JSON files in the same bucket that already hosts the site turned out to be simpler, cheaper, and just as reliable for this scale. Keeping the first version to one Bedrock call also made it obvious how easily this pattern can grow. Adding the artwork later means extending, not rebuilding.
Conclusion
The Weather Muse is a small project. One weather check, one model call, a couple of JSON files, and a static page. But the pattern underneath it is the interesting part: a genuinely stateless, event-driven agent that produces something new on its own, with nobody clicking a button. That pattern scales far beyond weather poems. The same shape works for a daily news summary, a nightly code review digest, a paired daily artwork once I add the image model back in, or anything else you would rather find waiting for you than have to go generate yourself.
The agent is forgettable. The pattern is not.
Link to App & Repo
Source code: https://github.com/TanseerS/aws-builder-lab/tree/main/weekend-challenges/creative-agent
YouTube demo: https://youtu.be/hIJ98nq1J0Y Results



How to Build The Weather Muse
Step by step instructions to deploy the agent from the zip file.
1. One-time AWS setup
Enable Bedrock model access:
- Open the AWS Console and search for "Bedrock".
- In the left sidebar, click "Model access".
- Request access to Amazon Nova Micro (and Amazon Nova Canvas if you are keeping the image generation part).
- Approval is usually instant. Refresh the page until it shows "Access granted".
Do this in
us-east-1, or whichever region you plan to deploy to.
Configure the AWS CLI:
aws configureEnter your Access Key ID, Secret Access Key, region (
us-east-1 ), and output format ( json ).2. Install Terraform
Check if you already have it:
terraform -versionIf it is missing, install it:
brew install terraform3. Unzip and initialize
unzip weekend-creative-agent.zipcd weekend-creative-agentterraform initThis downloads the AWS provider and the archive provider used to zip the Lambda code.
4. Review the plan
terraform planThis shows exactly what will be created: the S3 bucket, IAM roles, Lambda function, and EventBridge schedule, without making any changes yet. Worth a quick read before applying.
5. Apply
terraform applyType
yes when prompted. This takes one to two minutes. It also invokes the Lambda function once automatically so the gallery has content right away.6. Check the result
terraform output gallery_website_urlOpen that URL in a browser. You should see today's entry.
7. Re-run manually anytime
terraform output manual_invoke_commandCopy and run the command that gets printed. Then refresh the gallery page.
8. Check logs if something fails
aws logs tail /aws/lambda/weather-muse-agent --follow --region us-east-1The most common failure is Bedrock model access not yet approved in that region.
9. Tear down when done
terraform destroyNeed Help?
If you try building something similar and get stuck, especially around the Bedrock request formats or the EventBridge Scheduler permissions, feel free to reach out. I am happy to walk you through it.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article