AWS Builder Center

Builder Center

I spent 3 days building a personal AI that watches, remembers and acts

This is a blog post of how I spent my last 4 days starting from 17th to 20th September, 2026 working on my project for the Bharat Builds First Commit Hackathon! Hope you enjoy reading :)

Krish Jaiswal

learning agents, harnesses and trying to build one!
This is a blog post of how I spent my last 4 days starting from 17th to 20th September, 2026 working on my project for the Bharat Builds First Commit Hackathon! Hope you enjoy reading :)
So firstly I didnt have an idea, so I went through YC startup directory, looking at some interesting startups that just got into. I found one - SentientOS (https://sentient-os.ai/) and I just loved the idea.
So while I was studying the product, I found that they are available only for Mac which disappointed me. I had recently switched my primary OS from Windows to Omarchy Quattro and since then it had became my daily driver. So I thought I can basically build SentientOS but for Omarchy Linux.
I wont say my project is on that level but for sure I got a lot done in the last 3 days (while also sleeping 9 hours comfortably lol)
So the idea was the build not another chatbot. Not another app where I manually type everything I want it to remember.
Something that could quietly observe the things already happening on my computer, understand what actually matters, remember useful things, proactively tell me about them, and eventually act on my behalf. And I can now see it alive!!
(Note: I havent named this project yet. So for the rest of the blog, I'll just call my project as SentientOS, so please bear with me :))

The idea

A lot of my actual life already passes through my laptop. Primarily: WhatsApp messages.
Things like:
  • College groups
  • Hackathon messages
  • Links people send me
  • Deadlines
  • Events
  • Forms
  • Random things I tell someone I'll do and then completely forget about.
The problem is that all of this information is scattered. I wanted SentientOS to sit on top of that and do three things:
Perceive. Think. Act.

Perceive

Read information already available locally on my machine.

Think

Figure out what matters, what should be remembered, and what I should probably know about.

Act

Actually do things for me when I ask.
That sounds pretty straightforward when written like this. Building it was not straightforward at all.

Day 1 — Making my laptop understand WhatsApp

The first thing I wanted SentientOS to understand was WhatsApp. I didn't want to use some cloud WhatsApp API where all my messages get uploaded somewhere. The whole point of the project was that as much processing as possible should happen locally.
So I eventually started using wacli, which stores WhatsApp data locally in SQLite. That gave me something extremely useful that now my messages were already sitting on my laptop.
Then I wrote the first version of the ingestion system that reads new messages from the database, groups them by conversation, and processes only messages that SentientOS hasn't seen before. I maintain a marker using the SQLite row ID.
So a cycle basically looks like this:
1
2
3
4
5
6
7
8
9
WhatsApp
↓
wacli SQLite database
↓
Read only new messages
↓
Group by chat
↓
Process
It sounds simple now but it took a surprising amount of time to get the boring details right. Things like:
  • What happens on the first run?
  • What if new WhatsApp messages arrive while a processing cycle is already running?
  • When exactly should the marker advance?
  • What happens if processing crashes halfway?
I ended up taking an upper-bound row ID at the beginning of every cycle and only processing messages between the previous marker and that bound. The marker only advances after processing succeeds.
Not the most exciting part of the project, but probably one of the most important.

Running the first AI locally

For the first intelligence layer I wanted something local. My laptop is not exactly an AI workstation. It is an HP laptop with an 11th Gen i3 and 8 GB RAM.
I installed Ollama and started running a small Gemma model locally. And yes, it is slow. Sometimes painfully slow.
A large WhatsApp conversation in a single chat could take a minimum of 40 seconds and sometimes even 3 minutes!! At one point I ran a full-day stress test and just sat there watching my CPU suffer while the model slowly went through chats.
But this local model had an important job. I didn't need it to be a genius. I needed it to be a privacy layer.
Each conversation gets passed through Gemma4:E2B and classified roughly into:
1
2
3
KEEP
JUNK
SENSITIVE
If something is useful, Gemma creates a compact summary. Random reactions, useless chatter and noise get thrown away. Sensitive information should not leave the machine. Only the reduced useful summaries are allowed to move to the next intelligence layer. That made the architecture much more interesting to me.
Instead of:
1
2
3
My entire WhatsApp history
↓
Cloud AI
it became:
1
2
3
4
5
6
7
8
9
WhatsApp
↓
Local Gemma
↓
Privacy filtering + compression
↓
Small useful summaries
↓
Cloud intelligence
That felt much closer to the kind of personal AI system I actually wanted to use myself.

Day 2 — Memory and proactive intelligence

Once I had useful WhatsApp summaries, I needed SentientOS to actually do something with them. This is where I started using AWS Strands Agents.
The Strands agent receives:
  • existing long-term memory
  • new WhatsApp summaries
  • current context
and decides two things.
First:
Does anything here belong in long-term memory?
Second:
Is there anything useful the user should be proactively told about?
The long-term memory is literally a Markdown file.
1
~/.local/share/sentientos/memory.md
I intentionally kept this extremely simple. I wanted the system to be inspectable. If my AI remembers something about me, I should be able to open a file and see exactly what it remembers.
The memory contains things like:
  • ongoing projects
  • long-running goals
  • recurring responsibilities
  • useful preferences
  • important context
It is explicitly not an activity log. I don't want SentientOS remembering every random message I receive.
The second output is something I call cards: Cards are proactive things SentientOS thinks I should see.
For example:
You have a cloud assignment due.
Or:
Someone sent you a registration form for an innovation challenge.
Or:
There is an event happening that you previously showed interest in.
Each card has a title, body, priority, creation time and ID.
The UI then shows these cards in a feed inspired loosely by the idea behind ChatGPT Pulse. This was the point where the project started feeling less like a collection of scripts and more like an actual product. I could run SentientOS and get a small personalized briefing generated from things that had actually happened in my WhatsApp conversations.

The UI

I wanted the interface to feel completely different from a normal chatbot. If SentientOS is proactive, opening it should not just show:
How can I help you today?
It should already have something useful waiting for you. So the main UI became a visual card-based briefing.
The first screen has a nice look with a small greeting where you can click a button to enter the briefing and then go through the things SentientOS surfaced for you. The things that deserve your attention.
There is also a long-term memory panel where you can directly inspect and edit what the system knows about you.
The source of truth for both the cards and the memory is still just the local files. No hidden database. No mysterious memory service. Just files on my machine.
At this point I thought I was nearly done... then I made the mistake of thinking:
It would be really cool if it could actually DO something.

Day 3 — Giving SentientOS hands

Reading information and creating cards was cool but eventually I wanted to be able to look at a card and say:
Fill that form for me.
And have the AI actually open the browser and do it.
I originally tried Amazon Bedrock AgentCore Browser. That lasted for about five minutes lol
My AWS account kept returning a browser-session quota error. I tried another AWS region. Same thing. So that route was temporarily dead.
Then I discovered Amazon Nova Act.
Nova Act can control browser interfaces using natural-language instructions. Even better, there is a Nova Act MCP server.
So my architecture became:
1
2
3
4
5
6
7
SentientOS agent
↓
AWS Strands
↓
Nova Act MCP
↓
Browser
My whole project is TypeScript, while Nova Act itself is primarily Python. The MCP server saved me from having to rewrite parts of my project. I launch the Nova Act MCP server externally and connect to it from the Strands TypeScript SDK.
The first time the browser actually opened by itself from my TypeScript agent was probably the most satisfying moment of the whole hackathon.
And then immediately everything broke again.

Fighting Playwright, Arch Linux and Hyprland

Nova Act needed Playwright. Playwright tried to install its Linux dependencies using:
1
apt-get
There was one small problem.
Omarchy is based on Arch Linux. There is no apt-get.
I eventually installed just the Playwright Chromium binaries without the Ubuntu dependency installation and told Nova Act to skip its automatic Playwright install. That worked.
The browser opened. Then Nova Act refused to interact with it. The reason being my screen resolution.
I use Hyprland with a tiling setup. Every time Nova Act opened Chrome, Hyprland tiled the window into a narrow area of the workspace, it was seeing something around:
1
810 x 815
and complaining that the viewport was unsupported. I spent way too long trying environment variables, browser sizes, prompts telling the agent not to resize the browser, and basically arguing with my own window manager.
Eventually the stupidly simple solution was to give Nova Act's Chrome window its own class:
1
NovaActBrowser
Then add a Hyprland rule that automatically fullscreens any window with that class.
Suddenly:
1
2
3
4
5
6
7
8
9
Nova opens Chrome
↓
Hyprland detects NovaActBrowser
↓
Automatically fullscreen
↓
Nova gets a proper viewport
↓
Browser automation works
The amount of happiness I got from watching an AI successfully type the word Krish into a Google Form was probably not proportional to the achievement. But after everything required to make that happen, it felt amazing.

The final agent

By this point I had all the individual parts so I created the actual user-facing SentientOS agent. It has tools to:
  • read proactive cards
  • add cards
  • remove cards
  • read long-term memory
  • modify long-term memory
  • get the current date/time
  • control the browser using Nova Act
Now I can say things like:
Add a reminder card that I need to buy vegetables at 4:30 PM.
It checks the current time, calculates how long I have, and adds the card. Then, I can say:
Remove the cloud assignment card.
It looks up the card ID and removes it. I can ask it to change something it remembers about me. And, most importantly, I can ask it to perform browser tasks.

The moment it became real

Today I integrated the agent into the UI. Then I gave it this task.
I asked SentientOS to:
  1. Open Gmail.
  2. Log in with my primary email (which was stored in my memory file)
  3. Find an email containing a blog post (I sent a test email of a blog on the topic - Rust is my favorite programming language, it isnt lol)
  4. Copy the blog content.
  5. Open Hashnode.
  6. Log in using Google.
  7. Open the editor.
  8. Paste the blog post.
And it did it. I just watched the browser move through the workflow. That was the moment where the project crossed a line for me.
It stopped feeling like:
I built an AI that summarizes WhatsApp messages.
And started feeling like:
Oh. This thing can actually operate parts of my digital life.
There are obviously massive limitations.
  • It does not magically understand every application on my computer.
  • Browser sessions still have authentication limitations.
  • The local Gemma model is very slow on my laptop.
  • Memory isn't perfect.
  • Cards can occasionally duplicate.
  • The system currently focuses mainly on WhatsApp as an input source.
  • And I definitely wouldn't trust it to autonomously perform every possible action without confirmation.
But the loop works. And that loop is the part I cared about.
And most importantly I spend 3 days, fully hand coding this project. My use of AI was only chatgpt web to understand how things work and explain me the error messages that occurred. So I am very proud of it, and myself also :)

What SentientOS looks like now

The system currently works roughly like this:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
PERCEIVE

WhatsApp
↓
wacli
↓
Local SQLite
↓
Local Gemma model
↓
Privacy filtering + summarization

THINK

Filtered summaries
↓
AWS Strands Agent
↓
Long-term memory
+
Proactive cards

ACT

User request
↓
SentientOS Agent
↓
Local memory + cards
↓
Amazon Nova Act MCP
↓
Browser actions
That is my submission for Bharat Builds right now.
A project where the AI processes:
what happened → what matters → what should I do about it?
Things that went wrong. A lot. My original architecture changed constantly. There are parts of the code I will definitely rewrite after the hackathon.
But honestly this was pretty fun looking back. I wasn't following a tutorial where I knew the final architecture beforehand. Most of the system exists because I hit some weird limitation and had to find another route around it.

What I would build next

The obvious next step is adding more sources. Right now WhatsApp is the main perception layer but eventually SentientOS could understand:
  • browsing activity
  • email
  • calendar
  • notes
  • terminal activity
  • YouTube history
  • files
  • system notifications
I would also like actions to move beyond browser automation to things like:
  • Opening applications.
  • Managing files.
  • Running local commands safely.
  • Connecting different apps together.
But the thing I care about most is keeping the privacy model intact.
I don't want building a more capable personal AI to automatically mean uploading your entire digital life to a cloud model. The local filtering layer is something I want to keep exploring.
Small local models do not need to be insanely intelligent if their job is simply to protect, compress and route information before a stronger model sees it.

Conclusion - Three Days Later

Three days ago I basically had:
Wouldn't it be cool if my Linux machine had something like a personal intelligence layer?
Now I can open SentientOS and see things it proactively noticed from my messages. I can inspect exactly what it remembers about me, tell it to change that memory, ask it about things it surfaced earlier. And I can also tell it to open a browser and actually do something about them.
There is still a ridiculous amount I could improve.
And right now, as I finish writing this post, the slightly absurd plan is to email this entire article to myself...
...then record SentientOS opening Gmail, reading the email, opening Hashnode, and publishing the post you're currently reading.
Which feels like a pretty appropriate way to finish this hackathon! And also I have to come up with a nice name for this project and not keep calling it SentientOS lol
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