
Weekend Creative Agent Challenge: CreativePulse — An Autonomous Poetry Generator with AWS Strands
CreativePulse is an always-on autonomous poetry generator built with AWS Strands and Amazon Bedrock. Every day at 8:00 AM, Amazon EventBridge triggers the agent to create a unique themed poem, store it in DynamoDB, and publish it automatically to a static website hosted on Amazon S3.
Creating poetry that writes itself
What if creativity didn't need a button?
Most AI writing tools only create something after a user opens an app and enters a prompt. I wanted to build the opposite: an application that quietly works in the background, creates something meaningful every day, and has it ready before anyone visits the website.
That idea became CreativePulse, an always-on autonomous poetry generator powered by AWS Strands, Amazon Bedrock, AWS Lambda, Amazon EventBridge, Amazon DynamoDB, and Amazon S3. Every morning at 8:00 AM, Amazon EventBridge automatically triggers a Lambda function that launches the Strands agent. The agent remembers previous creations, chooses a fresh theme based on the weekday, writes an original poem using Amazon Bedrock Nova Lite, stores it in DynamoDB, and publishes it to a static website hosted on Amazon S3.
The result is a creative AI agent that produces new content without any manual interaction. Whether someone opens the website today or a week later, a new poem is already waiting for them.
Vision & What It Does
CreativePulse was designed around one simple vision: build a creative application that never needs to be opened to do its job.
Rather than asking users to generate poems on demand, the agent works autonomously. Every day is assigned its own creative mood:
- Monday — Productivity
- Tuesday — Learning
- Wednesday — Creativity
- Thursday — Focus
- Friday — Innovation
- Saturday — Adventure
- Sunday — Reflection
Before writing, the Strands agent checks its memory stored in DynamoDB. It reads the most recent poem, avoids repeating the previous theme or title, and generates something completely new. This gives the application a sense of continuity instead of producing unrelated outputs every day.
Each generated poem contains a unique title, the daily theme, mood, date, and an original AI-written poem. The newest poem becomes the featured content on the website, while previous poems remain available in the archive.
CreativePulse demonstrates how autonomous AI agents can combine scheduling, memory, reasoning, and cloud services into a single always-on creative workflow.
How I Built It
Phase 1 — Designing the autonomous workflow
I started by designing an event-driven architecture instead of a traditional user-driven application. The goal was to ensure the poem would be generated automatically every morning without requiring anyone to visit the website or press a button.
The final workflow became:
EventBridge → Lambda → Strands Agent → Amazon Bedrock → DynamoDB → S3 Website
This architecture is fully serverless, scalable, and requires virtually no infrastructure management.
Phase 2 — Building the AWS Strands Agent
The heart of CreativePulse is an AWS Strands Agent written in Python.
The agent performs three key tasks:
- Read previous creations from DynamoDB.
- Decide today's creative theme based on the weekday.
- Generate an original poem using Amazon Bedrock Nova Lite.
Using Strands made the application much more than a single LLM call. The agent can reason about previous outputs, use custom tools, and maintain contextual behavior across daily executions.
Phase 3 — Agent memory with DynamoDB
To prevent repetitive poems, I created a DynamoDB table named CreativePulsePoems.
Each record stores:
- Date
- Timestamp
- Title
- Theme
- Mood
- Poem content
Before generating today's poem, the Strands agent queries the latest entry and uses it as memory. This lightweight approach helps create more diverse and meaningful creative output while remaining cost-efficient within AWS Free Tier.
Phase 4 — Daily automation with Amazon EventBridge
The autonomous behavior is powered by Amazon EventBridge.
I configured an EventBridge schedule using a cron expression that triggers the Lambda function every day at 8:00 AM. Once triggered, Lambda executes the Strands agent, which completes the entire creative pipeline in just a few seconds.
This event-driven design eliminates the need for running servers while ensuring reliable daily execution.
Phase 5 — Publishing the website
After generating the poem, Lambda stores the structured JSON in Amazon S3 and updates the latest content for the website.
The static web application displays:
- Today's featured poem
- Theme and mood
- Publication date
- Archive of previous poems
Because the frontend is hosted entirely on Amazon S3 Static Website Hosting, the application is fast, lightweight, and inexpensive to operate.
Challenges I Faced
Designing an autonomous agent
The biggest challenge was creating a system that truly worked without user interaction. Instead of relying on manual prompts, I combined EventBridge scheduling with AWS Lambda so the creative workflow runs automatically every day.
Avoiding repetitive poems
Generative AI can sometimes produce similar outputs. I solved this by giving the Strands agent access to previous poems stored in DynamoDB, allowing it to intentionally avoid repeating themes and titles.
Keeping the architecture serverless
I wanted the entire project to be simple enough for builders using AWS Free Tier. Using EventBridge, Lambda, DynamoDB, S3, and Bedrock created a fully managed architecture with minimal operational overhead.
AWS Services Used & Architecture Overview
CreativePulse combines six AWS services into one autonomous creative system.
- Amazon EventBridge schedules the application every morning.
- AWS Lambda executes the Strands agent without managing servers.
- AWS Strands Agents provide reasoning, memory integration, and tool orchestration.
- Amazon Bedrock (Nova Lite) generates original poetry.
- Amazon DynamoDB stores poem history and acts as the agent's memory.
- Amazon S3 hosts the static website and stores generated content.
Architecture Flow|

What I Learned
This challenge taught me much more than building an AI application.
I learned how AWS Strands enables true agent-oriented development by combining reasoning with reusable tools instead of isolated prompts. Integrating Amazon Bedrock with Lambda showed how powerful serverless AI applications can be, while DynamoDB demonstrated an effective approach to lightweight agent memory.
Working with Amazon EventBridge also gave me practical experience building reliable event-driven systems that execute automatically on a schedule. Finally, deploying the frontend on Amazon S3 reinforced how simple and scalable static website hosting can be.
The biggest takeaway was realizing that the most engaging AI applications are not always interactive—they can quietly create value in the background, delivering fresh experiences every single day.
Live App & Source Code
CreativePulse is fully deployed on AWS and generates a brand-new poem every day through an autonomous AWS Strands agent. The complete source code, deployment guide, and architecture are available in the GitHub repository for anyone who wants to build their own always-on creative AI agent.
Thank you for reading! I hope CreativePulse inspires more builders to explore autonomous AI agents with AWS Strands and Amazon Bedrock.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article