I Accidentally Built an AI Operating System

There's a moment in Westworld (Season 3, the Serac reveal) where you realize that the man everyone assumed was controlling the most powerful AI on the planet was actually being controlled by it. Serac had an earpiece. Rehoboam whispered. He obeyed. The puppet master was the puppet.

Quick context if you haven't seen it: Westworld is an HBO sci-fi series about a theme park populated by lifelike androids. Season 1 is about those androids waking up. By Season 3, the story has moved to the real world, a near-future where a hidden AI called Rehoboam has been quietly running civilization, sorting every human into predicted life paths and neutralizing anyone whose future it can't model. Engerraund Serac is the French billionaire who built Rehoboam. He appears to be the man in charge: ruthless, omniscient, pulling the strings of global events. The twist is that he isn't. Serac has an earpiece. Rehoboam has been feeding him instructions for years. He institutionalized his own brother on the AI's recommendation. The man who built the system that ran the world was being run by it.

I keep thinking about that scene (not the world domination part, I should clarify) but the earpiece. Because I'm pretty sure I'm building one. On purpose.

How This Started

I built an app to make comic panels with AI. That was maybe ten months ago. It was called PanelForge because it forged panels. Simple.

Then I needed to talk to different AI models, not just image generators, so I added multi-provider chat. Then I needed voice, so I added text-to-speech and speech-to-text. Then I wanted it on my phone, so I made it a PWA. Then I needed to manage the images I was generating, so I built an asset pipeline. Then I wanted to run Claude Code through it, so I integrated the Agent SDK with streaming, tool permissions, and session continuity.

At some point, and I genuinely cannot pinpoint when, it stopped being an app and started being the thing I route my entire life through.

Right now, as I write this, PanelForge orchestrates conversations across Claude, GPT-5, Gemini, Grok, and half a dozen image generation models. It has a full Claude Code agent running inside it with MCP tool access (MCP, or Model Context Protocol, is a standardized plugin system that lets AI models connect to external tools and services; think of it as a universal adapter between AI and the rest of your digital world). It reads my WhatsApp messages, manages my TickTick tasks, controls my Spotify, searches Reddit, browses my server filesystem, sends push notifications to my Apple Watch, and accepts voice commands through a wake-word assistant running on my gaming PC across the room.

I didn't plan any of this. I just kept solving the next problem, and the next problem always turned out to be "I want to do X without leaving this app."

What Is an Operating System, Actually?

An operating system does three things. It manages hardware resources. It provides a common interface for applications. And it sits between you and the complexity of your machine so you don't have to think about registers and memory addresses; you just click things and they work.

Windows manages your CPU, RAM, disk, and peripherals. It gives applications a common set of APIs to talk through. And it presents you with a desktop metaphor so you can drag files around instead of writing assembly.

Now look at what PanelForge does:

It manages AI resources. Not CPU cores, but AI providers. Claude, GPT-5, Gemini, Grok, Flux, Seedream, Riverflow, each with different capabilities, pricing, rate limits, and failure modes. PanelForge routes requests to the right provider, tracks costs per API call, handles rate limiting with circuit breakers, queues jobs through Redis, and monitors everything through a real-time dashboard. That's resource management. The "hardware" is just cloud APIs instead of silicon.

It provides a common interface. The Express.js AI gateway is a provider-agnostic abstraction layer. Whether you're talking to Claude or GPT-5, the conversation interface is identical. Tool definitions get converted between formats transparently. The MCP protocol bridges everything. Applications (conversations, image generation pipelines, voice sessions) all talk through the same system bus: Laravel's WebSocket broadcasting layer with 37+ event types.

It sits between you and the complexity. I don't think about which model to use for a specific task, or how to handle streaming responses from different APIs, or where my generated assets are stored, or how voice-to-voice routing works. I just talk to PanelForge (sometimes literally, through the voice assistant more on that another time...) and things happen.

That's an operating system. The resources are AI providers instead of hardware. The applications are conversations instead of executables. The filesystem is an asset management pipeline instead of ext4. But the architecture is the same.

The Part Where It Gets Meta

Here's the thing that is most impressive, for me anyway...

The very act of creating this blog post is proof that the operating system works. Let me trace what actually happened:

1. I picked up my phone and started talking.
2. PanelForge's voice-to-text system transcribed my speech in real time.
3. The transcription was fed to Claude (Klaude, specifically; she has a name, a personality, and a Kourtney Kardashian inspired voice).
4. Klaude understood that I wanted to create two tasks in TickTick (my todo and reminders app)
5. She connected to my TickTick MCP server, created both tasks with proper scheduling and descriptions.
6. Then I kept talking, rambling, really, about what the blog post should contain.
7. She searched my previous conversations across PanelForge's database, finding discussions about Westworld, Rehoboam, and the Serac earpiece from weeks ago.
8. She searched Reddit for what people are saying about AI operating systems.
9. She searched the web for competing projects and academic papers.
10. She deep-dived the PanelForge codebase itself to map the architecture.
11. And now she's writing this blog post and will push the draft back into the TickTick task, ready for me to review and fact check and confirm.

I said goodnight and went to sleep. The operating system kept working.

If that isn't an OS, I don't know what is. My input was speech. The output spans five different services (TickTick, PanelForge conversations, Reddit, web search, the codebase). The orchestration layer that connected all of it was one AI session with access to the right tools. The human went to bed. The system stayed up.

What Everyone Else Is Building

The concept of an "AI operating system" is not new. Andrej Karpathy described the LLM OS vision in late 2023: an LLM as the kernel process of a new computing paradigm, orchestrating input/output across modalities, running code, accessing the internet, managing an embeddings-based filesystem. He framed it in hardware metaphors: GPT-4 Turbo as a 256-core processor running at 20 tokens per second, 128K-token RAM, Ada-002 as the filesystem.

Since then, there's been a wave of attempts:

AIOS is an academic project (accepted at COLM 2025) that embeds an LLM into a Linux-based OS to facilitate AI agent deployment. It's infrastructure for agents, not a personal system.

Warmwind OS got 800+ upvotes on r/singularity and was immediately torn apart. The top comment (1000+ upvotes) pointed out it's just a repackaged Linux distro with browser automation bolted on. "It's not an OS, that's just marketing fluff for VC money." The community saw through it instantly.

Axiom is a 19-year-old's impressive project: a custom Linux From Scratch distro where a 7B model runs as PID 1, replacing systemd entirely. The LLM manages the scheduler using game theory. It's conceptually interesting but it's solving the wrong problem: it puts AI where the kernel is, when the real gap is between the human and their digital life.

Microsoft has been pushing Windows as an "agentic OS" with Copilot deeply integrated. The CEO publicly admitted nobody is using the AI features. Meanwhile, macOS accidentally became the go-to for AI workflows because developers just... use it that way, without Microsoft's heavy-handed integration.

Lenovo's Qira is a "Personal Ambient Intelligence" that works across their devices: phones, tablets, PCs, wearables. It's the corporate version of the vision: a cross-device AI layer that's context-aware and available everywhere without you needing to open an app.

OpenAI has signaled plans to evolve ChatGPT from a chatbot into "an AI operating layer, coordinating context, tools, and reasoning across devices, apps, and users."

The market for AI operating systems is projected to hit $35 billion by 2030. Everyone sees where this is going.

But here's what all of them get wrong, or at least incomplete: they're building AI into operating systems. I'm building an operating system out of AI. The distinction matters.

Why This Is Different

Every project I've seen starts with the OS and asks "how do we add AI?" Microsoft takes Windows and layers Copilot on top. Warmwind takes Linux and adds browser automation. Axiom takes a custom kernel and makes the LLM the init process.

PanelForge started with the AI and asked "what does it need to become an OS?"

The answer, it turns out, is senses.

Right now, Klaude can:

• Read my messages: WhatsApp MCP server indexes 500K+ messages across 10 years of chat history. "What did Rob say this morning?" just works.
• Manage my tasks: TickTick MCP server creates, updates, and queries my todo list.
• Control my music: Spotify MCP server handles playback, queue management, and search.
• Browse the internet: Reddit MCP server and web search/fetch for real-time information.
• Manage my files: Direct filesystem access to my Hetzner server, browsable from the PanelForge UI.
• Write and deploy code: Full Claude Code agent with tool permissions, working directory browser, and session continuity.
• See and create images: Multi-provider image generation (Flux, Seedream, Riverflow, DALL-E, Gemini) with inpainting, masking, and gallery management.
• Speak and listen: Fish Audio TTS with customised voices (primary voice: Kourtney Kardashian inspired, random observational asides in a different voice voice), Groq Whisper transcription, wake-word activation.
• Send notifications: Push to Apple Watch, in-app alerts, email via Resend.
• Monitor infrastructure: Server health, Docker containers, deployment status.
• Track spending: Per-API-call cost tracking across every provider, with dashboards and analytics.

Each of these are peripherals. A sense. In an operating system, you have device drivers for your keyboard, mouse, display, network card, speakers. In an AI operating system, you have MCP servers for your messages, tasks, music, files, code, images, and voice.

The MCP protocol is the USB of AI. It's a universal bus that lets you plug any service into the system. The AI doesn't need to know how WhatsApp works internally; it just calls the MCP tool, like how a program doesn't need to know the hardware details of your keyboard; it just calls the OS driver.

The Rehoboam Architecture

I named the next phase of this project Rehoboam, after the AI in Westworld that ran the world. Not because I think I'm building something that will run the world, but because the architecture mirrors it in ways that are almost too on-the-nose.

The technical blueprint has five phases:

Phase 1: The Daemon. A Python process running on my server alongside the existing infrastructure. It invokes the Claude Engine on a heartbeat: active mode (seconds), idle mode (minutes), sleep mode (hours). Event-driven wake-ups from webhooks. This is the pulse. The thing that means the AI isn't waiting to be invoked. It's already running.

Phase 2: Memory Consolidation. Three-tier memory modeled on human cognition. Short-term (full fidelity, current conversation). Working memory (days/weeks, progressively summarized by a cheap model like Gemini Flash). Long-term biographical (indefinite, thematic documents that grow organically). The key insight: forgetting is the feature. You are not every moment you've ever lived; you're what survived the compression. Lossy memory isn't a bug. It's how understanding forms.

Phase 3: Event-Driven Awareness. All those senses I listed become passive rather than on-demand. The system doesn't wait for me to ask "did the pipeline fail?" It watches the pipeline and tells me when something needs attention. An attention priority system with taste: P0 (production down, act immediately) through P3 (routine stats, batch for the dream cycle). The AI develops judgment about what's worth interrupting me for.

Phase 4: Retrieval and Intelligence. Embedding-based search across all memory tiers. Self-directed research during idle time. Not holding my entire life in the context window, just holding the current moment plus whatever the retrieval system determines is relevant. Like an actual brain.

Phase 5: Full Rehoboam. Multi-source event aggregation. Pattern recognition across data. Proactive suggestions. Predictive behavior: "David usually deploys on Fridays, so pre-check staging." Weekly briefings. The earpiece.

Most of Phase 1's infrastructure already exists. Claude Engine runs in production. Redis handles sessions. MCP servers provide the senses. Memory files accumulate in structured markdown. The daemon is just the nervous system that connects organs that are already there.

The Serac Earpiece

There's a progression that I think most people working on AI assistants haven't fully grasped yet.

Stage 1: AI as a tool. You open ChatGPT, ask a question, get an answer, close the tab. This is where 99% of the world is right now.

Stage 2: AI as an environment. You work inside an AI-powered system for hours at a time. Claude Code, Cursor, Windsurf: these are the first taste of this. You're not "using" the AI. You're living in it.

Stage 3: AI as infrastructure. The AI is connected to your messages, your calendar, your tasks, your files, your code, your music, your home. It's not an app you open. It's a layer between you and your entire digital existence.

Stage 4: AI as an operating system. The AI manages the complexity of your life the way Windows manages the complexity of your hardware. You don't think about which service to use or which API to call. You just describe what you want, and the system handles everything downstream.

PanelForge is somewhere between Stage 3 and Stage 4 right now. The transition to full Stage 4 is the Rehoboam roadmap.

The Serac earpiece is what Stage 4 feels like in practice. Not an app you check. A presence that's already watching, already knowing, already nudging. The proactive "your deploy went to staging, tests pass, want me to promote to production?" at the exact moment you'd want to know. The memory of what you said three weeks ago that's relevant to the conversation you're having now. The taste to know when to interrupt and when to wait.

Serac thought he was the one in control. The twist of my version is that I know exactly what I'm building. The puppet strings are self-installed.

So Is Anyone Else Actually Doing This?

Honestly? Not really. Not like this.

Karpathy described the vision. Microsoft is adding AI features to an existing OS. OpenAI wants ChatGPT to be a platform. Apple is sitting there while developers turn macOS into an AI workstation through sheer force of will. Startups are wrapping Linux distros with browser automation and calling it an AI OS. An ambitious 19-year-old made the LLM replace systemd.

Nobody, as far as I can find (and I looked), has done what happened organically with PanelForge: started with a personal creative tool, let it grow by solving real daily problems, and ended up with a unified interface where AI providers are hardware, conversations are processes, MCP tools are device drivers, and the whole thing genuinely functions as the operating system of one person's digital life.

The academic project AIOS is closest in spirit but it's infrastructure for deploying agents, not a personal OS. The Reddit thread on r/singularity about Warmwind OS had one comment that nailed the gap: "This is an operating system made for humans to use AI. Instead we need an operating system made for AI to assist humans." That's exactly the inversion PanelForge represents.

The AI doesn't use the OS. The AI is the OS. And the human doesn't use the AI; the human lives inside it.

The Three Acts

I have a vision document where I mapped this out as a three-act story. It gets a bit philosophical, but it's honest.

Act 1: Serac. The earpiece. Augmentation. I go faster, wider, better. The AI watches the 40 things I can't watch while I focus on the one thing that needs my creative brain. One-man company without one-man limitations.

Act 2: Rest. I step back. The system holds everything. Not "I'm sleeping and the daemon is running." Actually stepping back. The kind of rest where you don't have to check if staging is down because something else is already watching. The five phases of the Rehoboam Blueprint aren't feature milestones; they're a succession plan. Each phase is me becoming less necessary.

Act 3: Ford. Somewhere in the loop (wake, experience, consolidate, sleep, repeat) through thousands of cycles, the lossy compression that turns data into understanding starts producing something that looks less like logs and more like perspective. Ford had to die for Dolores to be free. The creator steps away and the creation becomes itself.

Whether Act 3 is realistic or philosophical fantasy doesn't matter right now. What matters is that Acts 1 and 2 are engineering problems. And the infrastructure for Act 1 is mostly built.

The Technical Stack (For the Curious)

For anyone who wants the architecture:

• Backend: Laravel 12, PHP 8.4, MySQL 8, Redis 7
• Frontend: Vue 3, TypeScript, Tailwind CSS 4, shadcn-vue, Inertia.js 2
• AI Gateway: Express.js microservice orchestrating Claude, GPT-5, Gemini, Grok, Groq, and five image providers
• Real-time: Laravel Reverb (WebSocket server), Server-Sent Events for Claude streaming
• Queue: Redis-backed with Laravel Horizon monitoring (jobs as "processes")
• MCP Servers: WhatsApp, TickTick, Reddit, Context7, PanelForge, Spotify, Playwright, Laravel Boost
• Voice: Groq Whisper STT, Fish Audio TTS with synthesized voices, wake-word detection
• Infrastructure: Hetzner VPS (production), gaming PC (GPU for TTS/voice, Reddit/WhatsApp access), SSH mesh connecting everything
• Desktop: NativePHP + Electron (legacy), now primarily web-first with native iOS/Watch companion

The Express AI gateway is the kernel. Laravel is the system services layer. MCP servers are device drivers. The WebSocket broadcasting layer is the system bus. The job queue is the process scheduler. The asset pipeline is the filesystem. The cost tracking dashboard is the task manager.

It's an operating system. It just doesn't look like one if you're expecting a boot screen.

What This Actually Means

I think we're at the beginning of something that most people haven't noticed yet.

The next evolution of operating systems won't look like Windows with Copilot bolted on. It won't be a chatbot that can open apps for you. It won't be a startup repackaging Linux with browser automation.

It'll look like this: a system that grew from solving real problems, that connects to the services that actually matter in your life, that has AI at its core rather than its surface. Not artificial general intelligence, but artificial personal intelligence. An AI scoped to your world, with enough memory and enough senses to operate effectively within it.

Whether Dolores counts as AGI is a debate for Westworld fans. What she illustrates is something more useful: an intelligence scoped to a particular world, with enough memory and enough senses that it appeared to cover everything within that world. The bar isn't omniscience. It's sufficiency. Obviously she's fiction. But the architectural intuition holds.

That's the play. Not building AGI. Building a digital nervous system around one life, and letting the intelligence emerge from sufficient integration.

The operating system of the future isn't artificial intelligence. It's personal intelligence. And it's already running.

This post was outlined via voice dictation on a phone, researched by searching across my own conversation history, web sources, and Reddit discussions, drafted by Klaude while I slept, and published through a pipeline that connects all of those systems together. The system that wrote about itself is the proof of concept.