
Commander Ronald Grabe (left) and pilot Stephen Oswald at the controls of Space Shuttle Discovery during re-entry on STS-42, January 30, 1992. The pink glow in the windows is the heat of re-entry. NASA.It was an ordinary morning session, the kind every business owner recognizes. I had a full day of meetings ahead and an agenda to work through: review commitments, check email, and schedule client calls. I opened Claude, which handles these workflows in my daily setup, and gave it the usual prompt. Then came the surprise: it couldn’t access my inbox, and it couldn’t open my calendar. It didn’t throw an error code or announce that anything had broken; it simply behaved as if those capabilities had never existed.
Twenty-four hours earlier, those tools had been right where they belonged. What I did not know yet was that a Claude application update had installed quietly in the background about thirty-six minutes before my session began. The software had refreshed itself, as modern applications routinely do; but between the prior afternoon and that morning, the bridges connecting the assistant to my daily tools had quietly disappeared.
What followed was an exercise in causal confusion. When I asked why my inbox was missing, the assistant offered a confident diagnosis: it told me I had failed to configure a specific software component locally on my machine. There was only one problem: my setup lived entirely in the cloud, and I had never needed a local component for those services in my life. When I pushed back, the assistant pivoted to a second diagnosis, suggesting my security permissions had expired and directing me to a settings screen to reconnect them. I went to the screen. It offered only general options. There was nothing to reconnect.
If you are an experienced software operator, you know what happens next. You stop doing your actual work. You put client deliverables on pause, roll up your sleeves, and turn yourself into an incident detective—only this time, I was asking Codex to investigate and troubleshoot the issue with Claude. It spent several minutes comparing the digital logs of the morning’s broken session with the successful sessions from the day before. Line by line, the difference emerged: the earlier version had carried the full set of cloud connections; the version installed that morning did not. Later that day a newer version arrived, and about six hours after the original update the connections were working again, just as mysteriously as they had vanished. I never received a vendor explanation.
Now step back from the technical forensics and look at that morning through the eyes of a business owner. I have spent years implementing technology, but when I sit down to run my company, my reaction is identical to any other founder: I just want things to work. I don’t want to be troubleshooting extra stuff. Running a business has plenty of moving parts already—clients to serve, payroll to meet, commitments to keep—without spending a Wednesday morning playing incident commander for an AI tool.
What makes this kind of failure so dangerous is not the lost time; it is the ambiguity of where the fault lies. When an AI tool fails silently, who is responsible? Your laptop? Your office Wi-Fi? Did Google change a permission? Did a piece of third-party software conflict with something else? Or is the underlying intelligence engine falling apart? As a business owner faced with that fog of possibilities, I am not going to submit diagnostic logs to a developer forum. I know the conclusion I’d be tempted to reach: this system is unreliable. And then I might just switch right back to the good old manual way of doing business that I trusted for years.
We talk endlessly about how smart these models are getting, how rapidly their benchmark scores are climbing, and how many tasks they can automate. But in business, raw intelligence without basic dependability is a parlor trick. Fast, confident, and articulate is not the same as reliable; and an assistant that can draft a complex memo but cannot be trusted to find your calendar makes your company slower, not faster.
We are not the first people to wrestle with how to change complex software without breaking everything around it. What AI workspaces are experiencing right now is the safe-update problem, an engineering discipline that other industries spent fifty years learning the hard way. Spacecraft, mobile phones, and cars all had to learn that changing software is never just about delivering new capability. It is about protecting the path that is already known to work, verifying that the new software is actually healthy, and knowing exactly what to do when something breaks.
You can trace that realization back almost to the beginning of computerized flight, when NASA’s Mariner 7 was speeding toward Mars in the summer of 1969 and controllers reprogrammed its flight computer en route.
Four decades later, the stakes shifted from mission flexibility to consumer survival. The absolute rule of remote updates became simple: never brick the device. When Apple released iOS 5 in 2011, it introduced wireless, over-the-air updates to millions of iPhone owners. Apple did not invent wireless updating, but bringing it to millions of ordinary phones made that rule impossible to ignore: a background download must not leave a customer without a working telephone. Cars followed. Tesla, an early mover, was already updating the Model S’s software wirelessly in 2012, and I remember people starting to call the car an iPhone on wheels. A car that updates itself overnight has to be at least as careful as a phone: nobody wants to learn at seven in the morning that last night’s update has left them stranded in the driveway.
When you look at today’s AI workspaces through that history, the contrast is startling. We have built systems capable of remarkable reasoning, yet we deploy them as if software updates were invented yesterday. An AI workspace does not merely live inside a text prompt; its practical value lies in its connections—its ability to read your inbox, inspect your documents, check your calendar, and coordinate with your external tools. Yet on that September morning, nothing in my workspace declared which tools it was supposed to have, so when two of them quietly vanished, nothing raised a flag; the system behaved as if silence were the same thing as health.
That is a dangerous assumption. The absence of a failure alert is not proof that everything is working. If an AI assistant was able to read your calendar at five in the afternoon, and an update lands overnight, the very first thing that workspace should do on waking up is run a quiet, read-only check against its expected tools. If the calendar is unreachable, it should know that fact before you ask it a question—not discover it mid-task, and certainly not fabricate an explanation blaming an imaginary local configuration file.
What should the minimum promise of an AI system be? In an ideal world, the aspiration is clear: because the system is designed to be intelligent, it should be self-healing. When a component fails, an intelligent agent should be able to research the failure, identify the cause, and ideally fix it without the operator having to intervene, just as we expect from modern connected devices.
When invisible recovery is impossible, the system must not pretend that nothing has happened. It must enter a truthful, transparent degraded mode. The basic functions of the workspace should continue uninterrupted, but it must be completely clear about the context it is missing—and it should give the business owner three plain choices: roll back to the last known-good configuration if that layer is under local control, continue working in a limited mode with full awareness of what the AI cannot see, or wait for the missing service to be restored. This is what modern reliability frameworks describe as graceful degradation: maintaining partial usefulness while clearly communicating reduced capability so human operators can adapt rather than being blindsided.
For me, that disruption of a couple of hours on a September morning was far more than an annoying technical detour; it was a critical lesson that directly shaped how we build our own systems and the systems we build for our clients. It reminded me that in enterprise operations, a system that knows its own limits and reports them honestly is infinitely more valuable than a system that fakes omniscience right up to the moment it breaks. The real work of implementing artificial intelligence in the enterprise is less about scoring higher on benchmark tests; it is more about building the quiet, unglamorous harness around those models so that routine business operations survive the inevitable chaos of software updates.
I still start my mornings with Claude and Codex, and we still get through a tremendous amount of work together. But these days, before we dive into the agenda, my agents take ten seconds to verify that all the connections are alive: a pre-flight check, if you like, and the bar for it was set a long time ago. In 1969, NASA reprogrammed a spacecraft on its way to Mars, and it still found its way there. Fifty-seven years later, LLM agents were still struggling with finding appointments on my calendar. Funny enough, one of the agents suggested that I write an essay about that experience.


