
Weekend Creative Agent Challenge: The Unsent
The Unsent is an autonomous creative archive that gives a voice to perspectives history never recorded. It uses AWS services and Amazon Bedrock to choose a perspective, create a fictional letter, evaluate it and publish it automatically.
Vision
History is full of voices that were never written down.
The astronaut who wanted to tell a sibling what the silence of space felt like. The lighthouse keeper waiting for a sailor who never came back. The engineer who suspected that an invention might outlive its creator.
We know the events. We know many of the people involved. But we rarely get to hear the perspective that history never recorded.
That idea became The Unsent.
The Unsent is an autonomous creative archive that gives a voice to perspectives history never recorded. It creates fictional correspondence around real historical, scientific, and cultural events, then publishes the result as a growing archive.
The important word here is autonomous.
I didn't want to build another application where I have to open a page, enter a prompt, and ask an LLM to write something. The interesting question for me was: what happens if I give the system a creative goal, some boundaries, a memory, and a schedule, and then leave it alone?
The result is a system that wakes up once a day, decides what perspective to explore, checks what it has already explored, generates the correspondence, evaluates the result, and publishes it.
The website is not where the agent runs. It is where I come back to see what the agent decided to create.
Give a voice to a perspective history never recorded.

The generated letters are deliberately presented as fictional correspondence, rather than as historical documents. The creative writing is separated from a Real Story section containing the factual source information behind it.
That separation was important to me. I wanted the system to be creative without blurring the line between what actually happened and what the agent imagined might have been said.

The result is a different way of looking at an archive: the factual event provides the foundation, but the agent chooses an unexplored human perspective and creates something that could never have existed in the historical record.
That became the core idea behind The Unsent:
Real history provides the facts. The agent explores the voice that history left out.
Why The Unsent is Different
At first glance, The Unsent could sound like a daily AI writing tool: give a model a historical event, ask it for a letter, and publish the result.
That isn't really what I wanted to build.
The interesting part is everything that happens around the model.
A normal generator can produce something new every time, but it doesn't necessarily know what it has already explored. The Unsent keeps a persistent Humanity Ledger in DynamoDB so that the agent can remember the perspectives it has previously used and deliberately look for something different.
The agent also doesn't make its creative decisions completely invisible. A perspective is built from several dimensions, including the source, era, geography, role, relationship, emotional theme, narrative perspective, and letter type. The system uses these dimensions when deciding which candidate is the most novel, and the resulting perspective and novelty information can be shown alongside the published work.
Another design decision was keeping fact and fiction separate.
The historical source provides the factual foundation. The letter itself is intentionally fictional. The model is allowed to imagine the voice and emotional perspective, but the application keeps ownership of the factual source information instead of asking the model to invent the underlying history.
Finally, the generated work doesn't automatically become part of the archive just because the model returned an answer. The agent evaluates the result against a quality rubric before publishing it. If the result doesn't meet the required threshold, it can be regenerated with corrective feedback rather than immediately becoming part of the archive.
The overall design principle I kept coming back to was simple:
Let the application make the important decisions, and let the LLM do what it is good at generating the creative language.
That distinction ended up being one of the most important parts of the project. The model is a component inside the agent, not the entire agent.

The Archive is the visible result of this approach. Instead of treating each generation as an isolated response, The Unsent is designed as a growing collection where previous work becomes part of the system's memory and helps influence what it explores next.
What Makes It Autonomous
The biggest change from a normal creative application is that The Unsent doesn't need someone sitting in front of it to create something new.
I set up an EventBridge Scheduler to wake the agent once a day. The scheduled invocation goes to an AWS Lambda function, which runs the complete generation pipeline: it checks the Humanity Ledger, selects a source and perspective, generates the letter through Amazon Bedrock, evaluates the result, and publishes the accepted artifact.

Nobody has to open the website to start this process.
The website is the output of the agent, not the place where the agent runs.
That distinction was important to the project because I wanted to see whether the creative system could continue operating as a small autonomous service rather than behaving like a chatbot that waits for a user prompt.
The execution is also observable. The agent records structured activity as it moves through the pipeline, so I can see what happened during a run rather than treating the final letter as a black box.

The Agent Activity view makes the execution easier to understand from the application itself. It shows the stages the agent went through and the decisions made during the run.
Behind that interface, CloudWatch provides the AWS-side execution record. This was particularly useful while testing the production deployment because I could follow the execution from the initial memory check through source and perspective selection, Bedrock generation, and the final result.
That was the part I wanted to test: could the creative process continue without me sitting in front of the application? The scheduled function has to run a complete, bounded workflow and leave behind a useful result that is available when someone eventually comes back to the site.
For The Unsent, that means the daily cycle can happen independently of the website visitor. The next time I open the archive, I'm not asking the agent to create something. I'm seeing what it already created.
How the Agent Works
The daily run is not a single call to an LLM. It is a sequence of steps, with the application controlling what happens before and after generation.
The basic loop is:
DISCOVER ↓SELECT ↓CHECK MEMORY ↓CHOOSE NOVEL PERSPECTIVE ↓GENERATE ↓SELF-CRITIQUE ↓VALIDATE ↓PUBLISH ↓REMEMBERThe first step is to work with the curated source material available to the agent. From there, the application selects candidates and checks the Humanity Ledger to understand what perspectives have already been explored.
The important part is that novelty is not simply a sentence in a prompt telling the model to "be original." The application calculates novelty before generation and uses that result to make the perspective-selection decision.
Once a perspective has been selected, the agent sends the relevant factual source and creative constraints to Amazon Bedrock. Bedrock generates the creative fields, while the application remains responsible for the surrounding metadata and workflow.
The generated result then passes through the quality and validation stages. If it doesn't meet the configured quality threshold, the agent can retry with corrective feedback. The number of retries is bounded, so a failed generation cannot turn into an uncontrolled loop.
Finally, an accepted artifact is published to S3 and the selected perspective is recorded in the Humanity Ledger.
There is also an important reliability detail here: a repeated run for the same generation date is idempotent. In other words, if the same daily execution is triggered again, it should not create a second copy of that day's artifact in the archive.
That matters for an autonomous system. Scheduled infrastructure can be retried, interrupted, or invoked more than once. The archive should still represent one intentional daily generation rather than whatever happened to be triggered by the infrastructure.
The result is a pipeline where each stage has a defined responsibility:
- Application logic decides what to explore.
- DynamoDB remembers what has already been explored.
- Bedrock generates the creative content.
- Validation logic decides whether the result is acceptable.
- S3 stores the published artifact.
- EventBridge starts the process again on the next scheduled run.
This is what I mean by making The Unsent an agent rather than simply connecting a scheduled Lambda to an LLM.
The Humanity Ledger
The most important part of making The Unsent autonomous was giving it a memory.
Without memory, an agent can generate something interesting today and then unknowingly make almost the same creative choice tomorrow. I wanted the system to have some awareness of what it had already explored and to use that history when deciding what to create next.
That memory is the Humanity Ledger, backed by Amazon DynamoDB.
For each published perspective, the ledger records the dimensions that describe the creative choice: the source, era, geography, role, relationship, emotional theme, narrative perspective, and letter type. These aren't just metadata displayed on the website. The application uses them when evaluating future candidates.
Before generating a new letter, the agent compares potential perspectives against the perspectives already stored in the ledger. It calculates a novelty score using a recency-aware similarity across those dimensions, with the result normalized between
0 and 1 .In simple terms:
-
0.0means the candidate is effectively a repeat.
-
1.0means it is highly different from what has already been explored.
The application then uses these scores to choose a perspective rather than leaving the decision entirely to the language model.
This was an important distinction for me. "Be original" is easy to put into a prompt. Making originality part of the application's decision-making is much harder and much more useful.

The Humanity Ledger also gives the system a persistent memory beyond a single Lambda invocation. When the agent finishes a successful generation, the perspective it used is recorded so that future executions have something concrete to learn from.
There is also a reliability aspect to this memory. The daily publication is designed to be idempotent, so a repeated execution for the same generation date does not simply create another copy of the same artifact.
That means the ledger isn't just a database attached to the application. It is part of the mechanism that allows The Unsent to remember where it has been and make more deliberate choices about where to go next.
Amazon Bedrock Generation
Once the application has selected a source and perspective, Amazon Bedrock handles the creative generation.
I use the Amazon Bedrock Converse API rather than tying the application to a model-specific request format. This gives the generation layer a consistent interface and makes the model configurable rather than embedding a particular model choice throughout the code.
For the production deployment, The Unsent uses Amazon Nova 2 Lite through a global inference profile:
global.amazon.nova-2-lite-v1:0The model ID isn't hard-coded into the application. It is supplied through the deployment configuration and exposed to the Lambda function as the
BEDROCK_MODEL_ID environment variable.This became useful during deployment because I could change the model configuration without changing the generation code.
The model is also not responsible for deciding everything about the artifact. The application supplies the factual source and the selected perspective, while the model is primarily responsible for generating the creative fields.
The expected response is structured JSON rather than unrestricted prose. The application then parses and validates that response before allowing the rest of the pipeline to continue.
This gives me a useful boundary:
The application decides what the agent should explore. Bedrock decides how to express that perspective creatively.
I also deliberately avoid requesting or exposing hidden chain-of-thought. The system only uses the concise agent-facing information needed for the published experience and its execution flow.
This makes the model replaceable without making the rest of the application dependent on a particular model's internal behavior.
Self-Critique and Quality Gate
Generating a letter is only half of the problem. I also needed a way to decide whether the generated result was good enough to become part of the archive.
The Unsent uses a quality rubric that evaluates the generated artifact across five dimensions:
- Factual grounding
- Originality
- Creative quality
- Perspective consistency
- Reply quality
Each dimension receives a score from
0 to 10 . The application then checks the result against the configured minimum quality threshold.For the current deployment, that minimum is 6.0.
If a generation doesn't meet the required quality level, the agent doesn't immediately publish it. Instead, it can send corrective feedback back into the generation process and try again. The number of retries is deliberately bounded — the current configuration allows up to two retries.
This is another place where I wanted the application to have control around the language model. The model can produce the creative material, but the application decides whether that material is acceptable for publication.
The workflow therefore looks roughly like:
Generate ↓Evaluate ↓Pass? ── Yes ──→ Publish │ No ↓Corrective feedback ↓Retry ↓Evaluate againIf the artifact still doesn't pass after the allowed attempts, the agent doesn't keep generating indefinitely and it doesn't publish a failed artifact simply to produce something for the day. The failure is recorded and the archive remains protected from an unsuccessful generation.
That bounded behavior is important for an autonomous system. Once nobody is watching the application, there needs to be a clear definition of what happens when something goes wrong.
For me, this is one of the biggest differences between "an LLM that generates content" and "an application that uses an LLM as part of an autonomous workflow."
The model provides the creative capability. The surrounding system provides the constraints, evaluation, retry behavior and persistence.
AWS Architecture and Deployment
I wanted the infrastructure behind The Unsent to stay small and mostly serverless. There is no always-running application server waiting for someone to visit the site. The agent only consumes compute when the scheduled workflow actually runs.
The architecture is:
EventBridge Scheduler │ ▼ AWS Lambda │ ├──────────────► Amazon Bedrock │ Nova 2 Lite │ ├──────────────► DynamoDB │ Humanity Ledger │ └──────────────► Amazon S3 Published artifacts │ ▼ CloudFront + OAC │ ▼ Public HTTPS siteAmazon EventBridge Scheduler provides the daily trigger. It invokes the Lambda function without requiring a user to start the process.
AWS Lambda runs the actual agent workflow. It handles source selection, memory checks, perspective selection, generation, validation, retries and publishing.
Amazon Bedrock provides the generative capability through the Converse API. The production configuration uses Amazon Nova 2 Lite through a global inference profile.
Amazon DynamoDB stores the Humanity Ledger and gives the agent persistent memory between executions.
Amazon S3 stores the generated JSON artifacts and the static website assets.
For the public website, I added Amazon CloudFront with Origin Access Control (OAC) in front of S3. The S3 bucket is now private rather than publicly readable, and CloudFront is the public HTTPS entry point.
That was a useful improvement beyond simply getting the application working. The final architecture separates the public website from the underlying storage:
Visitor │ ▼CloudFront (HTTPS) │ │ OAC ▼Private S3 bucketThis means the public site can be accessed through a clean HTTPS URL without exposing the S3 bucket directly.
Amazon CloudWatch provides the execution logs, which made it possible to inspect what the autonomous run actually did during testing.
AWS IAM controls access between the components. The Lambda execution role is scoped to the resources the agent needs, including its DynamoDB table, S3 bucket and Bedrock invocation.
I manage the infrastructure through AWS SAM and CloudFormation rather than creating each resource manually. This keeps the infrastructure configuration alongside the application code and makes the deployment reproducible.
The final result is intentionally simple: scheduled serverless compute, managed storage, a managed model API, and a static public site. There is no backend server that needs to stay running just to serve the archive.
That also fits the nature of the project. The agent doesn't need to be running continuously. It needs to wake up, do its work, remember what it did, and leave the result somewhere I can find it.
Key Engineering Decisions
Building The Unsent taught me that the most important decisions weren't necessarily about which AI model to use. They were about where the AI should have control and where the application should have control.
Deterministic logic around the LLM
I deliberately kept important decisions such as perspective selection, novelty calculation, validation, retry limits and publication in application code.
The LLM is responsible for creative language, but it doesn't decide the entire workflow. This makes the system easier to reason about, test and debug.
A curated dataset instead of depending on a live history API
The agent works from a curated dataset bundled with the application rather than depending on an external history API being available every time the scheduled job runs.
That makes the daily generation pipeline more predictable and keeps the factual source material under the application's control.
DynamoDB for persistent memory and idempotency
The Humanity Ledger lives in DynamoDB. It isn't just a storage layer for the website; it is part of the agent's decision-making process.
The daily generation also uses idempotent behavior so that a repeated execution doesn't accidentally create duplicate entries for the same generation date.
A mock generator for development and testing
I also built a mock generation path so the rest of the pipeline can be exercised without making live Bedrock calls.
That makes development and testing much easier because the core application logic doesn't have to depend on a live model invocation every time a test runs.
Static website instead of another backend service
The published site reads the JSON artifacts generated by the agent. There isn't a separate application backend that needs to be running just to display the archive.
That keeps the architecture small and means the infrastructure doing the creative work can remain completely separate from the infrastructure serving the finished result.
Infrastructure as code
Finally, I used AWS SAM and CloudFormation to define the infrastructure rather than manually building the production environment resource by resource.
That became particularly useful as the deployment evolved from a basic S3 website into a private S3 bucket behind CloudFront and Origin Access Control. The infrastructure changes could be made alongside the application rather than becoming a collection of undocumented console settings.
Challenges
Getting the first successful generation was actually the easy part. The harder part was making all the pieces around it reliable enough to run without me.One challenge was making novelty a real algorithm rather than a prompt instruction. Asking a model to "choose something different" isn't enough when the system needs persistent memory and repeatable behavior. I had to make the application compare perspectives using explicit dimensions and use that result when selecting what to explore.
Another challenge was keeping historical grounding separate from creative writing. The system needs enough factual context to make the letter meaningful, but the generated correspondence itself is fictional. Keeping those responsibilities separate helped avoid treating generated prose as historical fact.
I also had to think carefully about idempotency. A scheduled agent can potentially be invoked more than once, so a repeated run shouldn't create duplicate daily artifacts or corrupt the archive. The generation date and persistent ledger are part of that protection.
The deployment itself produced a few useful lessons too. One of the production Bedrock issues was related to the permissions required by the global inference profile used for Nova 2 Lite. The Lambda function could reach Bedrock, but its execution role didn't initially have the required permission on the relevant Bedrock resource. Looking at the actual Lambda error and execution role made the problem much clearer than testing the model only from my local machine.
I also moved the public website from a directly accessible S3 website endpoint to CloudFront with Origin Access Control. That allowed the S3 bucket to remain private while still giving the project a public HTTPS endpoint.
These problems were useful because they changed the project from something that worked in a development environment into something I could actually leave running.
The Part I Didn't Expect
The part I didn't expect was how little of the "agent" actually needed to be left to the language model.
When I started building The Unsent, the obvious assumption was that the interesting part would be getting an LLM to write convincing historical correspondence. It turned out that writing the letter was only one piece of the problem.
The harder and more interesting part was everything around it.
How does the system decide what is worth exploring? How does it know that it has already used a similar perspective? What happens when the model produces something that isn't good enough? What happens if the scheduled execution runs twice? Where does the system remember what it did? And how does the result become available without someone manually publishing it?
Those questions pushed more responsibility into the application itself.
The model became one component in a larger loop:
Memory → Decision → Generation → Evaluation → PersistenceThat changed my definition of an AI agent.
For me, an agent isn't necessarily a model with a complicated prompt or a collection of tools. It can be a relatively small system where the application has a goal, memory, decision-making logic, bounded actions and a way to continue from where it left off.
The other thing that stood out was the role of memory.
A single generated letter can be interesting. But once previous perspectives become part of the next decision, the system starts to feel less like a collection of independent generations and more like an archive that is developing a history of its own.
And finally, making the system autonomous forced me to think differently about reliability. When a human is pressing a button, a failure is obvious. When a scheduled agent runs while nobody is watching, the system needs to know what "success" means, what to do when generation fails, how many times to retry, and how to avoid publishing duplicates.
That was probably the biggest shift for me:
Making an AI application autonomous isn't about removing the human from every decision. It's about designing the system well enough that it knows which decisions should be deterministic, which decisions can be creative, and what to do when either one fails.
The Unsent in the Wild
The Unsent is now deployed on AWS and running as a real application rather than just a local project.
You can explore the live archive here:
The site is served over HTTPS through Amazon CloudFront, with the underlying S3 bucket kept private through Origin Access Control.
The source code and infrastructure are available here:
The live application gives you the user-facing side of the system: the generated Unsent letters, the growing archive, the Humanity Ledger and the Agent Activity view.
The screenshots in this article show those different parts of the system, while the architecture and implementation sections explain what is happening behind them.
What started as an idea for a creative writing experiment ended up becoming something slightly different: a small autonomous system that can make a creative decision, remember that decision, evaluate its own output, and leave the result waiting for me when I come back.
That's what I wanted The Unsent to become.
Not a chatbot that waits for a prompt.
An archive that keeps writing when nobody is watching.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article