I Built My Own AI Operating System. Here's Why…

The system I needed didn't exist. So I built it…

My curiosity runs fast and wide. Always has. I can have four active projects, a full inbox, and a dozen ideas worth chasing, all at once, all feeling urgent, all competing for the same finite hours. That's not a complaint, It's just how I operate.

The problem isn't the ideas. The problem is the infrastructure. Every productivity system I tried had the same flaw: it required me to maintain it. And the moment I stopped paying attention, things fell through the cracks. Not because the tools were bad, because none of them ran without me. So I decided to build one and named it J.

ADHD shaped every decision I made in building J. Not as a liability, but as a design constraint. If a system needs manual upkeep, it gets abandoned. If it needs a trigger from me to run, it will go silent on the days I'm deep in something else. So I built the entire architecture around one principle: autopilot, not cockpit. J runs whether I'm watching or not.

Meet J.

J is a self-hosted, always-on intelligence layer that connects every tool, inbox, task, message, and decision in my life into one system that just runs. No app to open. No dashboard to check. No reminding myself to use it. It's just there, working in the background while I get on with my day.

He handles my email, tracks my calendar, reads my Granola meeting summaries, pulls out action items, and writes them to my reminders before I even know I need them. He delivers a brief every morning, captures my journal at the end of the day, nudges me when a project has gone quiet, and sends me a planning prompt every Sunday. He also synthesizes my messages so nothing important slips through the cracks.

None of it requires me to open anything; Which, honestly, is the whole point.

Why not just use what already exists?

It's the first question that comes to mind. And it's fair.

I tried the existing options. Productivity apps, AI assistants, note-taking systems, automation tools. Each one had real value. Each one had the same problem: I was the trigger. I had to open the app. I had to run the workflow, and remember to check the dashboard. The tool waited for me, but I didn't need something to wait for me; I needed something that ran on its own without my input. And there's no real way for those tools to act on their own either without having to give AI complete control of my computer. Most productivity tools respond when you show up - J doesn't wait.

Tools like Cowork and OpenClaw can do pieces of what J does, and they do them well. But I wasn't looking for a product someone else designed. I wanted something built around how I think, how I work, and what matters to me specifically. Something I could shape from the ground up. The moment I realized I could build it myself, that was the only path that made sense.

What I needed was a reasoning layer I had designed and configured myself. One that knew my rules, my priorities, my context, and my hard lines. Not a generic assistant, a specific one.

I built J on Claude with a context layer I wrote myself, with behavioral rules that govern how J operates: what he does autonomously, what he always asks me first, what he never does regardless. He understands when my workload is heavy and adjusts accordingly, when I need things streamlined, and when he should just handle something quietly so my mind doesn't have to carry it. That's not a feature you get out of the box. It's a personal system I wanted to build for myself.

The stack (the short version).

Claude is J's brain. He does the thinking: classifying emails, extracting action items, generating briefings, making judgment calls within the rules I've defined.

N8N is J's body. It does the moving: connecting to Gmail and Google Calendar, writing to Apple Reminders, and coordinating everything in between. Think of it as the plumbing. Claude is the water.

Telegram is where J and I talk. He sends me my daily briefs, action item alerts, and Sunday planning prompts through Telegram. I send him my end-of-day journal entries and ask him questions the same way. It's the one channel where everything between us moves.

Granola captures my meetings. After every call, Granola produces a summary and transcript. J reads those and pulls out action items, decisions, and anything worth remembering, so nothing from a meeting disappears into a folder I'll never open.

Obsidian is J's memory. Every journal entry, every session summary, every decision I've captured lives in a local vault on a LaCie drive connected to my Mac Mini. Personal context never touches the cloud. I like it that way.

The host is an older Mac Mini I had sitting around, always on, running quietly in the background. Cloudflare Tunnel makes J reachable from anywhere without opening a port on my router or exposing my home network. Free, fast, and it just works.

J's memory is built on a RAG-adjacent architecture. Obsidian is the knowledge store, with a retrieval layer that lets J surface the right context at the right moment, or when I ask for it.

Claude connects to external tools, including N8N itself, through MCP, the Model Context Protocol. This is what lets J interact with outside systems without me being the relay. I'll break down how that works in a different article.

This is not just a smarter automation. It's a second brain.

Most people hear "automated system" and picture a set of rules firing on a schedule. J is something different.

J reasons. He classifies incoming email not by keyword matching but by understanding context, sender history, and what the email actually means in the flow of my day. He pulls action items out of email threads and drops them into Apple Reminders with suggested due dates, not because I told him which emails to watch, but because he knows what kind of work I do and what needs follow-through. He labels marketing emails into a folder so I can review and delete. As he learns what I approve and what I don't, he'll handle that automatically. For now, he's still learning. We'll call it an internship.

At the end of each day, J reads my EOD journal entry, figures out which projects moved and which didn't, and decides whether anything needs to surface in tomorrow's brief. No input from me beyond the journal, he just handles it.

The system is also learning the shape of my weeks. J tracks which projects I've mentioned, which ones have gone quiet, and which ones are overdue for attention. When I open Telegram and ask "what should I focus on this week," J already has context from my last week of journal entries, my calendar, and my open project list. He gives me a prioritized answer. Not a list of everything. Just the answer.

And then there's what I'm building toward. The next phase is a coordinator layer, where I send one message and J figures out the full chain of things that need to happen. I ask for a week prep. J checks the calendar, reviews open projects, surfaces anything overdue, and brings it back as one coherent summary. I asked one thing. J did four. That's the difference between a system that executes what you set up and one that figures out what needs to happen.

The architecture is already built for it. The coordinator is the next piece.

What a day with J actually looks like.

I wake up to a daily brief in Telegram already waiting for me, telling me about the Emails that matter, what's on my calendar, and action items I need to prioritize. I usually read it before I'm fully awake, and by the time I've poured coffee I know what my day is going to be like. J figured it out while I was sleeping.

During the day I don't really think about emails. J is moving through it. Things get classified, labeled, flagged. If something needs me, it surfaces. If it doesn't, it's filed. I check the inbox when I want to, not because I have to.

If I need context on something, I ask J in Telegram. What did I decide about this last week? What's the status of that project? He pulls from my journal entries and session notes and gives me the answer. No searching, no scrolling, no trying to remember what tab I left that in.

At the end of the day I send J a few lines about what happened. What I got done, what I'm thinking about, what I didn't finish. He writes the journal entry to Obsidian, creates follow-up reminders for anything I mentioned, and notes which projects moved. That record feeds into tomorrow's brief. The longer this runs, the more context J carries. It compounds.

Sunday mornings a planning prompt shows up. What moved last week? What matters most this week? What has been sitting too long? J already has the answers from the week of activity he's been tracking. He brings them to me. I make decisions. He goes back to work.

None of that required me to open a dashboard, run a workflow, or remember to do it. He just does it… period.

Why it was worth building.

I built J because I was tired of dropping things - Not because I didn't care about them, but because there was no system holding them when I wasn't looking. Things would matter, and then they'd disappear under the next wave of things that also mattered.

J doesn't fix that by making me more organized. He fixes it by owning the parts that don't need me. The triage, the logging, the nudges, the weekly review. J handles those. I focus on the things that actually require my thinking.

It's still early and there's a lot more being built. But even at this stage the difference in how I move through a week is real.

At some point I'll write about how J is actually built: N8N, Claude, the MCP connections, the memory architecture, and what's next. But for now, I gotta get back to business. J just told me I'm way past the time I allocated to write about this. I do hope he doesn't get too demanding. I'll pull the plug if he does.