Thesis 1 — Foundational Models are a Rising tide

AI agents built to lift with the rising tide of foundational model improvements - rather than anchored and customized to specific versions - will compound their advantage over time. Every time a more capable model ships, a flexible agent simply swaps its cognitive engine and inherits the gains without an architectural rewrite; a tightly-coupled one sinks falls behind due to technical debt.

AI agents built to ride the rising tide of foundational model improvements - rather than anchored to a specific version - compound their advantage . Every time a smarter, faster, cheaper model ships, a flexible agent swaps its cognitive engine and inherits the gains; a tightly-coupled one sinks into debt. Consider teams that hand-tuned elaborate prompts for GPT-3.5’s quirks, only to watch those incantations underperform or misfire on GPT-4. Teams using frameworks like DSPy — which treats prompts as compiled artifacts against a declared signature, not hand-crafted strings — simply recompiled against the new model and captured its gains in an afternoon.

As foundational AI models improve, the AI agents able to take advantage of improved versions, rather than being tightly bound to specific versions, will have a moving advantage.

1. The nature of the “moving advantage”

The “moving advantage” refers to a dynamic, compounding competitive edge. Because foundational models (like GPT-4, Claude 3.5, Gemini) are advancing at a breakneck pace, their capabilities, cost-efficiency, and latency are constantly improving.

Free upgrades: An AI agent built with a model-agnostic architecture acts like a boat rising with the tide. When a cheaper, faster, or smarter foundation model is released, the flexible agent can simply swap out its “cognitive engine” and instantly deliver better margins and performance to the end user without requiring a total code rewrite.

Avoiding AI technical debt: Many developers who spent months highly optimizing prompts and architectures for GPT-3.5 or early Llama models found their work rendered obsolete overnight when GPT-4 was released. Agents tightly bound to a specific version suffer from severe “AI technical debt.”

2. What makes an agent “tightly bound”?

To understand the advantage, it helps to identify what makes an agent fragile to model updates:

Prompt overfitting: Relying on highly specific, convoluted prompts to bypass a specific model’s limitations (e.g., “bribing” the model, using specific formatting tricks). When the model updates, these tricks often break or cause unexpected behaviors.

Proprietary tool calling: Hardcoding an agent to rely entirely on one provider’s specific ecosystem (e.g., relying solely on OpenAI’s specific Assistants API state management) makes migration difficult.

Context window dependency: Designing an architecture around a strict 8k or 32k context window, which breaks or fails to capitalize when a 1-million-token context window becomes available.

3. How to achieve the moving advantage (architectural imperatives)

To capitalize on this thesis, AI developers must adopt specific architectural principles:

The abstraction layer: Developers are increasingly using routing and abstraction layers (like LiteLLM, LangChain, or custom middleware) that standardize inputs and outputs. The agent communicates with the abstraction layer, and the layer translates that to whatever foundational model is currently best.

Robust evaluation frameworks (evals): You cannot confidently swap foundational models without automated testing. Agents with a moving advantage are backed by rigorous “evals” that can run 1,000 test scenarios on a newly released model in an hour, proving it is safe to swap in.

Separation of state and logic: The agent’s memory, logic, and tool-access should live in standard software infrastructure (databases, vector stores, traditional code), using the LLM strictly as a stateless reasoning engine.

4. The counter-argument: the “lowest common denominator” trap

While the thesis is largely correct, there is a distinct trade-off to model-agnosticism.

If you build an agent to work on any model, you risk building for the lowest common denominator. By refusing to tightly bind to a specific model, an agent might miss out on a foundational model’s unique “superpower.”

Example: Gemini 1.5 Pro has native video-processing capabilities and a massive 2-million token context window. Claude 3.5 Sonnet has highly specific UI-generation capabilities (Artifacts).

If you build a perfectly agnostic agent, you may not be able to fully utilize these model-specific breakthroughs until they become industry-wide standards. Sometimes, deep integration yields a superior short-term product.

Conclusion

Your thesis points to a future where foundational models become commoditized utilities (like cloud computing or electricity). In such a world, the true value does not lie in the underlying model itself, but in the agentic scaffolding surrounding it.

The companies and developers who win will be those whose agents act as nimble orchestrators—able to seamlessly plug into GPT-5 today, Claude 4 tomorrow, and Llama 4 the next day, maintaining a continuous, moving advantage over competitors who are stuck rewriting their codebase for every new release.