The AI implementation dilemma

How to navigate in a big AI labs-driven wave

While Yann LeCun tweets about revolutionizing AI architectures and big labs struggle with finding ever-more-efficient models, most organizations face a fundamentally different challenge. I do not mean Deepseek's seism is not affecting us, but we can’t lose our focus in advancing through AI-driven strategies (these seisms are going to be a constant distraction). Our task isn’t to build better foundation models—it’s to create value with existing AI capabilities, operating in a field where today’s certainties become tomorrow’s obsolete assumptions, and that are controlled by a handful of protagonists.

Focus, focus,?focus

We are currently bearing three key strategic tensions. The first one is the dependency challenge. We rely on models and APIs we don’t control when they change or become obsolete. Pricing and availability are outside our control. The second tension is the implementation challenge. Each new model requires different approaches while skills and best practices keep evolving. What works today might not work tomorrow. Last, we deal with the investment challenge (when to adopt new models, how much to invest in current implementations, and how to build lasting value despite constant change).?

These challenges are interrelated, as we can see in figure 1. The ideal point is found when balancing the three challenges (first scenario on the left part of the figure). If we want to reduce the dependencies on main vendors, we will require an extra effort in implementation as we will need to develop new internal skills to pay for this independence (internal research, proprietary solutions, etc.). It also will increase costs (second scenario). If we want to reduce the implementation challenge (having fewer resources inside the organization), it will increase our dependency on model providers, which can increase the costs (third scenario). Last, if we reduce investment, it will barely affect our dependency or our implementation (fourth scenario) unless this reduction isn't general but in specific resources like implementation or dependencies. Then what we are going to do is go back to reducing dependencies or implementation scenarios.

Reducing dependencies: strategic model selection

The first rule for reducing dependency is not to get impressed by the latest models and technologies. Instead, we should focus on fit-for-purpose solutions. Some steps for this strategy are:

• Create a model evaluation framework focused on your specific needs
• Test models on actual business problems, not benchmark tasks
• Consider older, stable models for non-critical applications
• Build with model replaceability in mind

Example: A mid-sized insurance company successfully automated document processing using older or open-source models like GPT-3, despite newer models being available, because it met their needs and offered stability.

Reducing implementation: architecture for adaptability

Reducing implementation challenges would imply improving internal resource resilience through designing systems that can evolve without requiring complete rebuilds. Some steps for this strategy can be:

• Build abstraction layers between business logic and AI models
• Create model-agnostic interfaces
• Develop clear handoff points between AI and human processes
• Document assumptions about model capabilities

Example: A telecom company created a modular chatbot system that could switch between different LLMs without rebuilding their customer service workflows.

Risk management in?practice

When we talk about AI strategy risk management, we often get lost in abstract concepts, or we mix it up with the risks associated with the privacy of our data or the security of our systems. Instead, let's look at how organizations are actually handling these challenges on the ground. Picture an AI system like a complex symphony—multiple instruments playing together, each needing backup plans and careful coordination.

A compelling strategy combines continuous monitoring with smart fallback options. Think of it like a self-driving car that doesn't just rely on one sensor but maintains awareness through multiple systems. When their primary AI model shows signs of degradation—perhaps unusual response patterns or low accuracy—the system smoothly transitions to a secondary provider. If both AI options fail, a simpler rule-based system takes over, ensuring basic service continuity.

Building systems that get stronger through challenge and change has to follow, at least, these steps:

• Maintain fallback options for critical AI systems
• Create clear metrics for model performance monitoring
• Build expertise in prompt engineering across multiple models
• Develop contingency plans for API changes or outages

Implementation roadmap

Every strategy needs to focus on business-relevant metrics:

• System reliability and uptime (stay updated because obsolescence has a new meaning with AI)
• Speed of adaptation to model changes (in less than 24h, you have to be able to replace a foundational model for another in your architecture)
• Cost predictability (e.g., measure cost per insight instead of cost per computation)
• Business outcome improvements (ROI and ROAI—returns on Artificial Intelligence)
• Implementation efficiency (it's all about efficiency)