AWS Builder Center
Weekend Creative Agent Challenge: Aubade, a Studio That Opens Before You Do

Weekend Creative Agent Challenge: Aubade, a Studio That Opens Before You Do

Aubade is a studio with no front door for me to walk through. At 06:00 UTC it wakes up on its own, picks a city, reads that city's actual weather right now, and makes a piece of art about it. Then it writes a poem about the same morning, reads the poem aloud in a human voice, publishes all of it, reviews its own work, and edits its own style before it goes back to sleep.

AI Engineer | AWS Community Builder – AI Engineering | AWS User Group Madurai Leader
Every creative tool I have ever built died the same death. Not from bugs. From the blank cursor. You open it, you stare at it, it stares back, you close it. The tool was fine. The problem was that it needed me to start.
So this weekend I built the opposite. Aubade is a studio with no front door for me to walk through. At 06:00 UTC it wakes up on its own, picks a city, reads that city's actual weather right now, and makes a piece of art about it. Then it writes a poem about the same morning, reads the poem aloud in a human voice, publishes all of it, reviews its own work, and edits its own style before it goes back to sleep.
By the time I look at it, the work is already done. There is nothing to open. There is only something to find.



Vision & What It Does

The name is the word for a dawn song, a poem for the hour when the light arrives and nobody is watching yet.
Aubade rotates through 32 cities, one per morning, by day of year. On 16 August it was looking at Kathmandu. Open-Meteo reported a thunderstorm, 27.1°C, 0.1 mm of rain falling. Amazon Bedrock's Nova Pro, acting as the studio's art director, answered with a palette pulled out of that specific storm —  #0b243b ,  #2a597b ,  #6fa3d4 ,  #d0e1e8 ,  #ffffff  — a note explaining itself ("the contrast between the dark storm clouds and the fleeting glimpses of dawn"), and this poem:
Temple spires silhouette, Raindrops on corrugated roofs, Thunder cracks, wet leaves unfurl, Street vendors shelter under tarps, Monsoon's breath, a city awakened.
Then a generative engine drew the morning: a flow field of six hundred curling strokes over a graded sky, a single light source near a rule-of-thirds node, layered strata below the horizon — and rain, because the weather code said 95, so the code added tilted streaks at an angle set by the wind speed. Amazon Polly read the poem aloud. All of it landed on a public gallery about eleven seconds after the schedule fired.
Nobody asked for any of it. That is the entire point.
The output is four artefacts every morning:
  1. A vector poster — a 1024×1024 SVG, generated, not templated.
  1. A raster plate — the same composition drawn straight to pixels at 896×896.
  1. A poem — grounded in one real city under one real sky, written that morning.
  1. A narration — the poem in a neural voice, as an MP3.
And a fifth thing that is not an artefact but is the part I care most about: the agent's style is different tomorrow because of what it made today.



How You Built It

The decision that made the project work

My first version asked Nova Pro to write the SVG directly. It worked on the first try, which was the problem — I got valid SVG that was a tasteful grid of overlapping circles and rectangles. Competent. Generic. The kind of thing that looks like a language model drawing.
So I inverted the roles. The model never draws a single pixel. It is the art director: it chooses colour, writes the poem, and adjusts numbers. A deterministic engine of about 250 lines does the drawing — a flow field built from summed sines, integrated into curling strokes, layered over a gradient sky with a bloom and soft strata.
That one inversion fixed three problems at once. The art got dramatically better because the composition rules are hard-coded taste rather than a model's guess. Output became reproducible, because the same date always produces the same seed. And the SVG is guaranteed valid, because it is assembled by code rather than predicted token by token.

The self-improvement loop, and why my first attempt at it failed

The genuinely hard part was "improves its style over time" without it degrading into noise.
My first attempt was the obvious one: after publishing, a critic model reviews the piece and its mutation is applied to the style for tomorrow. I ran seven mornings and watched the critic's own scores go 4.6 → 4.0 → 4.1 → 3.9 → 3.8 → 3.9 → 3.7.
It got worse every single day.
The root cause is straightforward once you see it. The critic cannot see the image. Nova Lite was reading numbers and a poem and grading in the dark, so its mutations were guesses, and applying a guess unconditionally is a random walk, not learning. Worse, an unseeing grader tends to hedge downward — it always finds something missing, so it always scores low, and the trend told me nothing.
So I split the job, and this is the shape I would defend in any design review:
The model proposes. The code decides.
Every morning the agent breeds four candidate style genomes:
variant
where it comes from
 champion 
yesterday's surviving genome, untouched
 directed 
champion plus today's weather-driven nudge from Nova Pro
 critic 
champion plus the mutation yesterday's critic asked for
 explore 
champion plus a small deterministic random walk
All four are rendered — that costs about 0.4 seconds each — and then scored by a fitness function written in plain Python: ink coverage against a target band, palette contrast, chroma (five neutral greys score near zero), the light source's distance from a rule-of-thirds node, mean stroke length, and novelty against the last six palettes. Highest score is published. The winner becomes the new champion.
The critic's opinion is no longer authority. It is a hypothesis that has to survive measurement. Here is 16 August, from the published record:
champion 7.046 directed 7.127 critic 7.046 explore 7.046
selected: directed
The director's storm-driven nudge — more curl, more turbulence, a lower horizon — actually measured better than the alternatives, so it shipped. The critic's proposal that day (brighter bloom) changed nothing measurable, so it lost. On 18 August  explore  won. On 19 August the  critic  variant won. On 21 August the reigning  champion  beat all three challengers, which is exactly what a healthy hill climb looks like.
The measured result across the seeded archive, on the genome-controlled half of fitness:
5.78 → 8.07 → 7.35 → 7.56 → 7.78 → 7.46 → 7.78, and today's autonomous run reached 8.14.
Up, with real dips. Not a straight line, because it is a search and not a script.

Bounded genes, so it can run unattended for months

Every one of the 24 style genes has a hard range.  strokes  lives in 120–1400,  curl  in 0.3–4.5,  stroke_opacity  in 0.06–0.85. Any mutation from any model is clamped into that range before it renders, and anything unparseable falls back to the gene's default. A model can propose  strokes: 999999  or  "turbulence": "a lot"  and the worst outcome is a piece that looks slightly different from yesterday.
That is what lets me leave it alone. There is no combination of model outputs that produces a broken morning.

The problem I could not solve, and what I did instead

I wanted a real AI-generated raster image alongside the vector poster. Two walls, both account-level:
  •  amazon.nova-canvas-v1:0  is listed in my region but its lifecycle status is  LEGACY , and inference returns: "This Model is marked by provider as Legacy and you have not been actively using the model in the last 30 days."
I did get one successful generation through  stable-image-control-structure  before the wall came down, and it was genuinely lovely — a photographic Naples harbour that followed my composition's horizon and light placement exactly. So the code path is right; the entitlement is not there.
Rather than ship a feature that depends on an entitlement I do not control, I made the agent draw its own raster. There is no SVG rasteriser in a bare Lambda runtime, and I refused to move to a container image for one dependency, so  src/raster.py  draws the same flow field a second time straight into a byte buffer and encodes a PNG with  zlib  and  struct  in about 30 lines. It runs in 0.83 seconds at 896×896 with zero dependencies, and the strata read as mountains in a way the vector version does not.
The repaint step still exists, tries Nova Canvas first and Stability second, implements both payload shapes, and logs a warning when neither answers. It is a bonus, never a dependency. Any account that can reach either model gets the third artefact for free.

Everything else that had to not break

The agent is wrapped so that no external failure costs a morning. Open-Meteo actually did fail during testing; the run published anyway with a fallback sky and recorded  "weather_text": "unread sky"  in the archive, honestly. If the director call fails, there is a template poem built from the weather reading. If Polly fails, the piece ships silent. Every failure is written into the day's record under  errors , because an agent nobody watches has to keep its own logbook.
And a run that finds today's piece already published stands down in 38 milliseconds. Scheduler retries cannot double-publish.



AWS Services Used / Architecture Overview

EventBridge Scheduler
cron(0 6 * * ? *) UTC
│ the only trigger. no API, no button.
▼
┌──────────────────────────────────────────┐
│ Lambda · python3.12 · arm64 │
│ 1024 MB · ~12 s · 125 MB peak │
└──────────────────────────────────────────┘
│ │ │ │
│ │ │ └─► Amazon Polly
│ │ │ neural voice → mp3
│ │ │
│ │ └─► Amazon Bedrock
│ │ Nova Pro — art director: palette, poem, nudge
│ │ Nova Lite — critic: verdict + proposed mutation
│ │ image model — optional repaint (best effort)
│ │
│ └─► Open-Meteo (no key) — the real sky
│
├─► Amazon DynamoDB style genome + archive, on-demand
└─► Amazon S3 ─► Amazon CloudFront + OAC ─► public HTTPS gallery
bucket stays private, nothing is world-readable

Amazon CloudWatch Logs · candidate scores and decisions, every run
AWS IAM · one table, one bucket, two model families
Service
What it does here
Amazon EventBridge Scheduler
The only thing that starts the agent. Daily cron, UTC, retries with a one-hour max event age.
AWS Lambda
The agent itself. Python 3.12 on arm64, no layers, no container, stdlib plus boto3.
Amazon Bedrock
Nova Pro as art director, Nova Lite as critic, an image model for the optional repaint.
Amazon Polly
Neural narration of each poem.
Amazon DynamoDB
The style genome and the archive.  pk=GENOME  for the champion,  pk=DAY  for history, so seven days of memory is one query.
Amazon S3
Every artefact. Private, encrypted,  BucketOwnerEnforced .
Amazon CloudFront
The public gallery over HTTPS, with Origin Access Control so the bucket stays private.
Amazon CloudWatch Logs
The evidence trail — every candidate's fitness and the selection decision, 30-day retention.
AWS IAM
Least privilege: one DynamoDB table, one bucket prefix,  bedrock:InvokeModel ,  polly:SynthesizeSpeech .
AWS CloudFormation
The whole stack in one template. No SAM, no CDK, no bootstrap —  ./deploy.sh  and wait.

Evidence it runs without me

I deleted today's record from DynamoDB, attached a temporary two-minute schedule, and walked away. CloudWatch:
07:05:21 morning run date=2026-08-21 force=False
07:05:25 candidate champion fitness 7.591 {coverage 0.805, contrast 1.0, chroma 0.749,
composition 0.84, flow 0.647, novelty 0.112}
07:05:25 candidate directed fitness 7.489
07:05:25 candidate critic fitness 6.759
07:05:26 candidate explore fitness 7.498
07:05:26 selected champion with fitness 7.591
07:05:31 plate 2026-08-21: 352368 bytes
07:05:33 published 2026-08-21 'Naples Overcast Dawn' variant=champion gen->8
07:05:33 REPORT Duration: 12260.94 ms Billed Duration: 12261 ms Max Memory Used: 125 MB

07:07:12 morning run date=2026-08-21 force=False
07:07:12 piece for 2026-08-21 already published, standing down
07:07:12 REPORT Duration: 38.09 ms
Two ticks. The first made a morning. The second refused to make it twice.
You can check the result yourself without running anything:
  •  https://d2bq7r7f8dyh8z.cloudfront.net/latest.json  — the full record, including every candidate's score, the critic's verdict, and its proposal for tomorrow
  •  https://d2bq7r7f8dyh8z.cloudfront.net/feed.json  — the archive
  •  https://d2bq7r7f8dyh8z.cloudfront.net/plate/2026-08-21.png  — this morning's image
  •  https://d2bq7r7f8dyh8z.cloudfront.net/audio/2026-08-21.mp3  — this morning's poem, read aloud

What it costs

One invocation a day at roughly 12 seconds and 1024 MB is deep inside the Lambda free tier. A handful of on-demand DynamoDB requests, a few megabytes in S3, and CloudFront's always-free 1 TB cover the rest. Polly neural gives 1 M characters free for twelve months and a poem is about 200. Bedrock is the only line with a real number on it: two Nova calls per morning, a fraction of a cent.
An always-on creative studio, for less than a coffee a year.



What You Learned

A language model is a great art director and an unreliable judge of its own work. The downward score trend was the most useful failure of the weekend. It taught me that "let the LLM critique itself" is a story about self-improvement, not a mechanism for it. The mechanism needs a measurement the model cannot argue with. Once the code did the judging and the model did the proposing, the numbers went up and stayed up.
Constraints are what let an agent be left alone. I did not make Aubade reliable by handling errors better. I made it reliable by shrinking what it is allowed to say. Twenty-four genes with hard ranges means the space of possible outputs contains no catastrophes. That is a cheaper guarantee than any amount of validation logic.
Model availability is the least portable thing about a Bedrock project. I assumed image generation was a solved commodity. Instead I learned to read  modelLifecycle.status , that  LEGACY  models will list themselves and then refuse you, that Marketplace-hosted models need a payment instrument and  aws-marketplace:Subscribe , and that cross-region inference profiles mean your IAM  foundation-model  ARN cannot be pinned to one region. Design so no single model is load-bearing.
A 30-line PNG encoder beat a container image. Reaching for a dependency is a reflex.  zlib  plus  struct  plus one loop got me a 280 KB PNG in under a second, kept the deploy at "zip and upload", and produced the images I like best in the whole project. Some of the time the stdlib really is enough.
The best interface was no interface. I built a gallery, but I have never used it to make anything. The work arrives whether or not I show up. Removing myself from the loop did not reduce what the tool produces — it is the only reason it produces anything at all.



Link to App or Repo

To run your own studio, with awscli v2,  python3  and  zip  installed:
git clone https://github.com/logesh4v/Weekend-Challenge-Set-Your-Creative-App-Free.git
cd Weekend-Challenge-Set-Your-Creative-App-Free
./deploy.sh
That is the whole setup. One CloudFormation stack, one Lambda, one schedule. It will publish its first morning at 06:00 UTC without being asked, which is the only feature that matters.
Tomorrow it visits a city I have not chosen, in weather I cannot predict, with a style it edited itself. I will find out what it made at the same time you do.
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