
Weekend Creative Agent Challenge: AfterHours Museum
AfterHours Museum is an autonomous digital museum that continues curating fictional artifacts while nobody is visiting. Powered by AWS and Amazon Bedrock, each scheduled run creates a new exhibit, generates its artwork, remembers previous collections, and publishes it automatically.
AfterHours Museum
What happens inside a museum after everyone leaves.
That question became the starting point for AfterHours Museum.
Most generative AI applications wait for someone to open them, provide a prompt, and ask for something new. I wanted to build the opposite experience.
AfterHours Museum is an autonomous digital museum curator that continues creating new exhibits while nobody is using the application.
Every few hours, the curator wakes automatically. It reviews the exhibits it has already created, looks at the styles and themes it has recently used, chooses a different creative direction, creates a new fictional artifact, writes its museum description, generates matching artwork, stores the new exhibit, and publishes it to the collection.
When I return to the application later, there can already be something new waiting inside the museum.
That is the main idea behind the project.
A museum that keeps curating itself after everyone leaves.
Vision and what it does
I wanted AfterHours Museum to feel more like a real digital collection than a simple AI image gallery.
Each autonomous generation produces a complete fictional museum exhibit.
An exhibit can include an artifact name, category, collection, era, origin, materials, museum description, provenance, curator note, interesting fact, visual style, and generated artwork.
The artifacts can come from imagined history, fictional civilizations, unexplained scientific experiments, alternate futures, forgotten inventions, or completely new fields of study.
One exhibit might be an unusual astronomical instrument.
Another might be a transportation device from a future that never happened.
Another might be a handwritten document dated on a day that does not exist.
The goal is to make every visit feel slightly different.
For example, one autonomous run could create an artifact called The Memory Camera.
At first it appears to be an ordinary early twentieth century camera.
The museum description explains that photographs produced by the camera do not show a place exactly as it exists. Instead, they show the location as the photographer remembers it.
Buildings that have disappeared may return.
People who are no longer present may appear in the photograph.
Details forgotten by the photographer may disappear completely.
The application then generates a visual representation of that artifact and places it inside the museum collection.
The next autonomous run should not simply create another old camera.
It should review recent exhibits and deliberately move in another direction.
That is where the curator's memory becomes important.

Curatorial memory
One of the main problems with repeatedly generating creative content is repetition.
If the same instructions are sent to a generative model again and again, the results can slowly begin to feel similar.
I wanted the museum to behave more like a curator building a diverse collection.
AfterHours Museum stores information about previous exhibits in Amazon DynamoDB.
Before creating another exhibit, the autonomous curator retrieves recent exhibit metadata.
This can include the categories, materials, eras, moods, collections, visual styles, and themes used recently.
That information is included as context during the next generation.
If several recent exhibits used brass machinery and nineteenth century aesthetics, the curator can deliberately move toward something different.
It might create a ceramic scientific instrument from an imagined future, a cultural object from an unknown civilization, or an unusual biological specimen.
This gives the museum a lightweight form of creative memory.
The curator is not simply asking what can I create.
It is also asking what I have created recently, and what would make the collection more interesting next.

How I built it
I started with the autonomous workflow before building the final visual experience.
The most important requirement for the project was that the curator should work without manual user initiation.
Amazon EventBridge Scheduler handles this part.
EventBridge Scheduler invokes an AWS Lambda function at a configured interval.
During development, I can use a shorter interval to verify multiple autonomous executions. For the deployed application, the interval can be increased so that the museum receives a new exhibit every few hours.
When the Lambda function starts, it creates a unique run identifier and loads information about recent exhibits from Amazon DynamoDB.
This previous collection becomes the curator context.
The function then invokes Amazon Bedrock.
Through Amazon Bedrock, Amazon Nova is used to generate the structured concept for the next museum exhibit.
The output contains the artifact name, category, collection, era, materials, description, provenance, curator note, visual style, and image generation prompt.
The generated response is validated before it becomes part of the museum.
Once the written exhibit is complete, the artwork stage begins.
Amazon Nova Canvas is used to generate a visual representation of the fictional artifact.
The resulting image is stored in Amazon S3.
The complete exhibit metadata is then stored in DynamoDB.
Once the record has been saved, the public application can display the newly created artifact.
The Lambda execution finishes and the curator waits until EventBridge Scheduler wakes it again.
No visitor needs to open the application or press a Generate button for this process to happen.

AWS architecture
I intentionally kept the AWS architecture small and understandable.
Each service has a clear responsibility.
Amazon EventBridge Scheduler provides the autonomous trigger.
AWS Lambda runs the curator workflow.
Amazon Bedrock provides the generative AI layer.
Amazon Nova creates the structured exhibit concept and museum writing.
Amazon Nova Canvas creates the visual representation of each artifact.
Amazon DynamoDB stores exhibit metadata and the curator's recent collection memory.
Amazon S3 stores generated artwork.
Amazon CloudWatch records executions and gives visibility into autonomous curator activity.
Amazon API Gateway provides a public API for reading exhibits, collection information, and curator status.
AWS Amplify hosts the public web application where visitors can explore the museum.
The generation flow is straightforward.
EventBridge Scheduler wakes the curator.
Lambda retrieves recent exhibit memory from DynamoDB.
Lambda sends that context to Amazon Bedrock.
Amazon Nova creates the next exhibit.
Nova Canvas generates the artwork.
The artwork is stored in Amazon S3.
The exhibit metadata is stored in DynamoDB.
CloudWatch records the execution.
The public application displays the updated collection.

Designing the museum experience
I did not want the frontend to look like an administration dashboard.
The interface is designed around the idea of visiting a digital museum.
The latest exhibit receives the most visual space.
Previous exhibits appear as part of the permanent collection.
Each exhibit has its own detail page with artwork, museum description, provenance, curator note, and generation information.
The museum can also organize artifacts into temporary collections.
For example, the curator might create a collection called Objects From Futures That Never Happened.
Another collection might focus on forgotten scientific instruments.
Another could explore ordinary household objects from impossible civilizations.
These themes give the autonomous curator another way to change its creative direction over time.

Making autonomy visible
One thing I learned quickly is that an autonomous backend is not enough.
Visitors also need a way to understand that the system is actually working on its own.
The public interface therefore shows the curator status and generation information.
Each exhibit includes its autonomous generation timestamp and run information.
I also added a Curator Activity view.
This view can show the stages of recent autonomous executions.
For example,
The scheduler awakened the curator.
The previous collection was reviewed.
A new direction was selected.
The museum label was generated.
The artwork was created.
The exhibit was stored.
The exhibit was opened to visitors.
Amazon CloudWatch provides the technical view of the same workflow.
This makes the autonomous behavior visible from both sides.

Challenges I encountered
One of the main challenges was maintaining creative variety.
A museum containing thirty variations of the same mysterious brass device would not be very interesting.
Providing recent exhibit metadata to the model helped reduce repetition.
Another challenge was structured generation.
The backend needs more than a paragraph of creative writing.
It needs specific fields that can be stored and displayed consistently.
The artifact title, category, era, materials, provenance, curator note, and image prompt all need to exist separately.
Validating model output before storing it made this workflow more reliable.
Artwork generation introduced another consideration.
I did not want a temporary image generation failure to destroy an otherwise complete exhibit.
The text and visual generation stages are therefore treated separately.
If a valid exhibit has already been created, the application can preserve it even if the artwork stage temporarily fails.
The final challenge was proving that the application really works while nobody is interacting with it.
That is why EventBridge scheduling, generation timestamps, CloudWatch logs, run identifiers, and Curator Activity became important parts of the project.
They are not just debugging tools.
They help explain the product itself.

What I learned
The biggest lesson from this challenge was that autonomous creative applications require much more than a model call.
Amazon Bedrock creates the content, but several other parts of the system make the autonomous experience possible.
EventBridge Scheduler gives the curator time awareness.
Lambda gives it an execution environment.
DynamoDB gives it memory.
S3 gives it persistent visual storage.
CloudWatch gives it observability.
Amplify gives visitors a place to experience the results.
I also learned that even simple memory can significantly improve repeated generative workflows.
The curator does not need an extremely complicated long term memory system to understand that it recently created several similar exhibits.
A small amount of structured metadata is enough to encourage the next generation to move in a different creative direction.
Another important lesson was that autonomous applications need visible evidence of activity.
When a human is not initiating every action, timestamps, logs, status information, and execution records become much more important.
They answer a simple question.
Did the application really do this by itself?
For AfterHours Museum, the answer should be visible every time a new exhibit appears.
The result
AfterHours Museum started with a simple idea.
What if the museum continued working after the visitors left.
Now the curator can wake automatically, review its collection, decide what should be created next, write a new exhibit, generate its artwork, add it to the museum, and wait for another scheduled run.
When I return later, the collection may be larger.
There may be a strange new scientific instrument.
A document from an impossible date.
A piece of technology from a future that never existed.
Or something completely ordinary with a story that makes it unusual.
The museum keeps changing even when nobody is watching.
That is what I wanted to create for this challenge.
A creative application that does not wait for another prompt.
A museum that keeps curating itself after everyone leaves.
Project links
Live application:
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article