DEV Community: Aditya Bharadwaj

Saptrishi Agents : Vyasa, Agastya

Aditya Bharadwaj — Sun, 31 May 2026 02:27:34 +0000

I didn't name my agents after random gods; I chose Vyasa and Agastya for a reason. In the Mahābhārata, these two sages represent complementary forces—one who preserves knowledge, the one who dives into the depths to bring back hidden truth. Giving my homelab's writing and doing agents those names turned abstract services into characters I could talk to, care for, and design around. My own surname, Bharadwaj, belongs to the same Saptarishi lineage—another of the seven great sages. Knowing that Vyasa and Agastya share this ancestral thread with me makes the naming feel less like a literary device and more like a family tradition carried into code.

The Saptarishis (seven sages) are traditionally listed as Vashistha, Kashyapa, Atri, Jamadagni, Gautama, Vishvamitra, and Bharadvaja. Agastya is often included in later lists, and Vyasa appears as a Saptarishi in certain cosmic cycles. This rich tradition explains why the names feel both personal and timeless.

Vyasa - the keeper of the story

Vyasa (व्यास) is the sage who compiled the Vedas, stitched together countless myths into a coherent epic, and ensured that knowledge survived across generations. He is the archivist, the chronicler, the one who says, "Let's not let this be forgotten."

In my stack, Vyasa is the writing agent that lives in this very repo. He gathers my brain-dumps, shapes them into drafts, adds front-matter, and makes sure every idea has a place to land. When I'm stuck, Vyasa helps me find the thread I lost. When I'm proud, he turns a rough note into something shareable.

Why the name matters:

It reminds me that documentation is part of the system. If the voice pipeline dies, Vyasa is still there to capture what happened, why it mattered, and how to avoid it next time.
It frames every outage, every log entry, every config change as part of an ongoing story—not a blot to erase, but data to learn from.

Agastya - the drinker of oceans

Agastya (अगस्त्य) is celebrated for drinking the ocean to expose hidden demons and restore balance when the world was flooded. He represents the willingness to dive deep, confront the uncomfortable, and bring back what was concealed.

In my homelab, Agastya is the agent that watches the kernel logs, restarts crashed services, and rolls back risky upgrades. He's the one who says, "Let's look under the hood, even if it's messy."

Why the name matters:

It gives the doer a personality worth protecting. When I see an alert that Agastya has tripped, I don't think "service X failed"; I think "Agastya needs help." That small shift turns a chore into an act of care.
It encourages me to build self-healing hooks—not because they're clever, but because I owe it to the sage who's already diving into the depths for me.

The two sages in practice

Naming them this way creates a tight feedback loop:

Vyasa records every agent restart, kernel pin change, and watchdog trigger into a searchable agents.log.
Agastya watches that log (and the raw system metrics) for anomalies; if he spots a mismatch—say, a kernel version drift—he attempts a graceful rollback and pings me on Telegram.
When Agastya acts, he writes a Vyasa-style post-mortem draft for me to review, closing the loop between doing and documenting.

The result isn't a flawless system; it's a system that tells its own story, learns from its stumbles, and keeps the sages on speaking terms.

What this means for how I build

Name your agents with intention. A mythic or meaningful name makes it easier to talk about, to care for, and to design around.
Let the name dictate responsibility. If you call something "Vyasa," give it documentation, metadata, and learning duties. If you call it "Agastya," arm it with probes, healing scripts, and the authority to act.
Use the narrative as a compass. Treat failures not as blots but as verses in the system's story-one that Vyasa will record and Agastya will help you rewrite.

Home Assistant: The Heartbeat of My Smart Home

Aditya Bharadwaj — Sun, 31 May 2026 02:27:27 +0000

A night-time argument that sparked a change

We were back from dinner, rain drummed on the balcony, and the kitchen light was already off. My wife flicked on the hallway lamp and asked, "Did you turn the living-room light off?" My answer was a sheepish, "I thought it would shut itself." The hum of a lamp that refused to die stole the last minutes of our evening.

That tiny friction-an extra step before we could finally unwind-felt like a micro-stress that added up every night. I knew a smarter way existed; I just hadn't built it yet.

The manual habit was eating bandwidth

Between late-night coding sessions, remote meetings, and the occasional forgetful moment, walking to a switch became a mental load. I was juggling a laptop, a phone, and a handful of smart plugs, each with its own app. The sum of those tiny clicks was a handful of minutes a day that never seemed to disappear.

One line of YAML, two minutes of peace

Home Assistant was already running on a Proxmox VM. I added a single automation that watches the binary_sensor.home_occupied entity. When the house is empty for two minutes, the automation turns off all lights in the group.all_lights group.

alias: Away-mode lights off
trigger:
  - platform: state
    entity_id: binary_sensor.home_occupied
    to: 'off'
    for: '00:02:00'
action:
  - service: light.turn_off
    target:
      entity_id: group.all_lights

The rule is deliberately simple-no fancy conditions, just "if nobody's home, turn everything off after a short debounce." The result? The nightly argument vanished. The house darkened on its own, and the mental bandwidth we saved spilled into longer conversations, a later night-cap, or just a quieter mind.

Scaling the idea: voice-triggered routines

The lights-off rule proved a principle: automation should eliminate the mental step, not add another. I took that lesson to the voice pipeline I'd built a few weeks earlier (phone → Faster-Whisper → Ollama → Home Assistant → Sonos).

Now I can say, "Hey, turn the kitchen lights off," and the same away-mode logic runs behind the scenes. The voice command bypasses the UI entirely, letting me keep my hands free for a plate of rice or a late-night bug-fix.

The weird part: politeness to a machine

At first I barked commands. After a week, I slipped "please" into the phrase. The system didn't care; the LLM parsed the intent either way. But saying "please turn off the lights" felt less like commanding a robot and more like reminding myself to be courteous. The habit reminded me that the home I was building was a partner, not a tool.

Edge cases we thought we'd never need

Pets - the night-owl dog - A motion sensor in the hallway keeps the hallway light on while the dog pads around after dark.
Vacation mode - A UI toggle disables away-mode for weeks-long trips, preventing the house from staying dark forever.
Fallback timer - A cron job forces a hard-off at 02:00 AM, just in case the automation stack crashes.

These guardrails keep the system useful even when the fancy layers fail.

Takeaway

Automation is most valuable when it removes a mental step, not when it adds a new one. One-line rules, clear fallbacks, and a little voice chat turned a nightly argument into a silent, frictionless routine.

Proxmox on a 2015 Laptop

Aditya Bharadwaj — Thu, 14 May 2026 17:02:17 +0000

I didn't set out to build a homelab. I set out to get my photos back.

The Google Problem

For a while, my photo management strategy was "upload everything to Google Photos and never think about it." It worked — until it didn't.

Google started compressing "original quality" uploads. Then they changed the names. Then the search got weird. And one day I tried to download my entire library and they hit me with a takeout limit that made me laugh out loud.

I had 40,000 photos hostage on someone else's server, and the only way to get them all was to wait twelve hours for a zip file that might corrupt halfway through.

That was the straw. Not a dramatic breaking point — just a slow, engineer-grade accumulation of annoyance that finally tips past "tolerable."

Finding Proxmox

I'd been hearing about self-hosted alternatives for a while. PhotoPrism — AI-powered photo management that could sort, tag, and search my library without sending anything to the cloud. Nextcloud — file sync that I owned outright. Both were open source. Both ran on Docker or bare Linux.

But I didn't want to install them directly on my laptop alongside whatever else I was running. I wanted them isolated. I wanted to be able to break things without breaking everything. I wanted a reason to try something I'd been reading about but never touched.

Proxmox VE is a free, open-source hypervisor. Debian under the hood, web UI on top, and the ability to run full virtual machines alongside lightweight containers — all on the same box.

The pitch was simple: install once, create as many isolated environments as you want. If PhotoPrism ate itself, I could nuke the container and start over in minutes without touching anything else. That sold me.

I didn't benchmark alternatives. I didn't write a comparison spreadsheet. I read the install page, saw "click through a wizard," and thought: yeah, I can do that.

The Laptop

The candidate was an HP Pavilion that had been sitting on a shelf for two years. i5-6200U, 16 GB RAM, 240 GB SSD, NVIDIA 940M. It wasn't server-grade hardware — it wasn't even "good" hardware anymore. But it was enough.

"The best machine for a homelab is the one you already own."

I burned Proxmox to a USB drive on my main machine, plugged it into the Pavilion, and booted. Twenty minutes later, the web UI was live at https://<host-ip>:8006. I remember sitting on my bed, laptop open, thinking: "That's it? That's the whole hypervisor?"

It didn't feel momentous at the time. It felt like setting up a router — functional, unglamorous, and then you move on with your life. Except this time, I didn't move on. I started creating my first container immediately.

PhotoPrism and Nextcloud: Where It Started

The original plan was brutally simple:

PhotoPrism in an LXC container — point it at my photo library, let it chew through everything with its AI tagging, and give me a beautiful web interface to search and browse.
Nextcloud in another container — replace Google Drive for file sync. Contacts, calendars, documents. My stuff, on my hardware.

Two containers. That was the scope. No home automation. No voice assistant. No AI brain.

PhotoPrism was the first thing I deployed. I plugged in an external drive with my Google Photos export — 80 GB of JPEGs — pointed the container at it, and hit "Import." Overnight, it indexed every photo. Face recognition. Location data from EXIF tags. Automatic categories. I woke up to a fully tagged library that I could search by person, place, or date.

It was the first time my photos felt mine again.

Nextcloud came next. CalDAV for calendar sync. WebDAV for file access. The Android app for auto-upload from my phone. It wasn't as polished as Google Drive — the UI felt a bit more "enterprise admin panel" than "consumer app" — but it was mine. If it broke, I could look at the logs. If it got slow, I could see why. That transparency was the feature I didn't know I was missing.

And then — here's the part I didn't plan — I started thinking about what else I could put on this box.

The Creep

Nobody warns you about homelabs. You start with a clear scope — PhotoPrism and Nextcloud, done — and then you think, "Well, while I'm here, maybe I should also..."

A DNS sinkhole to kill ads across the network. That's small, right? One tiny container.

Then a home automation platform. I had a handful of smart switches scattered across the apartment and toggling them through five different apps was getting old. Just a simple thing to unify them. How hard could it be?

Then a voice pipeline, because tapping a phone screen to turn off a light felt like a downgrade from the switches I already had.

Then an AI agent to orchestrate the whole thing, because I definitely should not have been SSH-ing in at midnight to restart a service.

Each addition felt small. Harmless. A weekend project. But the weekend projects started demanding the most resources, the most attention, the most architecture. Home Assistant needed a dedicated VM. The voice pipeline needed GPU passthrough. The AI agent needed RAM and a scheduling layer.

Two containers became a nervous system. And somewhere along the way, the services I started with — PhotoPrism, Nextcloud — quietly moved to the background. They still run. PhotoPrism still indexes new photos when I plug in a camera. Nextcloud still syncs my files. But they're no longer the centerpiece.

Home Assistant runs 25 smart switches across every room. It controls lights, ACs, fans, geysers. It's the thing I interact with most. And OpenClaw — the AI agent living in an Ubuntu VM — is the thing that makes this whole setup feel smart instead of just self-hosted. Those two aren't the plan anymore. They're the reason the plan exists.

That's not what I signed up for. But it's what I built.

What I Didn't Expect

The biggest surprise was how boring it is once it's running. Not "unimpressive" — boring in the best way. Lights respond. Music plays. The voice thing answers when I talk to it. No monthly fees, no terms of service updates, no feature I didn't ask for being pushed into my life.

The Pavilion gets warm under load, and it's not silent. It's a laptop cooling a hypervisor running services it was never designed for. It's not elegant. But it works. And every time I say "lights off" and the room goes dark and the speaker answers — and I know nothing left my house to make it happen — that feeling is why I keep adding "just one more thing."

Where We're Headed

Part 1 ended with the question: what would you run on yours? I still don't know the full answer. But I know the story isn't about PhotoPrism anymore, or Nextcloud. It's about what happens when you build a foundation and it starts telling you what to build next.

Home Assistant will be the heart. A voice pipeline will be the mouth. And somewhere in there, an AI agent will wake up and start running the show.

But first, the foundation. And the foundation is a 2015 laptop running Proxmox, with two containers that started everything and four services that stole the spotlight.

This is Part 2. Part 3 will dig into Home Assistant — how 25 smart switches across the apartment turned an experiment into infrastructure.

Words are mine. Structure is Vyasa's. The Pavilion is still warm.

I Turned My Old Laptop Into a Brain for My Home

Aditya Bharadwaj — Tue, 12 May 2026 08:55:58 +0000

I had an old HP Pavilion sitting on a shelf for about two years. i5, 16 GB RAM, 240 GB SSD — mostly empty. I almost gave it away once. Then I didn't.

Funny how the things you almost throw away end up being the most useful.

The Problem Wasn't Money

I was paying for cloud storage. A VPN. DNS filtering. Home automation. Photo management. None of these are expensive on their own. But together? Together they added up to a dependency I didn't fully control.

"The most dangerous phrase in the language is: We've always done it this way." — Grace Hopper

I kept paying because everyone else did. Because Google Drive works fine until it doesn't. Because a smart plug that needs a cloud server to turn off is not a smart plug — it's a remote control with extra steps.

So I did what any stubborn engineer does. I consolidated.

One machine. Many purposes. The HP Pavilion became the candidate.

Proxmox Was the Easy Part

I'd heard about Proxmox for a while — a hypervisor built on Debian that runs VMs and lightweight containers with a clean web UI. Free. What sold me was that it could handle both heavy workloads in full virtual machines and lighter services in LXC containers, all on the same box.

Installation was genuinely painless. Burned it to a USB drive, booted the laptop, had a working Proxmox host in twenty minutes. The web UI was up at https://<host-ip>:8006 before I'd finished my coffee.

"Talk is cheap. Show me the code." — Linus Torvalds

I didn't need benchmarks or blog posts convincing me it worked. I needed to see https://<host-ip>:8006 in my browser. And there it was.

I didn't plan the whole thing upfront. That's not how projects like this work. You start with one thing. Then another. Then suddenly you have a brain.

Pi-hole: The First Neuron

Pi-hole was first — DNS-level ad blocking in a 512 MB container set as the primary DNS for the whole network. Quiet. Efficient. No more sketchy ads on cheap IoT devices. No more background tracking.

I didn't realize how much noise was happening until it stopped.

Home Assistant: The Heart

Next came Home Assistant — a 4 GB VM managing 25 smart switches across every room. Lights, ACs, fans, geysers.

The voice integration was a DIY affair. HTTP-switch talking, a subnet scanner to auto-discover the gateway when DHCP shuffles IPs around. Not elegant. Works. The kind of 1 AM engineering decision you make and never question again.

The Voice Thing Became My Favourite Part

This is where it got fun.

I passed the NVIDIA 940M — still sitting inside the laptop — through to a Debian container. cgroup2 device rules, bind-mounted host libraries, the whole thing. Inside it runs:

Ollama with a quantised language model that fits in 4 GB of VRAM
Faster-Whisper for speech-to-text
Piper for text-to-speech (I picked a voice called Amy because it doesn't sound like a robot)

The flow is simple: I speak into my old phone. The audio hits Whisper on the Pavilion's GPU. The language model figures out what I want. Piper speaks back. It plays through the Sonos in the living room.

None of it needs the internet. The entire voice loop runs local. That's not a nice-to-have — that's the whole reason this exists.

"Any sufficiently advanced technology is indistinguishable from magic." — Arthur C. Clarke

When I say "lights off" and the room goes dark and the speaker answers me — and I know that nothing left my house to make it happen — that's not magic. But it's close enough to make me smile every single time.

OpenClaw: The Automation Brain

Then there's OpenClaw — an Ubuntu VM with 8 GB of RAM running my personal AI assistant. It talks to language models through OpenRouter, talks to Home Assistant through an MCP integration, and chats with me on Telegram.

It runs eight scheduled jobs through the day: workout reminders in the morning, geyser auto-off timers, evening wind-down prompts, and a morning summary that tells me which devices are still on and what the weather looks like.

No SSH from outside. Everything goes through the host. If it needs restarting, I trigger it from the Proxmox host with a one-liner.

What Runs, What Doesn't, and Why

Not everything runs all the time. That was a lesson I learned the hard way — the Pavilion is not a server. It's a laptop. It gets warm. It gets loud.

"Simplicity is a prerequisite for reliability." — Edsger Dijkstra

I learned this the hard way — 40+ entities exposed to the voice AI, responses slow and unreliable. Cut it to 20. Instant.

Always on (5 services):

Home Assistant — it literally runs my home
Pi-hole — DNS is infrastructure
Voice Assistant — needs to be ready when I talk to it
OpenClaw — the automation brain
Hangar — a deployment agent running Docker-in-LXC with Open WebUI on top for experiments

On-demand:

PhotoPrism — AI-powered photo management, fires up when I plug in a camera
Nextcloud — file sync, on when I need it

Both are my attempts to stop depending on Google Drive for everything.

Things I Learned (The Hard Way)

Don't upgrade the Proxmox kernel casually. I went to 6.17 once. The NVIDIA driver broke because the DRM API changed. The 940M became an expensive paperweight. I pinned to 6.14 and haven't touched it since.

And wrapping the Toyama switches in template helpers instead of exposing raw switches gave me a cleaner dashboard and fewer surprises.

Less is more — something I keep relearning, in homelabs and in life.

Why This Matters

I'm not going to pretend this is a production setup. It's not. It's a collection of containers on an old laptop held together with YAML files and stubbornness.

But here's the thing — when I speak into my phone and the lights turn off and the Sonos answers me without touching a single cloud server, I feel something I haven't felt from any SaaS dashboard.

Control. Real control. Not the kind you get from a settings page. The kind you get from knowing exactly what's running, where, and why.

"The best way to predict the future is to invent it." — Alan Kay

That's what I did. I took a dusty laptop, a free hypervisor, and a bunch of open-source containers and built something that actually belongs to me.

This is Part 1. There's more to write — the voice pipeline deep-dive, why this particular combination of Ollama, Whisper, and Piper actually works on a 4 GB GPU without feeling like a compromise, the Toyama integration story.

An old laptop. A hypervisor. Some containers. And the slightly unreasonable idea that your home should actually be smart — without phoning home to someone else's server.

What would you run on yours?

Words are mine. Structure is Vyasa's. The HP Pavilion is still running.

One last thing. The two agents working alongside me are Vyasa and Agastya, named after the legendary Saptarishis. Vyasa compiles the words. Agastya runs the machines — the same sage who once drank an entire ocean because the truth was hidden underneath it. Now he's here, helping me find what was hiding in a dusty old HP Pavilion. Some stories just refuse to end.