
Weekend Creative Agent Challenge: Tomorrow Me — An AI Agent That Prepares Me for Tomorrow
Tomorrow Me is a autonomous AI agent that prepares you for tomorrow every evening. It observes your Google Calendar, tasks, weather, and past feedback, performs deterministic scheduling analysis, and uses Amazon Bedrock to generate a concise "Tomorrow Brief" with priorities, preparation tips, warnings, and recommendations. Built with React, Python, AWS Bedrock, Lambda, DynamoDB, and EventBridge, with mock providers for seamless development.
What if an AI agent didn't just answer questions when I asked it something, but quietly worked in the background and prepared me for tomorrow?
That was the idea behind Tomorrow Me, my project for the Weekend Creative Agent Challenge.
The problem I wanted to solve is simple: calendars and task managers tell us what is coming, but they don't necessarily tell us what deserves our attention tonight.
Tomorrow Me is an autonomous agent designed to answer one question every evening:
What should I know and prepare tonight so tomorrow goes smoothly?
What I built
Tomorrow Me collects context about the user's upcoming day and turns it into a concise, actionable briefing.
The agent can consider:
- Tomorrow's calendar events
- Pending tasks
- Task priorities and deadlines
- Repeatedly postponed tasks
- Weather
- User preferences
- Previous briefings
- Agent memory
- Feedback from previous briefings
Instead of simply dumping all of that information back to the user, the agent tries to identify what actually matters.
For example, if I have a presentation at 2 PM, several meetings before it, and a task that has already been postponed twice, Tomorrow Me might tell me:
Prepare tonight: Spend 30 minutes reviewing the presentation.
Watch out: Your morning is meeting-heavy, leaving little preparation time.
Main priority: Prepare the presentation.
The goal is not to create another productivity dashboard. The goal is to give me a small amount of useful information at exactly the right time.
How the agent works
One of the key design decisions was to avoid sending everything to an LLM.
The agent follows this pipeline:
Observe → Analyze → Reason → Generate → Reflect → Store Memory
First, the Observe stage collects the available context.
Then Analyze uses deterministic Python logic to identify things such as calendar conflicts, back-to-back meetings, free preparation windows, overdue tasks, tasks due tomorrow, and repeatedly postponed tasks.
I deliberately kept these calculations outside the LLM.
There is no reason to ask an expensive AI model whether two calendar events overlap when Python can determine that reliably! The AI is used for the part that is harder to express as deterministic rules: deciding what actually matters, what the user should prepare tonight, what might create stress tomorrow, and which information can be ignored.
Finally, the agent generates a short Tomorrow Brief and runs a lightweight reflection step. The reflection can identify whether the briefing was too long, repetitive, or not actionable enough. Useful information is persisted as agent memory so future executions can use it.
Building it local-first
I initially considered starting directly with the AWS infrastructure, but I decided to build the application local-first.
The local application uses a React + TypeScript frontend and a Python backend. I also created provider abstractions so external services can be replaced with mocks during development.
For example:
CalendarProvider
→ MockCalendarProvider
→ GoogleCalendarProvider
and:
BedrockService
→ MockBedrockService
→ AWSBedrockService
This means the entire agent can run locally with mock data before any cloud infrastructure is required.
I also integrated Google Calendar through OAuth so the local application can eventually work with real calendar data rather than only sample events.
This architecture turned out to be useful because it separates the actual agent logic from the external services supplying the data.
AWS architecture
After getting the local agent working, I added AWS as the deployment layer.
The production architecture uses:
- AWS Lambda for the agent/backend execution
- Amazon API Gateway for the API
- Amazon DynamoDB for persistent application data and agent memory
- Amazon Bedrock for higher-level AI reasoning
- Amazon EventBridge Scheduler for the daily autonomous execution
- Amazon SES for delivering the Tomorrow Brief by email
- Amazon CloudWatch for logging and observability
The eventual flow is:
EventBridge Scheduler → Lambda → Observe → Analyze → Bedrock Reason → Generate → Reflect → DynamoDB → SES
The scheduled agent can eventually run every evening at 9 PM in the user's configured timezone.
For local development, however, the same orchestration can be triggered manually.
This separation was important to me because I wanted AWS to be a deployment target rather than something that made local development unnecessarily complicated.
What broke along the way
One of the challenges was realizing that building an agent is not the same as simply connecting an LLM to a few APIs.
There are many failure points: missing calendar data, invalid AI responses, authentication problems, external API failures, persistence errors, and model availability.
I therefore added fallbacks and validation throughout the system.
The Bedrock response is expected to be structured JSON rather than free-form text. If the model produces invalid JSON, the application can retry and fall back instead of allowing one malformed response to break the entire agent run.
I also had to think carefully about credentials. Google OAuth tokens, AWS credentials, API keys, and environment variables should never become part of the repository. The project therefore uses configuration and
.env.example files while keeping secrets out of Git.Another lesson was that the AI model shouldn't be responsible for everything. Moving simple reasoning into deterministic code made the system easier to test and made the LLM's role much clearer.
What I learned
The biggest lesson from building Tomorrow Me is that an effective agent is more than an LLM call.
The interesting part is the system around the model:
- What information does the agent observe?
- What can be determined without AI?
- How does the agent remember previous interactions?
I also learned that building locally first can make cloud architecture much easier :))
Once the core agent was separated into providers, services, repositories, and orchestration, AWS became an implementation detail rather than the foundation of the entire application.
That made it possible to test the idea quickly, keep development costs low, and still have a path toward a fully autonomous AWS deployment.
What's next
The next step is to polish the application, and continue improving the agent based on real usage.
Eventually, I want Tomorrow Me to become something I genuinely rely on every evening—not because it tells me everything happening tomorrow, but because it tells me the few things I should prepare for tonight.
Project
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article