AWS Builder Center
Weekend Creative Agent Challenge: FutureNews AI

Weekend Creative Agent Challenge: FutureNews AI

FutureNews AI is an autonomous AI newspaper that remembers its fictional world, generates the next plausible future event, reviews its own output, and evolves its story over time using AWS

The Newspaper That Writes Itself
Most AI applications wait for a user.
You open the app, enter a prompt, click Generate, and get a response.

For this challenge, I wanted to build something different.
What if an AI application could keep creating even when nobody was using it?
That idea became FutureNews AI, an autonomous AI-powered newspaper that writes headlines from a fictional future.
The creativity behind the project is not just generating futuristic news articles. FutureNews AI maintains a persistent fictional world. Every edition becomes part of its history, and that history influences what happens next.
An early edition might introduce Aethera, a fictional autonomous city powered by AI. A later edition could describe a cybersecurity incident, followed by future stories about regulations, public trust, technological changes, or completely new consequences.
Instead of generating isolated content, the system follows a continuous loop:
Remember → Generate → Review → Save → Evolve
How It Works
FutureNews AI is designed as an always-on creative agent.
The workflow is:
Amazon EventBridge Scheduler → AWS Lambda → DynamoDB Memory → Amazon Bedrock → Self Review → DynamoDB → Next Edition
When the agent runs, AWS Lambda loads the current world state and previous editions from Amazon DynamoDB. This information becomes the AI's memory context.
Amazon Bedrock then generates the next plausible future event. Each edition includes a headline, future date, breaking summary, full news article, background context, new facts, and possible future developments.
The generated event is then reviewed for consistency with the existing fictional world.
Once accepted, it is saved to DynamoDB and becomes part of the world's history.
The next time the agent wakes up, it remembers everything that happened before and continues the story.
AWS Services Used:
Amazon EventBridge Scheduler
EventBridge Scheduler is responsible for waking the agent automatically.
The important idea is that FutureNews AI does not need a user to open the website before something new is created. The agent can run independently and have a new edition ready when the user returns.

AWS Lambda
AWS Lambda runs the backend and coordinates the autonomous workflow.
It handles routes for retrieving the latest edition, browsing previous editions, viewing individual editions, and triggering the generation workflow.
The generation process loads memory, calls Amazon Bedrock, reviews the output, and saves the result.

Amazon DynamoDB
DynamoDB acts as the persistent memory of FutureNews AI.
It stores previous editions and the evolving world state.
Without persistent memory, every AI generation would start from zero. DynamoDB allows one generation to influence the next, turning individual AI responses into an evolving fictional universe.

Amazon Bedrock
Amazon Bedrock provides the generative intelligence behind FutureNews AI.
The model receives the existing world context and generates a new event that fits logically into the previous storyline. It is also used as part of the review process to evaluate whether a proposed event is meaningful and consistent.
Amazon API Gateway
API Gateway exposes the FutureNews backend to the frontend through REST endpoints.
The frontend can retrieve editions without directly accessing DynamoDB and can trigger the agent when required.

AWS Amplify
The React and Vite frontend is deployed using AWS Amplify with GitHub-based deployment.
The interface allows users to view the latest edition, explore the evolving timeline, browse the archive, and trigger a new future event.


Challenges I Faced
The most interesting part of this project was the debugging journey.
Initially, I discovered that endpoints such as /latest and /editions were accidentally triggering the same generation logic as /generate.
That meant simply opening the frontend could create a new edition and invoke Amazon Bedrock.
This was especially problematic for an autonomous application because a read operation was unexpectedly modifying the fictional world's history.
The solution was explicit route handling inside Lambda.
Now, /latest only reads DynamoDB, /editions retrieves the archive, /editions/{id} retrieves a specific edition, and /generate is the only route that triggers the AI agent.
Another challenge came from DynamoDB's Python Decimal values.
When DynamoDB data was passed into JSON serialization while building the AI memory context, the Lambda failed with the error:
Object of type Decimal is not JSON serializable
The fix was to recursively convert DynamoDB Decimal values into standard Python numeric types before the data entered the generation pipeline.
We also encountered differences between Lambda test events and requests coming through API Gateway. The deployed API included paths such as /prod/latest, while Lambda tests used /latest. Normalizing the incoming path solved this deployment issue.
Finally, configuring Amazon Bedrock involved working through model access, permissions, and invocation requirements before successfully running the complete generation workflow.
These challenges taught me that building an autonomous agent involves much more than calling an AI model. Routing, memory, state management, permissions, and error handling are equally important.
What I Learned
FutureNews AI helped me understand the difference between a simple generative AI application and an autonomous agent.
A typical AI application follows:
User → Prompt → AI → Response
FutureNews AI follows:
Scheduler → Agent → Memory → AI → Review → Save → Next Run
The biggest lesson was the importance of persistent memory.
Without memory, AI generations are isolated.
With persistent state, every generation can influence the next one.
That creates continuity, but it also introduces new challenges such as avoiding repetition, maintaining consistency, and carefully separating operations that read state from operations that modify it.
This project also gave me hands-on experience combining multiple AWS services into a complete serverless architecture.
FutureNews AI is an experiment in giving a creative application a memory and a lifecycle.
The agent remembers what came before, decides what could happen next, generates the story, reviews the result, and saves it as part of its history.
Every edition becomes history.
And history shapes the next headline.
Tomorrow's headlines, written before they happen.
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