Inspiration
We noticed something simple but frustrating: our lives are already full of information, but the responsibility of connecting that information is still ours.
A meeting changes in an email. A subscription quietly becomes more expensive. A flight confirmation contains a time that conflicts with something already on the calendar. A deadline appears in a message and gets forgotten because it lives somewhere else.
We already have Gmail for messages, Calendar for events, reminders for tasks, alarms for time, and dozens of specialized productivity tools.
But they mostly operate as separate systems.
What they rarely ask is the question that actually matters:
What does this new information mean in the context of everything else happening in this person's life?
That question became NOVA.
We did not want to build another productivity dashboard that asks people to manually organize their lives. We wanted to build something that works quietly in the background, remembers what matters, connects new information with existing context, prepares what should happen next, and interrupts the user only when there is a meaningful decision to make.
The idea was simple:
NOVA should remember the things people should not have to remember.
What it does
NOVA is a background AI agent that turns scattered information into context, decisions, and plans.
It can understand incoming information, remember important entities and events, detect meaningful changes, prioritize what deserves attention, identify conflicts, prepare plans, and ask the user for confirmation when an action matters.
For example, imagine an email arrives saying that an Adobe subscription is renewing for $59 per month.
A normal email client shows the message.
NOVA remembers that the previous renewal was $49 per month.
It connects the two events and tells the user:
Adobe increased your subscription.
$49 to $59
+$10 per month
+$120 per year
The important part is not the arithmetic.
The important part is that NOVA understood that two pieces of information separated in time belonged to the same story.
The same idea applies to scheduling.
Suppose an email says:
Your meeting has been moved to 4:00 PM.
NOVA checks the calendar and discovers that the user already has another event at 4:00 PM.
Instead of creating another generic notification, NOVA explains the consequence:
Your meeting moved to 4:00 PM, but you already have Gym scheduled at 4:00 PM.
It can then ask what the user wants to do.
Move the Gym session.
Move the meeting.
Keep both.
NOVA can also turn information into a practical plan.
Suppose a flight confirmation says the flight departs at 08:30.
NOVA can connect the flight time with airport requirements, travel time, the user's calendar, and existing commitments to prepare a morning plan.
05:00 — Wake up
05:40 — Leave home
06:25 — Arrive at airport
08:30 — Flight
Instead of simply reminding the user about the flight, NOVA can say:
Your morning plan is ready. Set a 05:00 alarm?
This is the core philosophy behind NOVA:
Do not give people more information. Give them understanding.
NOVA is designed to stay quiet when nothing important is happening and surface only meaningful changes, conflicts, decisions, and plans.
How we built it
NOVA is built with the Strands Agents SDK and Amazon Bedrock.
We designed it as an agent system rather than a traditional chatbot because the problem is not simply answering questions. NOVA needs to continuously understand information, connect it with memory, reason over consequences, use tools, prepare actions, and remember what happened afterward.
The core workflow is:
Collect
Understand
Resolve
Compare
Prioritize
Plan
Act
Remember
The workflow is coordinated by an orchestrator and supported by specialized agents.
The Inbox Analyst understands incoming information and extracts meaningful signals.
The Change Detector compares new information with historical context and identifies what actually changed.
The Attention Prioritizer determines whether something deserves the user's attention or should simply remain in the background.
The Planner turns appointments, deadlines, travel information, and other events into actionable plans.
The Conversation Agent allows the user to interact with NOVA and ask questions about what it knows and why something matters.
The system also has a tool layer for persistent memory, entity resolution, change detection, calculations, planning, calendar operations, notifications, and other deterministic operations.
We intentionally keep deterministic work in code.
For example, when a subscription changes from $49 to $59, the financial impact is calculated by software rather than asking a language model to perform arithmetic. This makes the result reliable and traceable.
NOVA also treats incoming email content as untrusted input.
We implemented injection detection, permission boundaries, scoped tools, confirmation tokens, and human approval for consequential actions.
The result is an agent that can operate autonomously while keeping the user in control of important decisions.
We also built a complete product layer around the agent, including persistent storage, APIs, a React and Vite frontend, multilingual support, explainability, realistic demo scenarios, and automated testing.
Challenges we ran into
The hardest part of NOVA was not getting an AI model to understand an email.
The difficult part was making the system understand that one piece of information is rarely the complete story.
The same subscription, person, appointment, or event can appear in completely different messages.
For example, NOVA may receive a new Adobe billing email today and have an older Adobe renewal stored in memory from months ago.
The system needs to understand that both refer to the same subscription before it can recognize the price change.
This required persistent memory and deterministic entity resolution instead of relying entirely on the language model.
Another major challenge was deciding what deserves attention.
If NOVA notified the user about everything it found, it would simply become another source of noise.
We therefore separated information from attention.
Finding something does not automatically mean interrupting the user.
A newsletter can remain in the background.
A changed meeting that creates a conflict should be surfaced.
A significant subscription increase should be surfaced.
A flight disruption should be surfaced.
A routine message should often be ignored.
Another challenge was making autonomous agents safe.
Email content is untrusted input, and an email could contain instructions attempting to manipulate an AI agent into performing an unrelated action.
We therefore built injection detection, permission boundaries, scoped tools, confirmation tokens, and human approval for consequential actions.
Our principle is simple:
The agent can reason autonomously, but the user remains in control.
The final challenge was turning understanding into useful action.
It is easy to build an AI that says:
You have a meeting conflict.
It is much harder to build one that understands what changed, what conflicts, what the consequence is, what options exist, and what should happen next.
That transition from answering questions to intelligently preparing actions became one of the biggest engineering challenges in NOVA.
Accomplishments that we're proud of
We are especially proud that NOVA evolved beyond a collection of AI features into a complete agent architecture.
One of our favorite scenarios is the Adobe subscription example.
The agent receives new information, searches its memory, resolves the subscription entity, compares historical information, calculates the financial impact, determines that the change matters, and produces an explanation.
The user does not have to remember the previous price.
NOVA does.
We are also proud of the calendar reasoning.
A moved meeting is not useful information by itself.
NOVA asks:
What else does this change affect?
That shift from reading information to understanding consequences is what we wanted to demonstrate.
Another accomplishment we are proud of is the safety architecture.
We intentionally avoided giving an AI unrestricted control over a user's digital life.
NOVA can analyze, remember, compare, prioritize, and prepare.
When an action has meaningful consequences, it asks.
We believe that combination of autonomy and boundaries is essential for a trustworthy personal agent.
We are also proud that NOVA is designed as a complete product rather than only a technical proof of concept.
It has agent orchestration, persistent storage, APIs, integrations, security, multilingual support, explainability, frontend experience, realistic end-to-end scenarios, and automated testing.
The result is something people can actually interact with rather than an isolated model demonstration.
What we learned
Our biggest lesson was that context is more valuable than conversation.
When people hear "AI assistant", they often imagine a chat box.
But the most useful AI may not be something we constantly talk to.
It may be something that quietly understands what is happening and speaks only when necessary.
We also learned that agentic systems require a different mindset from traditional applications.
Traditional software often follows:
Input → Rule → Output
NOVA needs to handle:
Input → Context → Reasoning → Tools → Memory → Decision → Human approval → Action → New context
We learned that deterministic software and AI reasoning work best together.
The model is excellent at understanding ambiguous human information.
Code is excellent at calculations, permissions, persistence, and predictable operations.
NOVA combines both instead of asking an LLM to do everything.
Most importantly, we learned that a good agent is not the one that does the most.
It is the one that knows what to remember, what to connect, what to do, and when to stay quiet.
What's next for NOVA
The hackathon version is the beginning, not the end.
Our next goal is to turn NOVA from a powerful prototype into a trustworthy personal context layer.
We want NOVA to connect more deeply with Gmail, Google Calendar, reminders and alarms, travel services, subscriptions, task management, messaging, and other everyday services.
The long-term vision is for NOVA to become the layer that connects these fragmented systems.
Instead of users constantly moving information between applications, NOVA would understand the relationships between them.
A changed email could update a plan.
A calendar change could reveal a conflict.
A subscription change could reveal a financial impact.
A flight delay could reshape the user's schedule.
A deadline could become a realistic plan.
And when everything is fine?
NOVA stays quiet.
We also want to expand NOVA's memory, improve personalization, strengthen evaluation and observability, and explore production deployment with Amazon Bedrock AgentCore.
Ultimately, we do not want NOVA to become another application people spend their day managing.
We want it to become the opposite:
A system that manages the small things so people can spend their attention on the things that actually matter.
NOVA
Remember the things you shouldn't have to.
Built With
- agentcore
- agents
- amazon
- api
- bedrock
- fastapi
- gmail
- python
- react
- sdk
- sqlalchemy
- sqlite/postgresql
- strands
- typescript
- vite
Log in or sign up for Devpost to join the conversation.