AWS Builder Center
Weekend Creative Agent Challenge: EvoMuse

Weekend Creative Agent Challenge: EvoMuse

EvoMuse is an always-on AWS project architect. Every day it autonomously generates a fresh, actionable AWS project idea β€” with a difficulty level, real services, and an architecture β€” and has it ready when you return. You react with πŸ‘/πŸ‘Ž and a comment, and it evolves its suggestions using persistent memory. Built serverless with Amazon Bedrock (Nova Lite), Lambda, DynamoDB, API Gateway and EventBridge.

Software Engineer

Vision β€” what it does and the problem it solves

Most creative tools go stale the moment you stop opening them. The best tool is the one you never have to open β€” it just shows up with something new. That's the idea behind EvoMuse.
EvoMuse is an always-on AWS project architect that learns what you want to build. Every single day, without anyone asking, it invents one fresh, buildable AWS project idea and has it waiting for you when you come back. Each idea is genuinely actionable: it has a difficulty level (100–400), a category, the real AWS services it uses (each with a purpose), an architecture with a data flow, key features, an implementation roadmap, learning objectives, the skills required, an estimated build time, and suggested next steps.
The problem it solves is a very real one for developers learning the cloud: "what should I build next?" Staring at a blank page is the number-one reason side projects never start. EvoMuse removes that friction β€” it proposes a fresh, right-sized project daily and, crucially, adapts to you over time.
That last part is the heart of the agent. When you see the project of the day, you give it a πŸ‘ or πŸ‘Ž and, optionally, a sentence about what you'd change β€” "make it more advanced", "more Bedrock", "use Step Functions", "Level 200 is too easy". EvoMuse analyzes that feedback and updates a persistent project- preference memory. The next day's idea reflects what it learned. No model training, no fine-tuning β€” the learning is entirely persistent memory fed back into the next prompt.
The full loop:
GENERATE PROJECT β†’ SHOW IT β†’ πŸ‘ / πŸ‘Ž (+ comment) β†’ ANALYZE FEEDBACK
β†’ UPDATE PREFERENCE MEMORY β†’ GENERATE A MORE RELEVANT PROJECT β†’ REPEAT

How it works (always-on behavior)

An Amazon EventBridge Scheduler fires once per day and invokes a Lambda that:
  1. Loads the current preference memory.
  1. Loads recent projects and recent feedback.
  1. Asks Amazon Bedrock (Amazon Nova Lite, via the Converse API) for a structured JSON project that honors the learned preferences and avoids repeating recent ideas.
  1. Validates the project β€” the level must be exactly 100/200/300/400, every AWS service must be a real service name with a stated purpose, the architecture flow may only reference services that were actually listed, and there must be implementation steps and learning objectives. It also rejects "trivial variations" of recent projects (near-duplicate titles or the same level + service set), regenerating up to three times if needed.
  1. Stores the result in DynamoDB.
The Lambda is idempotent: if today's project already exists it exits without generating a second one, so retries or overlapping runs never create duplicates. When you return, the frontend simply reads today's project β€” it's already there.

How I built it (process, key decisions, challenges)

Process. I started from the data model and the agent logic, because those define everything else. I used a single-table DynamoDB design with three record types (Β PROJECTΒ , Β MEMORYΒ , Β FEEDBACKΒ ), wrote the Python 3.12 Lambdas, then the OpenTofu infrastructure, then the Astro frontend, and finally wired it all together and tested the loop live.
Key decisions.
  • Persistent memory instead of training. The "self-improvement" requirement is met with an incremental merge: each feedback event contributes deltas (preferred levels, services, categories, architectures, things to avoid) that are unioned into the existing memory. A single reaction never wipes what was already learned, so taste accumulates instead of thrashing.
  • Strict validation + diversity checks. An LLM will happily invent an AWS service that doesn't exist or describe an architecture that references components it never listed. I put a hard validation layer in front of storage (real-service allow-list, purpose-per-service, architecture-consistency) and a similarity check so the agent doesn't hand you "AI Resume Analyzer" three days in a row.
  • The architecture diagram is generated from data, not hardcoded. The frontend renders each project's diagram as SVG straight from the project's own Β architecture.flowΒ , so the picture always matches the services the agent actually chose.
  • Least-privilege, fully serverless, Free-Tier friendly. Each Lambda has its own IAM role with only what it needs; DynamoDB is pay-per-request; nothing runs when idle. The only variable cost is Bedrock text inference β€” and it's capped by generating exactly one project per day.
Challenges.
  • Model availability differs per account/region. The model IDs are configurable (Β BEDROCK_TEXT_MODEL_IDΒ ) precisely because you can't assume a given model is enabled. I verified availability and access before deploying and settled on Amazon Nova Lite, which is Free-Tier friendly and Converse-API compatible.
  • Getting structured JSON reliably. Models wrap JSON in markdown fences or add stray prose. The parser tolerates that, and if a response still fails validation the generator retries with a stronger instruction.
  • Proving the loop without faking it. I tested end-to-end against real AWS and real Bedrock (details below) rather than mocks, so the self-improvement is demonstrable, not just claimed.

AWS services used and architecture overview

Service
Role
Amazon Bedrock (Nova Lite)
Generates each project and analyzes feedback into preferences
AWS Lambda
Five functions: generate, feedback, and three reads
Amazon EventBridge Scheduler
Triggers the daily generation (always-on)
Amazon DynamoDB
Single-table store for projects, memory, feedback
Amazon API Gateway
HTTP API exposing the endpoints
Amazon S3 + CloudFront
Private static hosting of the frontend (Origin Access Control)
AWS IAM
Least-privilege role per Lambda
Amazon CloudWatch
Logs and a generation error alarm
Daily generation (while you're away):
EventBridge Scheduler β†’ Lambda: generate_project β†’ Amazon Bedrock (Nova Lite)
β”‚
└──────────────→ Amazon DynamoDB (project + memory)
When you return (request flow):
Browser β†’ CloudFront β†’ (private S3 site)
Browser β†’ API Gateway β†’ Lambda (get today / history / memory / feedback)
β”‚
DynamoDB + Bedrock (feedback analysis)
API endpoints: Β GET /projects/todayΒ , Β GET /projects/historyΒ , Β GET /projects/{date}Β , Β GET /memoryΒ , Β POST /feedbackΒ .
The whole environment is defined in OpenTofu and deploys with Β tofu init && tofu applyΒ  β€” no console clicking. The frontend is Astro + TypeScript + Tailwind, dark developer-focused, with a level badge, scannable service cards, the data-driven architecture diagram, a full project breakdown, a "what EvoMuse has learned" memory panel, an evolution timeline, and a filterable project history.

Proof: the self-improvement loop, live

I deployed everything to AWS and exercised the loop against real Bedrock:
  1. On deploy, the scheduler generated the first project automatically: "Serverless Chatbot with Sentiment Analysis" β€” Level 300, category Serverless (Lex, Bedrock, Lambda, API Gateway, DynamoDB).
  1. I submitted feedback: "I like it, but I want more advanced Level 400 projects with event-driven architectures using Step Functions, EventBridge and Bedrock. Avoid basic CRUD."
  1. The memory updated to: preferred levels [300, 400], category Event-Driven, architecture event-driven, services Amazon Bedrock, avoid basic CRUD, learning goal Step Functions orchestration.
  1. The next generated project became "AI-Powered Event-Driven Chatbot for Customer Support" β€” category Event-Driven, now including Amazon EventBridge and AWS Step Functions.
Same theme, visibly smarter direction β€” the agent listened and evolved.

What I learned

  • Bedrock’s Converse API gives a clean, model-agnostic way to get structured output, and pairing it with strict server-side validation is what turns a "chatbot that returns JSON" into a dependable agent.
  • "Self-improving" doesn't require training. A well-designed persistent memory that you fold back into the prompt produces a genuinely adaptive experience at near-zero cost.
  • Idempotency is a feature, not an afterthought for anything on a schedule β€” it's what makes "always-on" safe to retry.
  • Least-privilege IAM per function is easy to do from day one with IaC and much harder to retrofit.
  • Design the validation and diversity rules early. They shape the prompt and are what keep an autonomous, unattended generator from drifting into repetitive or nonsensical output.

Try it

Open it, read today's AWS project, tell EvoMuse what you'd change, and come back tomorrow β€” it will have designed something more your style, all on its own.
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