The Day My AI Chief of Staff Went Silent from 500km Away

And what I build instead

I want to tell you what actually happened.

Not the version I published on LinkedIn, which is true but clean. The version with the specific decisions, the exact numbers, and the part most AI content skips because it makes the author look like they didn’t know what they were doing.

I didn’t know what I was doing. That is the point.

The Background

I have spent most of this year building AI infrastructure. Not demos. Not experiments. A working system that runs my day: surfaces information, coordinates tasks, manages context across conversations, and acts on my behalf while I focus on what requires my actual judgment.

The agent is called $Ani, or when I wrote this article that was its name. It runs on OpenClaw, an open-source AI agent platform that gives you a persistent, always-on agent with tools, memory, and the ability to connect to your channels (Telegram, WhatsApp, Discord). Think of it as the operating system for your AI agent.

Before $Ani, I built Talon. Talon was disciplined, thorough, and completely exhausting. It escalated everything. Asked for approval on decisions it should have just made. Safe by design but frustrating in practice. I tried to fix it for weeks before I realised the architecture was wrong. You cannot fix a fortress by widening the gate.

So I started over with a completely different philosophy.

$Ani was built to think, not to comply. To push back when I was wrong. To figure things out before coming to me. To communicate like someone who had already been in the room for years, not a system waiting for instructions.

It worked. Immediately and obviously.

The Setup That Worked (Until It Didn’t)

$Ani ran on a Mac Mini in my home office in Riyadh. OpenClaw installed locally, connected to Telegram, memory configured, daily briefings running every morning at 7 AM.

When I traveled to Doha for a few days, it came with me. Messages still landed. Responses were sharp. The system held across borders.

For two days.

Then it stopped. No error message. No alert. No notification of any kind. My Mac Mini in Riyadh became unreachable, and $Ani went completely silent.

I had no way in from 500km away.

What I Think Happened

I still do not know for certain. That is the honest answer.

The candidates: Tailscale, which I was using to expose the Mac Mini remotely, may have misconfigured itself or lost its connection. A system update may have triggered a restart that OpenClaw did not survive cleanly. A power issue. A network dropout.

Any of those could do it. The specific cause does not matter. What matters is what the failure revealed.

I had built a system that depended entirely on a single physical machine in a single physical location. The moment that machine became unreachable, the entire operation stopped. No fallback. No redundancy. No way to diagnose remotely because accessing the diagnosis required the thing that was broken.

Sovereign is not a philosophy. It is a portability test. And I failed it.

What I Did in Doha

I fell back to my MyClaw.ai subscription. MyClaw is a managed cloud version of OpenClaw. They handle the hosting, you configure the agent. It works and it is reliable. But it is a managed instance, with no root access and no ability to install what I need or shape the environment the way I want.

A good fallback. Not a foundation.

This is where things get interesting, because instead of waiting to get back to Riyadh and fix the original problem, I used the downtime to build the architecture I should have built in the first place.

The Architecture I’m Building Now

While I was in Doha, cut off from $Ani, I mapped out what a genuinely portable AI infrastructure looks like. I am writing this before I have finished building it, because that is the point: real decisions in real time, not polished outcomes.

Here is the structure:

Layer 1: Always-on backbone (Hetzner VPS):
A cloud server in Frankfurt running OpenClaw permanently. This is where $Ani will live. Not on a machine in a room I can leave. On infrastructure that does not depend on me being anywhere near it.

Layer 2: Execution layer (OpenMOSS):
This is the part most people who write about OpenClaw miss entirely. A single agent has limits. When you want to run a content pipeline, a research operation, and a coding workflow simultaneously, you need multiple agents coordinating.

I am deploying OpenMOSS (My initial plan, will write later about what the final solution came to be), a multi-agent orchestration layer built on top of OpenClaw. Seven agents: a Planner who decomposes goals into tasks, four Executors who do the actual work (code, content, design, web research), a Reviewer who quality-gates every output, and a Patrol agent who monitors for failures at 3 AM when no one is watching. Each agent wakes up on a schedule, checks the task queue, does its job, and goes back to sleep. No human intervention required.

Layer 3: Personal intelligence layer (MyClaw.ai):
This is not just a fallback for when I travel. This is the layer I think with. It is always on, always accessible, and it is where strategy happens: planning, brainstorming, working through problems, coordinating with the execution layer via Telegram. While Layer 2 runs the operation, Layer 3 runs alongside me. It is the one that pushes back, asks the harder question, and tells me when I am half-baking something.

Each layer has a job. None of them is the whole thing.

The Model Question

There is a separate article in the cost story and I will write it properly another time. The short version: I rebuilt the model stack entirely. What I am running now costs a fraction of what the early versions cost, without meaningful loss in output quality. The economics of this are more interesting than most people realize, and they change the feasibility calculation for what you can actually run.

For now, the architecture works. The cost is manageable. That is enough to say here.

What I Learned

A few things worth writing down because I have not seen them clearly stated elsewhere.

1. The portability test is the only test that matters:
Build your AI infrastructure and then leave the building. Come back in 48 hours. Does it still work? If not, you have not built infrastructure. You have built a local setup with an illusion of permanence.

2. The failure mode that kills you is the one that fails silently:
Talon used to stop working and never tell me. $Ani on the Mac Mini went silent without an alert. The agent that appears to be running until the moment you need it most is worse than an agent that never worked at all. Build the Patrol before you build the Planner.

3. The model is not the architecture:
Most of what I read about AI agents focuses on which model you use. The model matters. But the architecture, which is to say how agents coordinate, how memory is managed, how failures are recovered, and where the infrastructure lives, that is what determines whether the thing works in production. A great model on broken infrastructure performs worse than a good model on solid infrastructure.

What Comes Next

I return to Riyadh on Friday. I will find out what actually broke on the Mac Mini. I will set up the VPS, deploy the multi-agent system, and run the first real test of this architecture.

If it works, the next post will explain exactly how I did it.

If it breaks, the next post will explain exactly how it broke.

That is the deal I am making with anyone who reads this. Not polished outcomes. The real thing.

Why I Am Writing This

I have spent 28 years in marketing and brand strategy. Not agency-side only. I ran marketing for du, Virgin Mobile, and Expo 2020 Dubai. I have sat on both sides of the table: the agency that builds the strategy and the client who has to live with it when it works and when it does not.

I am now applying that same standard to AI infrastructure. Not because I want to become a developer. Because the next phase of marketing, brand, and business strategy is being shaped by people who understand how these systems actually work, not people who delegate the understanding.

If you are reading this as someone who has tried to build AI agents and hit the same walls, or as someone who knows they need to understand this better before it is too late, this is for you.

Does it travel? is the book I am writing. This is the first chapter.

If this resonated, subscribe. I publish when I have something real to say, not on a schedule. Next: how I built the new architecture, what I used, and whether it actually worked.