AWS Builder Center
Weekend Creative Agent Challenge: DreamForge

Weekend Creative Agent Challenge: DreamForge

What if your AI didn't wait for a prompt? DreamForge wakes up every morning, reads the world around it, remembers what it created before, chooses what to create next, critiques its own work, and publishes a brand-new creative capsule—completely on its own. Built on AWS, it's creativity that runs while you sleep.

Cybersecurity & App Developer

Weekend Creative Agent Challenge: DreamForge

Tag:  agents 



Vision & What It Does

Most AI creative tools wait for you.
You open a tab, type a prompt, press a button, and something appears. The machine provides the generation, but the human still has to provide the initiative.
DreamForge takes the opposite approach.
It is an always-on autonomous creative agent that wakes up every morning, understands its current context, remembers what it has created previously, decides what it should create next, produces the work, evaluates its own output, revises it when necessary, and publishes the finished result automatically.
There is no Generate button anywhere in the product. There is no hidden manual generation workflow behind the dashboard. The creative pipeline is intentionally separated from the user interface so that the agent can operate whether or not anyone is visiting the website.
The result is a Daily Creative Capsule generated automatically every morning.
Each capsule contains:
Output
Description
Theme
A creative direction selected autonomously by the agent
Reasoning
A short explanation of why the agent chose that direction
Story
A short story, poem, or two-character micro-script
Quote
An original pull-quote from the creative work
Cover
An agent-directed typographic SVG poster based on the selected mood
The challenge was not simply to connect an application to a generative AI model. The interesting problem was to make creativity continuous and autonomous.
A one-shot generator has no continuity. If the same context is supplied repeatedly, it can easily produce similar ideas over and over. This becomes particularly obvious with weather-driven creativity. If it is monsoon season and it rains every day, an agent that simply receives "rain" as its prompt can produce variations of the same rain story indefinitely.
DreamForge approaches this differently through memory.
Before deciding what to create, the agent retrieves recent capsules from DynamoDB. It uses those previous themes and emotional directions as creative constraints. The agent is explicitly instructed to avoid simply repeating recent themes and to vary its emotional register.
For example, if yesterday's story was melancholic and whimsical, today's reasoning might deliberately move toward something more upbeat and reflective.
One production capsule contains the reasoning:
"Shifting from the melancholic-whimsical of 'Echoes of the Rainy Streets', this story will provide an upbeat yet reflective mood, offering a different emotional register."
The important part is not just that the model generated a sentence. The reasoning is displayed as part of the capsule so that the user can understand the creative decision the agent made.
DreamForge therefore treats previous work as part of the creative process rather than simply storing old outputs in an archive.

The Autonomous Creative Loop

The complete agent workflow is:
EventBridge Scheduler
↓
SENSE
↓
RECALL
↓
DECIDE
↓
CREATE
↓
CRITIQUE
↓
REVISE if necessary
↓
PUBLISH

At 08:00 every morning, EventBridge Scheduler triggers the agent automatically.
The agent first senses its current context, including the date, weekday, season, and live weather. It then recalls recent creative work from DynamoDB.
Next, the decision stage selects the theme, mood, creative form, art direction, and reasoning.
The creation stage produces the actual story or other creative work.
The critique stage is intentionally implemented as an independent model call. It evaluates the generated work and produces a score out of ten. If the score falls below the configured quality threshold, DreamForge performs exactly one revision before publishing.
Finally, the completed capsule is written to S3 and DynamoDB, and the CloudFront distribution is invalidated so the latest creation becomes available through the website.
The entire process happens without a human initiating the generation.



Proof of Autonomy

One of the most important requirements of this challenge is demonstrating that the application actually produces creative output autonomously rather than simply providing a button that a user can press.
DreamForge has a real scheduled execution running through EventBridge.
A production execution produced the following log:
05:24:43 trigger source=eventbridge.schedule human_input=none
05:24:43 sense season=Monsoon
05:24:43 recall count=1
05:24:44 decide theme="Silver Linings in Monsoon"
mood=upbeat-reflective
05:24:47 create.text title="Whispers of the Rain"
words=162
05:24:47 create.visual kind=poster
05:24:48 critique score=7
05:24:48 publish.visual images/2026-08-21.svg
05:24:48 publish.json data/latest.json
05:24:48 publish.memory dynamodb ok
05:24:48 publish.invalidate CloudFront
05:24:48 complete duration_ms=5528

The complete execution took approximately 5.5 seconds.
Every scheduled execution records its trigger source, allowing the system to distinguish an autonomous scheduled run from other development or testing activity.
The absence of a user-generation path is also intentional. The browser can read the published result, but it cannot invoke the creative agent.
The architecture therefore enforces the central design principle:
DreamForge creates first. Humans discover later.



How I Built It

I built DreamForge back-to-front.
The first priority was proving that the autonomous pipeline could work against real AWS infrastructure. Only after the backend workflow was reliable did I focus on the presentation layer.
The goal was to avoid building a beautiful local prototype that could not actually operate autonomously in production.

Choosing the Model by Measurement

One of the first decisions was choosing the text-generation model.
Instead of assuming that the largest model would provide the best result, I tested the models using the actual creative-generation requirements.
The evaluation measured whether the generated output stayed within the requested length and whether the model followed the requested prose format.
The results were:
Model
Words
In Range
Prose
us.amazon.nova-lite-v1:0
214
✅
✅
qwen.qwen3-32b-v1:0
207
✅
✅
zai.glm-4.7
210
✅
✅
deepseek.v3.2
222
❌
✅
global.amazon.nova-2-lite-v1:0
174
❌
✅
amazon.nova-pro-v1:0
147
❌
✅
The result was surprising: the larger Nova Pro model followed the length constraint worse than Nova Lite.
That led to a deliberate decision to use Amazon Nova Lite for DreamForge's decision, writing, and critique workflow.
This was an important lesson in building AI applications: model selection should be based on the behavior required by the application rather than model reputation alone.
I also discovered a problem with my first model-testing script. It reloaded modules between candidates in the same process and silently attributed one model's output to another model. I removed that probe and changed the methodology so each candidate runs in its own clean process.

Handling Image Generation

I initially investigated using a generative image model for the capsule covers.
Amazon Nova Canvas was unavailable for my account and returned a provider error indicating that the model was legacy-restricted for accounts that had not been actively using it during the required period.
I then investigated alternative image-output models. The available alternatives did not provide the text-to-image generation path required by DreamForge.
Rather than allowing that limitation to block the project, I changed the visual architecture.
DreamForge now uses an agent-directed typographic SVG poster generator.
The agent chooses the mood, palette, theme, and art direction during the decision stage. The poster generator then composes those decisions into an SVG cover.
This is intentionally not represented as a diffusion-generated image.
Each capsule identifies the visual output as a typographic poster composed by the agent.
The approach has some useful technical advantages. SVG is lightweight, resolution-independent, requires no image-processing dependency, and can be generated directly without shipping large model or font assets.
Most importantly, it keeps the creative decision inside the agent while remaining honest about how the visual artifact is produced.

Making the Agent Critique Itself

A creative generator naturally tends to approve its own work if asked whether the output is good.
To avoid that, DreamForge uses a separate critique call.
The reviewer receives the theme and generated creative work without being told that it is the same model that produced the original content. It scores the result out of ten.
If the score is below seven, DreamForge performs exactly one rewrite.
The revision is intentionally bounded.
An unlimited improve-until-perfect loop could consume the Lambda execution time and result in the agent publishing nothing. For an always-on daily system, publishing a reasonable creation is better than failing to publish because the system became trapped in an endless optimization loop.

Learning From Production Failures

Several problems only became visible after deploying the system against real AWS infrastructure.
One issue involved cross-region Bedrock inference profiles. The first scheduled execution failed because the model authorization referenced a different US region than the IAM policy allowed.
Another issue involved an AWS Organization Service Control Policy that blocked anonymous Lambda Function URL invocation despite the resource policy itself being correctly configured. The API architecture was changed to use App Runner instead.
CloudFront also exposed a header collision involving Origin Access Control and authentication data, which required moving the token to a separate header.
An App Runner deployment initially failed because the Docker image included an OCI image index with provenance metadata that the runtime could not execute. Disabling provenance and SBOM generation resolved the issue.
There was also an agent-quality failure rather than an infrastructure failure.
On the first run, the memory table was empty, but the model claimed that it was balancing a "recent series of uplifting themes." That history did not exist.
This was especially important because DreamForge displays the agent's reasoning as evidence of its decision process. A fabricated history would undermine that evidence.
The solution was to explicitly tell the model when memory is empty and forbid references to previous work when there is no previous work.
These failures reinforced one of the central principles of the project: an autonomous agent has to be designed for partial failure.
Weather can fail and the agent can continue with less context. Memory can fail and the agent can create without memory. Visual generation can fail and the system can still publish the text.
The creative story itself is the critical path.



AWS Services Used / Architecture Overview

DreamForge uses an event-driven AWS architecture:


AWS services used

AWS Service
Role in DreamForge
Amazon EventBridge Scheduler
Triggers the creative agent every morning
AWS Lambda
Executes the seven-step autonomous agent loop
Amazon Bedrock
Provides Nova Lite for creative decisions, writing, and critique
Amazon DynamoDB
Stores agent memory, previous capsules, run history, and user data
Amazon S3
Stores capsule JSON, SVG covers, and web artifacts
Amazon CloudFront
Delivers the private S3-hosted application through Origin Access Control
AWS App Runner
Runs the containerized accounts API
Amazon ECR
Stores the App Runner container image
AWS Secrets Manager
Stores the JWT signing secret securely
Amazon SQS
Provides a dead-letter queue for failed agent executions
Amazon CloudWatch Logs
Provides execution logs and evidence of autonomous runs
AWS IAM
Enforces separate least-privilege identities
One architectural decision is particularly important:
Nothing in the browser points back to the creative agent.
The website reads the published result, but it does not have permission to invoke the agent.
The accounts API is also isolated from the agent and has no permission to invoke it.
This means the no-human-trigger property is enforced through the architecture and IAM permissions rather than simply being a statement in the documentation.
The live application is available at:
The source code is publicly available at:



What I Learned

The biggest lesson from DreamForge is that scheduled invocation is what transforms a generator into an autonomous agent.
The generative model itself is not the most interesting part. The important engineering work happens around it: scheduling, memory, decision-making, evaluation, revision, persistence, observability, and failure handling.
I learned that memory has a major impact on the quality of autonomous creative systems.
Without memory, similar context produces similar creative work. With memory, previous output becomes a constraint that encourages the agent to explore a different direction.
The seven-capsule memory window became a practical balance. A shorter window caused visible repetition, while a much longer history could overwhelm the prompt and force artificial novelty.
I also learned that negative constraints can be more effective than generic instructions to "be creative." Telling the model what to avoid — such as repeating recent themes or relying on obvious clichés — produced more useful variation.
Another lesson was the importance of measuring model behavior.
It would have been easy to assume that a larger model would automatically produce better results. The actual tests showed otherwise for the specific constraints DreamForge needed to satisfy.
Production deployment also changed how I think about IAM.
Local development can hide permission problems because a developer's own identity often has significantly more access than the deployed Lambda role. Several of the most important infrastructure problems only appeared after the application was deployed using scoped permissions.
Finally, I learned that autonomous systems should be designed for graceful degradation.
DreamForge does not require every external dependency to succeed. Weather is useful context, but not the creative output. Memory improves continuity, but an empty memory table should not stop creation. The visual poster improves presentation, but failure to create it should not prevent the story from being published.
Only the core creative output is treated as fatal.
That mindset makes the system much more suitable for unattended execution.



Running DreamForge

The project can be provisioned and deployed using the included scripts:
# Provision storage and CDN
cd infra
python provision.py

# Deploy the agent and schedule
python deploy_agent.py

# Test the scheduled path without waiting until tomorrow
python deploy_agent.py --schedule-in 5

# Build the web application
cd web
npm install
npm run build

The project also includes automated tests for the agent's poster generation and backend authentication behavior, along with checks against the deployed API.
The agent itself is intentionally lightweight. The Lambda implementation uses Python 3.12 on arm64 and has no external Python dependencies. This keeps the deployment small and avoids dependency and architecture-specific packaging problems.



Final Thoughts

DreamForge started with a simple question:
What happens if an AI does not wait for us to ask it to create something?
The answer is not just another chatbot or another prompt box.
It is a system that wakes up every morning, observes its context, remembers what it has already created, chooses a new direction, creates something, judges its own work, revises when necessary, and publishes the result.
The human role changes from requesting creation to discovering creation.
That is the idea behind DreamForge.
The best creative tool may be the one you never have to open.

Project Links

Built for the AWS Builder Center Weekend Creative Agent Challenge: Set Your Creative App Free.
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