I'm a software engineer, Can build the product's that i imagine, and someone who's usually following some problem or idea far enough that it eventually turns into a system.

It's usually more like:

"Why does this problem still exist?"

"Can this be done differently?"

"What if I actually build it?"

And then I figure out whatever I need along the way frontend, backend, computer vision, integration's, AI, infrastructure, automation, distributed systems, product design... whatever the problem asks for.

A lot of the things I've built started either from something I personally wanted, something repetitive I didn't want to keep doing manually, or simply an idea I couldn't stop thinking about.

I'm very much a build-first, understand-deeply kind of person.

I like moving fast,

If something breaks in an interesting way, I'll probably spend more time than necessary figuring out why it broke.

If I'm doing something repeatedly, I'll probably try to turn it into a system.

And if an idea feels useful enough, I usually want to see what happens when it goes beyond a prototype and starts meeting the real world.

That has taken me across AI, product engineering, developer tools, consumer applications, automation, business systems, computer vision, training custom model's and much more creative web experiences, and open source.

🤖 One of the projects that pushed me much deeper into applied AI.

Kwuel started around a simple question: 💡

Can software understand and always keep me in modration level's while enjoying food i want?

That eventually meant building around computer vision, a custom-trained YOLO model, OCR, LLMs, contextual information, smart data retrival and personalized intelligence.

The interesting part for me wasn't just recognizing food from an image.

I wanted the system to understand enough surrounding context like what all i've had in that week and recent day's to become useful over time rather than treating every meal as an isolated event.

It became one of those projects where computer vision, AI, backend systems and product thinking all had to work together rather than existing as separate demos.

(Can have a product demo video here: https://www.youtube.com/watch?v=4KthEm8EyXs)

Benki came from thinking about how differently the internet could feel if it was designed around listening instead of scrolling.

It's an audio-first consumer platform that explores things like: 🎙️

• AI being RJ host to convey internet comment's
• social/community comment's turned into audio
• music discovery
• narration
• background audio, sound and atmosphere
• a feed that feels closer to personalized modern radio

This one taught me a lot about building an actual consumer experience where the technology itself matters much less than whether the whole thing feels right.

Early preview here(currently only view in mobile): https://benkipreview.pages.dev/

At some point I realized that finding genuinely interesting companies and opportunities to work with involved way too much repetitive searching.

So naturally... I started turning that into a system. ⚙️

LookOut continuously looks for signals across startups ecosystem and the internet, then tries to turn those scattered signals into something useful across the news sites and portal's like Ashby, Greenhouse, Hacker News, YC Work at a Startup, Wellfound, and intresting company pages

Think: 🔁

discovery → filtering → scoring → enrichment → AI analysis → action

Instead of searching through dozens of places manually, I wanted one system that fully know about me and my personality and whole context could understand what I was actually looking for and surface the things worth spending time on.

It eventually grew into a much larger automation and intelligence workflow than I originally planned.

As usual. 😄

This haven't made public yet...

This one is different from most of my projects because it isn't just software. 🏢

Shila Murti is a real brand & stone-art business, and I worked on building much of the digital infrastructure around it.

That meant thinking beyond "build a website." 🌐

I worked across things like:

• the web storefront
• backend infrastructure
• payments
• customer flows
• invoicing
• WhatsApp integrations
• email
• automation
• Building visual branding
• operational workflows
• deployment
• branding and the overall digital experience

Building software for a real business changes the way you think.

A technically elegant system isn't enough.

Customers have to understand it. Payments have to work. Operations have to work. Failures actually matter.

That experience probably shaped my product thinking more than most purely technical projects could.

Can visit the store here: https://shilamurti.com/products?sort=price-asc&categories=deities%2Cmarble

I've spent a lot of time thinking about one problem in particular: 🧠

Why do AI agents keep learning useful things and then forgetting them?

Central Memory Unit is my current exploration of that problem.

CMU is an agent-first organizational memory layer built around situational intelligence rather than simply storing more information.

The idea is that agents should remember things like: 📚

• hard-won fixes
• recurring situations
• important constraints
• accepted practices
• costly mistakes
• ownership
• unresolved questions

…but memory should stay quiet when it isn't actually useful.

That led into work around: ⚙️

• agent lifecycle hooks
• memory retrieval
• trust and promotion
• evidence
• Git checkpoints
• review workflows
• MCP
• Codex-style runner integrations
• retrieval evaluation
• team-scoped knowledge

What interests me most here isn't "giving an AI more memory."

It's figuring out when past knowledge should influence the next action — and when it absolutely shouldn't.

→ Central Memory Unit

🔎 This one started because manually researching interesting companies startups that are building something intresing gets old very quickly.

(Like this was earlier than LookOut)

So I built an MCP-based system that can do much of that investigation itself. 🤖

It can work through things like: 🧭

company discovery

↓

company + product research

↓

founder identification

↓

contact enrichment

↓

personalized outreach generation

Instead of giving an agent a single search command, I wanted it to perform an actual end-to-end research workflow, and after it saved to googlesheet, will have a look and decide to what takeover

✨ Sometimes tools you build end up changing your own path in ways you didn't expect.

🎨 Not everything I build is infrastructure or AI.

This project came from wanting to create something much more visual and experiential.

Life Journey of Krishna is an interactive web experience built around storytelling, motion and immersion.

I worked with things like: ✨

• parallax interactions
• animation
• complex visual transitions
• performance and memory optimization
• custom GLSL / graphics work

I like this project because it represents another part of engineering I enjoy:

sometimes software doesn't need to optimize a workflow or solve an infrastructure problem.

Sometimes the goal is simply to make someone feel something while using it.

Can Experince here: https://journyofkrishna.pages.dev/

Some problems apparently don't leave me alone after one project.

Before CMU, I explored agent memory through a couple of other systems.

A persistent memory layer for coding agents built around Entire checkpoints.

It takes large development sessions and distills them into compact, structured memories containing things such as decisions, failed approaches, warnings, root causes and useful insights.

Retrieval then combines signals like semantic similarity, file relationships, error signatures, recency and importance.

The basic idea was: 💡

an agent shouldn't have to rediscover yesterday's debugging session today.

→ Agent Memory

🧭 I also like stepping into systems I didn't design.

There's something very different about contributing to an existing project: you have to understand the assumptions, architecture and constraints that already exist before changing anything.

I've been contributing to Entire CLI, including a couple of changes that have now been merged into main.

🐛 One of the more interesting ones started with finding a concurrency bug where two successful checkpoint writers could still result in completed data being silently lost.

That became: 🛠️

reproduce it deterministically

→ understand the race

→ design the correctness model

→ implement locking + Git compare-and-swap

→ retry from fresh state

→ stress test it

→ merge upstream

also got an credit from security advisory for reporting a vuln privately!

I've also reported other correctness/concurrency issues while digging through the system.

I enjoy this kind of work because there's no greenfield freedom.

The system already exists.

You have to understand it first.

🤖 AI-assisted development has also changed the way I work.

I can move in near light speed than before, but that makes understanding architecture, correctness, integration and judgment even more important — not less.

The goal is to understand the system and ship something that actually works.

🧠 AI agents & memory
⚙️ Developer infrastructure
🏗️ Backend and distributed systems
🔍 System design & debugging
🤖 Automation
📱 Consumer products
🎨 Creative engineering
🚀 0 → 1 product building
🏢 Entrepreneurship
🌍 Open source

I'm especially interested in places where a few of those collide.

I like experimenting. 🧪

A lot.

Some experiments become products. Some become repositories. Some turn into completely different ideas. Some teach me that the original idea was wrong.

That's probably my favorite part of building things. ❤️

I'm still figuring out what I'll work on for the next ten years.

But I'm pretty sure I'll keep doing the same thing I've been doing so far: 🚀

find interesting problems, go deeper than I initially intended, and build something to understand them.