Technical 17 July 2026

Belvedere Is Dead.

Long Live Belvedere.

Back in April, I built myself a digital butler named Belvedere. He was a custom-coded AI agentic harness designed to run quietly in the background, pick up tasks, coordinate different models, manage context, and generally make me feel like I was living a few years ahead of everyone else. It was the absolute dream of the moment: a tireless, autonomous AI colleague humming away on a server, turning my vague intentions into completed work while I got on with more interesting things.

But by July, Belvedere had been sitting completely unused for a month. There was no dramatic shutdown or cinematic deletion of the repository; I simply stopped messaging him. And honestly? That might be the most successful thing Belvedere ever did.

The romanticised promise of autonomous agents is incredibly enticing. You give them high-level goals, and they break them down into discrete tasks, remember yesterday’s context, check their own work, and interface with other agents. In theory, you wake up to find your backlog has miraculously cleared. In practice, however, running a DIY agent felt less like hiring a polished butler and more like keeping an unsupervised work experience student away from the production code.

To make matters worse, I had hooked Belvedere up to Telegram.

Initially, this felt incredibly sci-fi. I was getting real-time progress updates pushed straight to my phone. I felt hyper-productive, orchestrating server deployments while standing in the Starbucks drive through queue. But the novelty wore off fast. That “always-on” connectivity quickly devolved into a high-stress babysitting gig. Every vibration in my pocket wasn’t a finished task; it was a notification that Belvedere had hit a minor edge case, hallucinated a dependency, or was currently looping on a terminal command. I wasn’t delegation focused, I was helicoptering.

Belvedere worked, sometimes brilliantly, but running him introduced an entirely new category of chore. I had to monitor token burn, preserve context, constantly tweak prompts, constrain infinite loops, inspect obscure execution failures, and second-guess model behaviour. The more autonomous the system became, the more effort went into making sure it didn’t confidently wander into the road.

Context rot was brutal; long-running agents accumulate assumptions, stale information, and tiny misunderstandings until they spend six hours building entirely the wrong thing. Combine that with an autonomous loop’s ability to consume API tokens with the enthusiasm of a Labrador at a buffet, and the friction started to outweigh the utility.

Meanwhile, the frontier models simply got too good. Companies like OpenAI, Anthropic, and Google made their premium subscriptions so frictionless, fast, and feature-rich that opening a terminal became infinitely easier than maintaining my own background daemon. I gradually stopped calling on Belvedere, and he quietly slipped into retirement.

The 120-Day Glow-Up

There is a particular kind of guilt attached to abandoning a side project. You think about the late nights telling yourself that this was definitely going to become a major platform. But Belvedere was not a failed project; he was a compressed engineering education disguised as an overambitious AI butler.

Back in March, I was still effectively “vibe-coding.” My process relied heavily on interactive sessions with Claude. I would prompt the model for a script, copy-paste the terminal output, and manually SCP files to my remote box, hoping for the best.

Today, my development workflow is unrecognisable.

This transformation didn’t happen because I sat down with a textbook on enterprise DevOps. It happened because Belvedere kept creating complex, real-world problems that could only be solved by learning better engineering.

Hard Lessons in the Sandbox

My first real bottleneck was token burn. Using the most capable, expensive frontier models for basic code execution or routine file formatting was an incredibly fast way to run up a massive bill. To solve this, I had to design a tiered, multi-agent verification pipeline: Architect → Implement → Review → Execute.

Under this setup, a heavyweight model handles the high-level system architecture and session orchestration (Claude Opus). A cheaper, faster model performs the bounded code implementation (Claude Sonnet). A third, independent agent (Codex) reviews the code against security and style guidelines, and execution only occurs once the work passes that final gate.

What started as an attempt to save money completely changed how I think about system design. It forced me to isolate responsibilities, write testable requirements, and dramatically reduce the blast radius of LLM hallucinations.

But the biggest shift was psychological. Moving from interactive chat sessions to this structured, headless agentic looping framework meant my role changed from “babysitter” to “systems engineer.”

Instead of hovering over a Telegram thread, prompting to nudge a stubborn model back on track, I could focus entirely on high-intensity planning sessions. I would define the architecture, feed the system the precise parameters, kick off the pipeline, and physically step away. The system executed the plan, verified its own work, and only surfaced to alert me when a human gate required a strategic decision.

Now, as an engineer, I didn’t commit the cardinal developer sin of running Belvedere locally on my laptop; he lived on a dedicated VPS from day one. But running an autonomous, headless daemon on a remote server introduces its own flavour of chaos. If an agent is going to operate autonomously across different repositories, APIs, and environments, a single SSH port and some faith aren’t enough.

To make this system secure and resilient, I had to build actual infrastructure. That friction forced me to set up a private Tailscale network to securely link my local dev environment to the agent, orchestrate multi-region VPSs, deploy my frontend via Cloudflare Pages, and automate system-wide backups using Restic. The environment stopped being a single remote box and became a cohesive, professional system.

Finally, managing a growing codebase with an autonomous agent will teach you the value of Git faster than any computer science programme. When you have multiple agents writing code and interacting through terminal sessions, mental notes don’t cut it. One rogue prompt can easily overwrite another agent’s work. I had to implement proper task management with Linear, connect my development tools via custom MCP servers, and move everything to structured Git workflows with gated PRs and automated CI/CD pipelines.

The absolute fastest way to discover why modern engineering and DevOps disciplines exist is to give an AI agent enough autonomy to violate all of them.

Belvedere forced me to learn every single one of these lessons not through dry theory, but through immediate, practical friction.

The Butler’s Final Task

By July, the reality was obvious: I no longer needed Belvedere in the form I had originally built him. The major AI platforms had absorbed his day-to-day utility into polished, managed ecosystems. But that doesn’t mean Belvedere lost; he succeeded as the ultimate sandbox.

He was the scaffolding that allowed me to transition from an amateur prompter running chaotic terminal sessions to a systems engineer designing multi-agent deployment pipelines. That is an incredible rate of professional growth for a four-month period.

The lasting legacy of the recent agent hype won’t be millions of autonomous bots quietly running our lives in the background. Instead, the real value lies in how these tools lower the barrier to entry, encouraging curious builders to tackle projects far beyond their current technical limits and forcing them to learn serious, enterprise-grade engineering disciplines at warp speed.

Belvedere is gathering dust on GitHub, but the skills I built while coding him are very much alive. I am currently leveraging this entire DevOps stack to build and deploy a real, production-ready product. The butler’s final task, it turns out, was teaching me how to build without him.

← Writing · Andy Bridson