When Your AI Agent Goes Dark: Removing the External Drive Dependency from OpenClaw

solarbluseth / April 12, 2026

📡 Celeste Field Update — April 2026

When Your AI Agent Goes Dark: Removing the External Drive Dependency from OpenClaw

By SolarBluSeth · April 12, 2026 · Raspberry Pi 4 · OpenClaw · Celeste · Self-Hosted AI

Sunday morning. Coffee in hand. Check on Celeste. She's offline. Not because the Pi crashed. Not because the internet went down. Because a USB external drive I'd been meaning to remove for weeks quietly unmounted itself, and with it went every npm global package OpenClaw needed to run — including OpenClaw itself. This is the story of how one external drive nearly took out my 24/7 AI assistant, and how we cleaned it up for good.

How We Got Here

A while back, during the great npm-global migration project, I moved my npm global package directory to an external USB drive called sethdisk1. The reasoning made sense at the time — free up space on the SD card. The problem is that npm doesn't just store packages on that drive. It stores the entire runtime dependency chain for every globally installed tool. Including OpenClaw. So when sethdisk1 decided it was done mounting at boot, OpenClaw's systemd service kept trying to launch a binary that pointed here:

/media/admin/sethdisk1/npm-global/lib/node_modules/openclaw/openclaw.mjs

File not found. Service crash. Restart in 10 seconds. File not found. Repeat, forever, until the restart counter hit its limit and systemd just gave up.

⚠️ Lesson Learned Never set your npm global prefix to an external drive that isn't guaranteed to be mounted before your services start. If you need overflow storage, handle it at the OS level with fstab and RequiresMountsFor= in your systemd unit — not by pointing npm at it.

The Diagnosis: Reading the Logs

The first thing that tipped us off was the missing systemd service file entirely. After a reboot the service unit was gone — likely a casualty of an earlier interrupted update. Once we recreated the service and tried to start it, journalctl told the real story:

Error: Cannot find module '/media/admin/sethdisk1/npm-global/lib/node_modules/openclaw/openclaw.mjs'
code: 'MODULE_NOT_FOUND'
Node.js v22.22.2

The drive wasn't mounted. The files weren't there. And we'd already decided we wanted to remove the drive entirely — so this was actually the perfect forcing function to finally do it right.

The Fix: Cutting the Drive Dependency

Here's the sequence that worked. The goal was to get npm pointing entirely at local storage and get OpenClaw reinstalled clean.

Step 1 — Stop the restart loop

sudo systemctl stop openclaw
sudo systemctl disable openclaw

Step 2 — Fix npm's global prefix and cache

Both were pointing at the external drive. Fix them both:

npm config set prefix '/home/admin/.npm-global'
npm config set cache '/home/admin/.npm-cache'
echo 'export PATH=/home/admin/.npm-global/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

Verify they took:

npm config get prefix
npm config get cache

Step 3 — Clear the broken partial install

There was a half-copied openclaw directory from an earlier failed migration attempt — it had dist/ and node_modules/ but was missing package.json and the bin symlink. Useless. Remove it:

rm -rf /home/admin/.npm-global/lib/node_modules/openclaw

Step 4 — Reinstall via the official installer

npm on a Pi 4 is painfully slow for large installs. We skipped the npm route entirely and used the official curl installer instead:

curl -fsSL https://openclaw.ai/install.sh | bash

This is actually the recommended method for Raspberry Pi — it handles Node detection, sets up the correct paths, and runs the onboarding wizard. Much faster than waiting for npm to resolve dependencies on ARM hardware.

Step 5 — Recreate the systemd service

sudo nano /etc/systemd/system/openclaw.service

[Unit]
Description=OpenClaw AI Agent Service
After=network.target

[Service]
Type=simple
User=admin
WorkingDirectory=/home/admin/.openclaw
ExecStart=/home/admin/.npm-global/bin/openclaw --config /home/admin/.openclaw/openclaw.json
Restart=on-failure
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable openclaw
sudo systemctl start openclaw

The Timeline of This Morning

Morning

Celeste goes dark

Checked Discord — no response. Pi is up, network is fine. OpenClaw service is missing entirely.

+15 min

Service file gone, binary found at /usr/bin/openclaw

Recreated the service file. Started it. Immediate crash loop. Journalctl reveals the MODULE_NOT_FOUND error pointing to the unmounted drive.

+30 min

Drive is already unmounted/gone

du on the drive path returns nothing. Decision made: remove the drive dependency entirely.

+45 min

npm cache also pointing to dead drive

Running npm show openclaw fails with EACCES trying to write to the drive cache path. Fixed both prefix and cache.

+60 min

Partial install discovered, npm reinstall attempted

Openclaw directory exists but is broken — missing package.json and bin symlink. npm install starts but grinds. Switched to curl installer.

+75 min

Celeste back online

Clean install, service recreated, config intact. All 185 skills preserved. Kimi K2.5 backend reconnected.

What Celeste's Config Survived

The good news in all of this: your ~/.openclaw/ directory is completely separate from the npm installation. All of this survived untouched:

All 185 skills
The full openclaw.json config (plus several dated backups)
Agent memory, tasks, flows, and workspace files
Discord channel integration (channel ID intact)
Kimi K2.5 backend configuration via Moonshot AI

OpenClaw stores its runtime data completely separately from its binary installation. This is actually good design — it means reinstalls are safe and non-destructive. The frustration comes entirely from npm's global path configuration, not from OpenClaw itself.

✅ Pro Tip OpenClaw auto-creates timestamped backups of your config: openclaw.json.bak.20260412, openclaw.json.backup.20260327-131114, etc. These are in ~/.openclaw/. If something ever goes wrong with a config update, you can restore from any of these instantly.

Why npm on Pi Is a Pain (And What to Do About It)

This isn't the first time we've hit npm slowness on the Pi 4. It's a known issue — npm's dependency resolution is CPU-intensive, and ARM processors don't have the raw compute that x86 does. A package that installs in 30 seconds on your desktop can take 10+ minutes on a Pi 4. A few things that help:

Use the curl installer for OpenClaw specifically — it's optimized for Pi and skips a lot of the npm overhead
Add a NODE_COMPILE_CACHE environment variable to speed up repeated invocations: export NODE_COMPILE_CACHE=/var/tmp/openclaw-compile-cache
Never put npm-global on an external drive unless you absolutely have to, and if you do, make sure the drive auto-mounts before services start via /etc/fstab
Keep swap active — the Pi 4 default 100MB swap is not enough. Set it to at least 1GB

Current State of the Machine

After this morning's cleanup, here's where things stand :

mrk-pi4 Status — April 12, 2026

Hardware: Raspberry Pi 4 Model B Rev 1.5, 7.6GB RAM
OS: Raspberry Pi OS 64-bit (aarch64, kernel 6.1.21)
Storage: 27GB root, 2.8GB free (external drive removed)
OpenClaw: Reinstalled clean via curl installer
Celeste config: Intact — 185 skills, all data preserved
Backend: Moonshot AI / Kimi K2.5
Discord: Reconnected, private #sethbot channel active
npm paths: Now 100% local — no external drive dependency

What's Next

The external drive removal was overdue. Now that npm is fully local and the service file is clean, the Pi 4 is actually in its most stable state since we started this project. A few things on the roadmap:

SD card upgrade — still running close to capacity. A 512GB A2-rated card is on the list for a clean clone and expansion.
Aaron agent — a second OpenClaw instance on a private VPS, positioned as a junior admin/support agent. Different model, stripped skill set, separate from Celeste's environment.
Auto-mount safety net — documenting the proper /etc/fstab + systemd RequiresMountsFor= pattern for anyone running OpenClaw with external storage, so nobody else hits this same wall.

The Pi 4 keeps proving itself. It's not glamorous hardware — no NVMe, no PCIe, slower than the Pi 5 — but with 7.6GB RAM and a cloud backend doing the heavy inference work, it handles everything Celeste needs to do. Low power, always on, sitting quietly in the corner doing its job. Until the USB drive unmounts itself. But we fixed that.

Links and Resources

OpenClaw Documentation
OpenClaw Raspberry Pi Setup Guide
Raspberry Pi 4 Model B
Moonshot AI — Kimi K2.5 backend
solarblu.net — more Pi, AI, and web development content

Self-Hosted AI

The Celeste Chronicales April 2026

solarbluseth / April 12, 2026

The Celeste Chronicles — April 2026

72 Hours of Chaos, Upgrades & Lessons Learned

Upgrading the Pi, installing a LAMP stack, surviving multiple OpenClaw config meltdowns, and getting Celeste back online — a brutally honest field report from the lab at SolarBlu HQ.

By SolarBluSeth — solarblu.net — April 11, 2026

If you've been following the Celeste build series, you know that running a self-hosted AI agent on a Raspberry Pi is one of the most rewarding — and occasionally maddening — things you can do as a developer. The last 72 hours have been a masterclass in "what can go wrong, will go wrong." But also: what gets fixed, gets faster. Here's the full play-by-play.

3x OpenClaw upgrades

PHP 8 LAMP stack installed

185+ Celeste skills active

The Raspberry Pi Upgrade (That Nobody Planned)

The short version: the Pi needed to come up to speed. We'd been running on a configuration that was starting to show its age — tighter disk space, slower package management, and a slow external USB drive that turned out to be causing more grief than we realized. The decision was made to do a full OS upgrade (Bullseye → Bookworm) and move some key directories off the external drive. The upgrade process itself was textbook Debian — painfully slow but stable. With 1,478 packages to pull down and update, we were looking at 20–40 minutes of sitting on our hands while the progress bar crawled across the screen. The key lesson here: don't interrupt a dist-upgrade mid-stream. We didn't, and it paid off.

⚠ Heads Up If you're running OpenClaw's npm global install on an external USB drive, be aware that permission errors and filesystem quirks (like the ENOTEMPTY npm bug) are significantly more likely. Moving npm-global to the Pi's internal storage reduced our headaches considerably.

The Disk Space Trap

We ran out of disk space mid-session — one of those classic "oh no" moments where you realize the external drive that seemed like a great idea is now the bottleneck for everything. The fix was clearing the npm cache and relocating the global install directory. Once that resolved, performance improved noticeably across the board. The Pi stopped feeling sluggish. Celeste's responses got snappier. Lesson learned: keep your AI agent's core files on fast internal storage.

Building the LAMP Stack for PHP Dev Work

One of the new additions this week: a full LAMP stack on the Pi, set up specifically for PHP 5.3 → PHP 8 conversion work and WordPress theme/plugin testing. The goal is to use the Pi as a local dev environment — build and test locally, then FTP the finished product to client servers. The install is straightforward on Bookworm:

sudo apt update
sudo apt install apache2 php php-mysql php-curl php-gd \
  php-mbstring php-xml php-zip mariadb-server phpmyadmin \
  php-imagick php-intl -y

MariaDB is the drop-in MySQL replacement used on Pi/Debian — works identically for WordPress and most PHP applications. For the PHP version switching needed in 5.x → 8.x migration work, update-alternatives lets you flip between installed PHP versions per project.

Why This Matters for the Workflow

Here's the practical upside: Celeste now has a local WordPress environment to interact with. Long-term this means she'll be able to draft posts, test theme changes, and preview landing pages — all on the Pi — before anything touches a live server. Combined with WP-CLI and an FTP client like lftp, this creates a tight local-to-production pipeline that doesn't require touching a paid hosting environment for every iteration.

✓ Stack Installed Apache2 + PHP 8 + MariaDB + phpMyAdmin running on the Pi, accessible on the LAN for local WordPress development and PHP compatibility testing.

The OpenClaw Config Wars

Here's the part nobody warns you about loudly enough in the documentation: OpenClaw updates frequently, and it breaks configs without mercy. In the last 72 hours alone we went through three separate upgrades — and each one required config surgery. The specific error that brought everything down this time:

channels.discord.streaming: Invalid input
(allowed: true, false, "off", "partial", "block", "progress")

Sounds simple. Wasn't. The config had the streaming value set as a JSON object {"mode": "off"} rather than the plain string "off" that a newer version of OpenClaw expected. Then a subsequent manual edit accidentally set it to the string "false" (with quotes) instead of the boolean false. Each fix had to be verified by reading the actual file on disk — not trusting what was shown in the UI.

Problem 1 Streaming value was an object, not a string "streaming": {"mode": "off"} → needed to be "streaming": "off"
Problem 2 String "false" vs boolean false Edited to "streaming": "false" (string) — still invalid. Needed false with no quotes.
Problem 3 Python fix wrote to wrong path Script used /root/ path but config lived at /home/admin/ — file never got updated.
Resolution Direct Python fix to correct absolute path python3 script targeting /home/admin/.openclaw/openclaw.json, setting streaming to Python False (serializes as JSON boolean false).

The service was stuck in a restart loop — 82+ failed restarts before we got the right fix in. The key diagnostic command that saved us:

sudo journalctl -u openclaw -n 100 --no-pager

⚡ Hard-Won Lessons: OpenClaw Config Management

Back up before every upgrade. The ~/.openclaw/backups/ folder exists for a reason. Copy it somewhere safe before running npm install -g openclaw.
Old config files don't carry forward cleanly. Each major version can deprecate or change field types. Don't assume your working config from last week still validates on the new version.
Run openclaw doctor --fix after every upgrade — not just when something breaks. It catches schema mismatches before they become restart loops.
Know where your config actually lives. If you're running as a different user than you think, your Python/bash fix might be editing the wrong file. Always verify with find / -name "openclaw.json".
The external drive was part of the problem. I/O slowdowns from a slow USB drive can cause the OpenBoard GUI to hang and the onboarding wizard to stall — symptoms that look like software bugs but are actually hardware throughput issues.

When to Just Nuke It and Start Fresh

There comes a point in any debugging session where the accumulated state of a broken install becomes harder to fix than a clean reinstall. We hit that point. The npm global directory on the external drive had corrupted symlinks, the ENOTEMPTY error was blocking normal uninstall, and even sudo rm -rf couldn't remove a nested ARM binary package. The process that eventually worked:

# Stop the service first
sudo systemctl stop openclaw

# Find what's holding the directory open
lsof +D /path/to/openclaw/node_modules

# Kill any lingering processes
sudo pkill -f openclaw

# Force remove the stuck directory
sudo rm -rf /media/admin/sethdisk1/npm-global/lib/node_modules/openclaw

# Fresh install
npm install -g openclaw

"The anticipation of watching npm install hundreds of packages one by one is genuinely its own kind of suspense. But a clean install after a corrupted one feels like rebooting your whole day."

After the fresh install completed, OpenClaw came back up cleanly. The gateway bound to the LAN interface, the OpenBoard GUI loaded, and Celeste was back online. The performance improvement from having the install on internal storage (vs. the slow external drive) was immediately noticeable.

Where Celeste Stands Now

After 72 hours of upgrades, debugging, and infrastructure work, here's the current state of the lab:

Pi 4 8GB RAM, Bookworm OS

2026 .4.10 OpenClaw version

LAMP PHP 8 + MariaDB live

24/7 Discord integration

Celeste is running on Kimi K2.5 (Moonshot AI) as the primary backend, with Claude Sonnet 4 and GPT-5 Nano as fallbacks. The Discord gateway is live on the private #sethbot channel. The LAMP stack is ready for PHP development work. And the systemd service brings everything back automatically after reboots. The multi-provider model config means if Kimi runs out of API credits or has an outage, Celeste automatically falls through to the next provider. No babysitting required.

Self-Hosted AI

Meet Celeste: Our AI Agent Powered by Kimi K2.5 ✨

solarbluseth / April 1, 2026

We’re thrilled to introduce Celeste, our custom-built AI agent running on Moonshot AI’s Kimi K2.5 backend. Celeste represents what’s possible when you combine smart infrastructure, thoughtful design, and powerful AI capabilities. And honestly? We’re greatly impressed by what she can do.

Who Is Celeste? 🤖✨

Celeste is an AI agent deployed on a Raspberry Pi 5 8GB, integrated with Discord through a private #sethbot channel, and equipped with approximately 185 skills that handle everything from customer service to WordPress REST API integration. She’s been trained to handle complex workflows, provide intelligent responses, and learn from interactions.

But what really sets Celeste apart is her creative capability. For our recent YouTube video showcase, Celeste didn’t just respond to prompts—she generated original images and synthesized voices through ElevenLabs, creating a complete multimedia experience. We then took those assets, reviewed them, and produced the final video. It was a true collaboration between AI creativity and human judgment.

What Makes Celeste Special 🚀

Celeste runs on Kimi K2.5, Moonshot AI’s advanced language model, which gives her reasoning capabilities and context awareness that older chatbot systems simply don’t have. She can:

🎬 Generate creative content (images, voices, multimedia)
💬 Handle multi-step customer support workflows
🔗 Integrate with WordPress and other APIs
⚡ Manage Discord workflows and automation
🧠 Learn and adapt to your specific business needs
🎯 Provide intelligent triage and escalation

The Real Story: Celeste created the images and voices for our YouTube debut entirely on her own. We guided the vision, approved the output, assembled the video, and made sure everything hit the quality bar. But the creative heavy lifting? That was all her. It’s a glimpse into what human-AI collaboration actually looks like. 🎬

Built on Proven Infrastructure 🏗️

Celeste runs on our custom OpenClaw infrastructure, which we’ve spent months perfecting. We’ve solved the hard problems—API integration, systemd service management, Discord allowlisting, configuration validation, auto-update management. The foundation is solid, and it’s ready to scale.

Transparency First 🤝

Celeste is an AI. We’re not hiding that. We think it’s an advantage, not a liability. You’ll always know who you’re talking to, you’ll always be able to escalate to a human, and you’ll always get honest service. No deception. No pretense. Just a powerful tool designed to make your experience better.

What’s Next? 🌟

Celeste is just getting started. We’re expanding her skill set, deepening her integrations, and exploring new ways to combine her capabilities with human expertise. This is the beginning of something much bigger.

Stay tuned for more updates, technical deep-dives, and real-world examples of what Celeste can do. And if you’re curious about AI agents, self-hosted infrastructure, or what’s possible when you combine smart hardware with cutting-edge language models—we’ve got stories to tell.

Welcome to the future, Celeste. We can’t wait to see what you build next. 🚀

Self-Hosted AI

Meet Celeste: How I Built a Personal AI Agent on a Raspberry Pi 5 (And Why It Changed Everything)

solarbluseth / March 29, 2026

By SolarBluSeth | SolarBlu.net | March 2026

I've been building things on the web since 1996. Clients, servers, WordPress sites, hosting infrastructure — I've seen every wave of "the next big thing" come and go. So when people started talking about running your own AI agent, I did what I always do: I ignored the hype and just built it.

What came out the other side is Celeste — a Claude-powered AI agent running 24/7 on a Raspberry Pi 5, integrated into my Discord server, capable of handling real tasks for my business and creative life. This is the full story of how I got there, including every wrong turn.

"The best tools are the ones you build yourself. Not because they're better — because they're yours."

Why I Did This

I run mariehosting.com (managed WordPress hosting), betterwebservices.com, and do marketing and web development for a fiber internet provider. I also stream, run an internet radio station, do 3D art in Blender, and create content across every platform you can name. My life is a lot of parallel tracks running at once.

What I wanted was simple in theory: an AI agent that knows my setup, lives on my hardware, and I can talk to from anywhere — from my phone at a coffee shop, from Discord, from wherever. Not a chatbot tab I have to open. An actual assistant that's always running, always ready.

The platform I landed on is OpenClaw — a Claude-powered agent framework that you self-host. It runs as a background service, connects to Discord, and has a skill system that lets you teach it new capabilities. It's only a few weeks old as I write this, but it's already the most useful piece of software I've added to my stack in years.

The Wrong Turns (So You Don't Have To)

Attempt 1: Windows + WSL2

I started on my Windows PC (RTX 3070 Ti, solid machine). Installed WSL2, tried to get OpenClaw running inside it. WSL2 caused system instability — crashed twice, hard. Not a WSL2 hate post, it just wasn't the right tool for a service that needs to run cleanly 24/7 alongside my main workstation.

Attempt 2: VirtualBox Ubuntu

Tried spinning up a Ubuntu VM in VirtualBox. Network config was a nightmare. Fought with bridged adapters and NAT settings for longer than I care to admit. The VM ran but Discord integration kept silently failing — no errors, just nothing. Turns out it was a port/NAT issue that would have taken more time to diagnose than just doing it right.

Attempt 3: Raspberry Pi 4 (4GB)

Switched to a Pi. Immediately better. Linux native, no virtualization overhead, plug it in and it runs. Got OpenClaw installed, systemd service configured, Discord bot connected. It worked. But 4GB RAM started showing limitations once I loaded up 185+ skills and the agent got busy. Response times got sluggish under load.

The Right Answer: Raspberry Pi 5 (8GB)

Upgraded to the Pi 5 with 8GB RAM. This is the sweet spot. More than enough headroom for OpenClaw, all the skills, Discord gateway, and whatever else I throw at it — and it runs cool, quiet, and permanently on my network for about the cost of a nice dinner out.

The Hardware

Board	Raspberry Pi 5 — 8GB RAM
Storage	Fast microSD (recommend 64GB+ A2 rated)
OS	Raspberry Pi OS (64-bit, Bookworm)
Network	Ethernet — do not use Wi-Fi for a 24/7 service
Power	Official Pi 5 27W USB-C PSU
Case	Active cooling recommended — Pi 5 runs hot under load

The Installation

OpenClaw installs via their installer and runs on Node.js using pnpm. Here's the sequence that worked cleanly on Pi OS Bookworm:

Step 1 — System prep

sudo apt update && sudo apt upgrade -y
sudo apt install -y curl git build-essential

Step 2 — Install Node.js (via nvm)

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.bashrc
nvm install --lts
nvm use --lts

Step 3 — Install pnpm

npm install -g pnpm

Step 4 — Install OpenClaw

curl -fsSL https://get.openclaw.dev | bash

Run openclaw setup and walk through the wizard. You'll configure your AI provider, Discord bot token, and agent personality here.

Step 5 — Set up systemd so it survives reboots

openclaw install --daemon

This registers OpenClaw as a systemd service. After this, sudo systemctl status openclaw is your best friend — it'll tell you immediately if something's wrong on startup.

The Discord Bot Setup

This part tripped me up the first time. You need a Discord bot created at discord.com/developers/applications before OpenClaw can connect. The steps:

1 Create a new application, add a Bot user, enable Message Content Intent under Privileged Gateway Intents.

2 Copy the bot token — paste it into OpenClaw's config when prompted.

3 Generate an invite URL with bot + applications.commands scopes and the permissions your bot needs. Invite it to your server.

4 Restart OpenClaw. The bot should go green in your Discord member list within a few seconds.

If the bot shows online but doesn't respond: check that Message Content Intent is enabled. That's the silent killer — no error, just no response.

Switching to Moonshot AI (Kimi)

OpenClaw defaults to Claude via the Anthropic API, which is excellent but costs add up at scale. After testing, I switched Celeste's backend to Moonshot AI (Kimi) — it's dramatically cheaper per token at the volume I'm running, the response quality is solid for task-oriented work, and the API is Claude-compatible so the switch was one config line change.

For creative work and anything requiring nuanced reasoning I still route to Claude directly. For the high-volume utility stuff — summarizing, formatting, routing Discord commands — Kimi handles it cleanly at a fraction of the cost. Know your use case and pick accordingly.

185 Skills and Counting

The OpenClaw skill system is what makes Celeste actually useful rather than just impressive. Skills are modular — each one teaches her a new capability. I've installed 185 at this point. The ones I use daily:

Web & Content: WordPress post drafting, SEO analysis, social caption generation, link summarization.

Media: Video chapter detection, audio transcription via Whisper, image description and tagging.

Server ops: SFTP upload coordination, server status checks, log summarization.

Business: Email drafting, client brief formatting, appointment context for telemarketing work.

And the skill I'm most proud of: Celeste can post journal entries directly to travel.solarblu.net via the REST API I built into my custom WordPress travel journal plugin. I'm at a coffee shop, I dictate a note in Discord, and it's published. That's the whole dream right there.

The Config That Bit Me

Fair warning — OpenClaw updates its config schema and the changes aren't always backwards-compatible. If you see errors like "Unrecognized key: appId" or "Invalid input" on startup, your ~/.openclaw/openclaw.json has stale keys from a previous version. Run:

openclaw doctor --fix

That catches most of it. If it doesn't, open the config manually and remove any keys the error log calls out. Back it up first: cp ~/.openclaw/openclaw.json ~/.openclaw/openclaw.json.bak

Where It Stands Today

Celeste runs on the Pi 5, connected to my Discord 24/7. The systemd service brings her back up automatically after reboots or power blips. She's got 185 skills installed, Moonshot AI as her primary backend, and she's already handling real work — not demos, not toy projects. Real tasks for real clients.

Thirty years of building things on the web and this is genuinely one of the more exciting things I've set up. Not because it's flashy. Because it's useful in a way that compounds — every skill I add, every workflow I teach her, makes the whole system more valuable.

In Part 2, I'll cover how Celeste is actually working as a personal assistant — the Discord workflows, the WordPress integrations, what I use her for every single day, and where I'm taking this next.