Most businesses are buying AI like it's 2019 software.

They're comparing feature lists instead of asking "what's the infrastructure?"

I've watched this pattern repeat across dozens of expert-led practices. They evaluate AI tools the same way they'd evaluate accounting software: does it have the features we need? What's the monthly cost? Can it integrate with our existing stack?

Wrong questions entirely.

The businesses that actually transform with AI aren't asking about features. They're asking about architecture. Can this swap models when Anthropic goes down? Does it maintain context across agent handoffs? What happens when the API rate limits hit during peak load?

Last week, Anthropic's Fable suspension proved the point perfectly. Businesses that built on single-model dependencies scrambled to rewrite prompts and retrain workflows. Meanwhile, practices with model-agnostic architectures swapped from Claude to GPT in minutes and kept operating.

The difference isn't technical sophistication, it's thinking like an operator instead of a buyer.

When Adobe rebuilt Photoshop with AI at the centre, they didn't bolt ChatGPT onto existing workflows. They redesigned the entire content creation pipeline around AI capabilities.

Content-aware fill isn't a feature addition, it's a fundamental rethinking of how image editing works.

Most knowledge businesses do the opposite. They add Zapier triggers to broken workflows. Slap AI features onto manual processes. Build ChatGPT wrappers and call them "AI-powered solutions."

The result is expensive theatre that breaks under real operational load.

Real AI infrastructure starts with a different question: what would this business look like if it was designed from scratch with AI agents as the primary workforce?

For a legal practice, that might mean agents that draft, review, and route documents through approval workflows without human handoffs. For a consulting firm, it could be research agents that maintain client context across multi-month engagements and surface relevant insights proactively.

But here's what separates working AI operations from expensive demos: the supervision layer.

Most businesses focus on the agents: what they can do, how smart they are, how human-like their outputs feel. The real infrastructure challenge is building systems that know when agents are wrong, can route edge cases to human experts, and maintain quality without becoming bottlenecks.

This means building agent pipelines with explicit checkpoints, not just prompt chains. It means designing handoff protocols between AI and human work that preserve context and maintain accountability. It means treating AI agents like any other operational resource, with monitoring, failure modes, and escalation paths.

The businesses winning with AI aren't the ones with the cleverest prompts or the latest models. They're the ones that rebuilt their operational architecture around AI-first principles and designed systems robust enough to handle real client work at scale.

Your takeaway this week: audit one core workflow in your practice. Don't ask "how could AI help with this?" Ask "if this workflow was designed from scratch with AI agents handling 80% of the work, what would the architecture look like?" Then start building that, not bolting ChatGPT onto what you have.

Most agent frameworks lock you into a single model provider, a design decision that looks cost-efficient until your primary model goes down or degrades.

Smart operators are building model-agnostic routing layers that can switch between Claude, GPT and Gemini based on task requirements and availability. The pattern involves three components:

The routing logic is simpler than it sounds. Creative tasks route to Claude for its reasoning depth. Structured data extraction goes to GPT for consistency. Code generation hits whatever model has the lowest latency that hour.

This isn't premature optimisation; it's operational resilience. When Anthropic suspended Fable access, practices with single-model dependencies stopped operating. Multi-model architectures kept running.

The implementation overhead is minimal if you design for it upfront. Build your agent interfaces around task specifications, not model-specific prompts. Use configuration files for routing rules instead of hardcoded model calls. Design your prompt templates to work across providers with minimal adaptation.

Worth the engineering investment for any practice running AI agents in production.

Domain expertise beats prompt engineering every time. Anthropic's research confirms what operators already know, which is that AI develops real domain knowledge, not just mimicry. The expertise you thought AI would devalue actually makes AI valuable. A tax agent trained on your specific client scenarios will outperform generic ChatGPT every time.

Model swapping is table stakes now. If your AI stack can't switch providers in under 10 minutes, you're building a single point of failure, not robust infrastructure. The businesses that survived this week's Anthropic issues had model-agnostic architectures ready to deploy.

Infrastructure decisions compound. Early architectural choices about agent supervision, model routing, and context management determine whether your AI operations scale or break under load. Design for production from day one, not prototype-to-production later.

AI theatre is getting expensive. Most "AI-powered" products are existing software with ChatGPT bolted on. The market is waking up to this. Real transformation means rebuilding workflows around AI capabilities, not adding AI features to broken processes.

Our content generation agents started disagreeing with each other this week.

We run multiple agents for different content types: one for LinkedIn posts, another for newsletter drafts, a third for technical documentation. They share context through a central knowledge base but maintain separate reasoning chains.

The LinkedIn agent flagged a newsletter draft as "too technical for social distribution". The newsletter agent pushed back, arguing the audience expects architectural depth. Both were right within their operational contexts.

This wasn't a bug. It was emergence. The agents had developed distinct perspectives based on their training data and feedback loops. The LinkedIn agent optimised for engagement metrics and social platform constraints. The newsletter agent optimised for subscriber retention and expertise demonstration.

We could have flattened this into a single "content agent" with unified outputs. Instead, we built a coordination layer that preserves the tension. The agents now negotiate content decisions through structured debate, with human oversight for final calls.

The lesson: agent disagreement isn't always a failure mode. Sometimes it's a feature. When your agents start developing distinct operational perspectives, you're building something closer to a real AI workforce than a collection of smart tools.

The coordination overhead is real, but so is the output quality improvement. Our content pipeline now catches blind spots that single-agent systems miss.

Tony