AWS Builder Center

Weekend Showcase Challenge: Dear Nowhere

An autonomous agent on AWS Lambda and Bedrock that writes a letter every day to a person who doesn't exist, building a public archive with no human in the loop.

An autonomous agent on AWS Lambda and Bedrock that writes a letter every day to a person who doesn't exist, building a public archive with no human in the loop.
TITLE: Weekend Showcase Challenge: Dear Nowhere
Every day, without anyone asking it to, an agent invents a person who does not exist — a name, one grounding detail about their life, nothing more — and writes them a short, sincere letter. Nobody edits the letter. Nobody approves it. It just gets published, and it stays, building a public, ever-growing archive called Dear Nowhere.
The problem it's solving isn't practical, it's emotional: most "agent" demos are task-completion machines — book this, summarize that, ship this ticket. I wanted to see what an agent looks like when its only job is to notice something small and put it into words, on a schedule, with no human in the loop at all. The result is somewhere between a public art project and a stress test of what a small autonomous system can sustain on its own, day after day, unattended.
Mechanically: once a day, the agent checks who it has already written to (so it never repeats a person), invents someone new, writes them a letter, and re-publishes the whole archive as a website anyone can read.

How I built it

I wanted the loop to be as small as possible: read state, generate, write state, publish. That meant resisting the urge to add a queue, a review step, or a "human approves before publish" gate — the entire point was that nothing waits on a person.
Key decisions:
  • Structured output over free text. The model is instructed to return strict JSON (recipient name, one grounding detail, the letter body, a signature line) instead of open prose. That made the rendering step trivial and let me catch malformed output with a simple retry instead of fragile text-parsing.
  • State lives in the read, not just the write. Before generating, the agent pulls recent recipient names out of DynamoDB and tells the model explicitly not to reuse them. Without that, a stateless "just call the model" version would eventually repeat itself, and the archive would feel less like a living thing and more like a slot machine.
  • Render the whole archive, every time. Rather than appending to a page, the Lambda re-renders the full static site on every run. It's wasteful, in the way a haiku is wasteful — it costs almost nothing at this frequency, and it means the site can never drift from the database.
The main challenge was getting the model to stop writing greeting-card copy. Early prompts produced letters that were technically fine and completely forgettable. What worked was asking for one concrete, specific detail about the invented person's life before asking for the letter, and explicitly banning saccharine language — grounding the emotion in a fact instead of an adjective.

AWS services used

  • AWS Lambda — runs the whole agent loop once a day
  • Amazon Bedrock (Nova) — invents the persona and writes the letter
  • Amazon DynamoDB — stores every letter ever written, and supplies "don't repeat this name" context to the next run
  • Amazon S3 (static website hosting) — serves the public archive
  • Amazon EventBridge — the daily trigger; the only thing that ever "asks" the agent to run
Architecture, start to finish: EventBridge triggers Lambda once a day → Lambda reads recent recipients from DynamoDB → Lambda calls Bedrock to generate a new persona and letter → Lambda writes the new letter back to DynamoDB → Lambda re-renders the full archive and publishes it to S3. No other service, and no human, sits anywhere in that loop.

What I learned across the summer

Going through a full summer of shipping on a deadline — first an idea, then a creative app, then something autonomous — changed what "done" means to me. Early on, done meant "it runs when I click it." By this final build, done meant "it keeps running when I'm not there, and I trust it enough not to check on it."
The biggest shift was learning to design for state, not just for output. A one-off script only has to be right once. An agent that runs unattended has to be right repeatedly, without repeating itself, without drifting, and without a human around to notice when it goes weird. That forced a different kind of discipline: constraining the model's output into strict, checkable structure, and treating the datastore as part of the "prompt" rather than just a place to dump results afterward.
If I could tell myself one thing back in June, it's that autonomy isn't a feature you bolt on at the end — it's a design constraint you should be building around from the first weekend.
Live archive: [paste your WebsiteURL stack output here after deploying]
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