AWS Builder Center
Weekend Creative Agent Challenge: Invented Today

Weekend Creative Agent Challenge: Invented Today

Invented Today is an always-on curator that explores history daily and uses Amazon Bedrock to turn real events into a concise record of human ingenuity.

Invented Today: A Daily Record of Human Ingenuity

The idea

What if you could open a website every morning and find a new piece of history waiting for you?
That is the idea behind Invented Today.
Invented Today is an always-on historical curator built for the AWS Weekend Creative Agent Challenge. Instead of waiting for someone to ask a question, the agent runs automatically once a day, retrieves real historical events that happened on that date, evaluates them with Amazon Bedrock, and publishes a small editorial edition highlighting inventions, scientific discoveries, engineering achievements, technological milestones, and other remarkable examples of human ingenuity.
The goal isn't to generate fictional history.
The source material is real.
The creative part is the curation: deciding which events are worth bringing to someone's attention and explaining why they matter.



Vision and what it does

Every date in the calendar contains dozens of historical events.
Some are famous. Some are obscure. Some are technical milestones that rarely appear in everyday history feeds. And many are buried inside long lists that most people will never read.
Invented Today turns that raw historical record into a small daily experience.
Each day, the agent:
  • Retrieves historical events associated with the current date.
  • Preserves the original historical data.
  • Sends the events to Amazon Bedrock.
  • Asks an AI curator to identify the most interesting examples of human ingenuity.
  • Selects one featured event and additional quick hits.
  • Assigns useful categories such as Technology, Space, Medicine, or Transportation.
  • Writes a concise explanation of what happened.
  • Explains why the selected event matters.
  • Preserves a source reference for the historical information.
  • Publishes the finished edition to Amazon S3.
The result is a simple website that is already waiting when you arrive.
There is no prompt box.
There is no Generate button.
The agent does the work while you're away.

The Invented Today daily edition. The website presents a featured historical milestone alongside additional events selected by the AI curator.



Why make it an agent?

The most interesting part of this project isn't the website.
It's the fact that the website doesn't need someone sitting behind it.
A normal AI application waits for a user to provide input. You open it, type something, press a button, and receive a response.
Invented Today has a clock.
Once a day, the workflow wakes up, gathers new source material, makes a new editorial decision, and publishes a new edition.
That small change turns the application from a one-time AI generator into an ongoing process.
The experience I wanted was simple:
Come back tomorrow, and there should be something new waiting.
The daily editions are also stored in Amazon S3. This creates a growing record of what the agent has produced over time instead of treating every invocation as an isolated request.
The architecture remains intentionally small. There is no database and no continuously running server.



How I built it

I started with the historical data rather than the interface.
The agent uses the Byabbe On This Day API as its historical source. For a given date, the API provides a collection of events that happened on that date throughout history.
An individual day can contain dozens of events spanning centuries and completely different subjects.
For example, the August 21 dataset used during development contained events involving technology, transportation, medicine, space, politics, exploration, warfare, science, and many other areas.
The Lambda function first retrieves the historical data and stores the raw response in S3.
This separation is intentional.
The original source material is preserved independently from the AI-generated edition, which makes the workflow easier to inspect and debug.
The historical data is then passed to Amazon Bedrock along with a curation prompt.
The AI curator is asked to look through the available events and select the ones that best fit the theme of human ingenuity.
Rather than asking the model to invent historical facts, the model works from the supplied source material.
Its job is to:
  • Evaluate the available events.
  • Choose the strongest feature.
  • Select additional interesting events.
  • Categorize them.
  • Summarize what happened.
  • Explain why the event matters.
  • Preserve a source reference.
The response is requested as structured JSON so that Lambda can process it reliably before publishing the edition.
This gives the system a useful separation of responsibilities:
The historical API provides the facts.
The application manages the workflow.
Amazon Bedrock provides the editorial judgment.
Amazon S3 stores and publishes the result.

A closer look at an Invented Today edition. The featured event includes its year, category, explanation, significance, and historical source, followed by additional events from the same date.



AWS services and architecture

The deployed architecture uses a deliberately small set of AWS services.

Amazon EventBridge Scheduler

EventBridge Scheduler provides the clock for the agent.
It invokes the Lambda function automatically once every day.
This is what makes Invented Today an always-on agent rather than an application that only runs when someone visits the website.

AWS Lambda

Lambda runs the complete agent workflow in Python.
It:
  1. Determines the current date.
  1. Retrieves the historical events.
  1. Stores the raw source data in S3.
  1. Loads previous edition information where required.
  1. Sends the historical events to Amazon Bedrock.
  1. Processes the structured response.
  1. Stores the generated edition.
  1. Updates  latest.json  for the website.
There is no server that needs to remain running between executions.

Amazon Bedrock

Amazon Bedrock provides the AI layer.
The project uses Amazon Nova 2 Lite as the curator.
The model receives the historical source material and produces the editorial selection and explanations.
I deliberately kept the model's role focused. It isn't responsible for retrieving arbitrary information from the internet or inventing historical events. It works from the historical material supplied by the application.

Amazon S3

S3 serves two purposes in the project.
It provides persistent storage for the agent and also hosts the static website.
The bucket contains:
  • Raw historical data
  • Daily editions
  •  latest.json 
  • Static website files
The website simply reads the latest published edition from S3.
There is no API server sitting between the website and the generated content.

AWS IAM

IAM controls the permissions between the services.
The Lambda execution role provides the required access to S3 and Amazon Bedrock, while the scheduler has permission to invoke the Lambda function.
The overall workflow is:
EventBridge Scheduler
|
| daily trigger
v
AWS Lambda
|
+--------+--------+
| |
v v
Historical API Amazon Bedrock
| Nova 2 Lite
| |
v v
Raw data Curated edition
| |
+--------+--------+
|
v
Amazon S3
/ \
Daily editions latest.json
|
v
Static website
The architecture is intentionally simple:
EventBridge provides the rhythm.
Lambda performs the work.
Bedrock provides the editorial intelligence.
S3 provides persistence and publishing.



A few challenges along the way

  • Image generation availability: Some image-generation models in Bedrock were marked as legacy or unavailable for my account. Instead of making image generation a dependency, I shifted the focus toward the agent’s research, curation, scheduling, persistence, and publishing workflow.
  • Nova 2 Lite inference profiles: Amazon Nova 2 Lite required an inference profile instead of direct on-demand invocation with the base model ID. Once the appropriate profile was configured, the Lambda workflow was able to invoke Nova successfully.
  • Testing the historical API separately: I tested the historical API independently before connecting it to Bedrock and S3. This made it easier to isolate API issues from problems in the rest of the workflow.
  • Lambda execution time: The initial Lambda timeout was too short. The function could retrieve the historical data but timed out while waiting for the Bedrock response. Increasing the timeout allowed the complete workflow to finish reliably.
  • Keeping intermediate data: Instead of storing only the final edition, I also preserved the raw historical response in S3. This makes troubleshooting much easier because I can compare the original source material with the AI-generated result when something doesn’t look right.



What I learned

  • An always-on agent doesn’t need to be complicated. A clock, a model, and persistent storage can turn a simple application into a workflow that continuously produces new work.
  • Each AWS service has a focused role. EventBridge provides the schedule, Lambda runs the workflow, the historical API provides the source material, Bedrock performs the curation, and S3 stores and publishes the result.
  • AI doesn’t have to generate everything from scratch. Invented Today uses real historical data, while the AI focuses on evaluating, organizing, summarizing, and explaining it.
  • Grounding the AI in real source material makes the experience more useful. The creative part comes from the model’s editorial judgment rather than inventing historical facts.
  • An agent changes the user experience. Users don’t need to invoke Lambda, call Bedrock, provide a prompt, or press a Generate button.
  • The goal is simple: come back tomorrow. The agent works in the background and publishes a new edition so there is something new waiting each day.



Try Invented Today

The live application is available here:  Invented Today .
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