top of page
Search

AI: From GPTs to MCPs — Haven’t We Seen This Story Before?

Looking ahead through the lens of the past — today’s AI interfaces echo the browser revolution that reshaped the world.
Looking ahead through the lens of the past — today’s AI interfaces echo the browser revolution that reshaped the world.

In a prior blog post, “AI: Not Quite Déjà Vu All Over Again,” I wrote about how AI is repeating a familiar pattern of evolution, albeit much faster this time around. With the emergence of MCPs, that analogy is continuing to play out, and the parallels are becoming even clearer.


In the early 1990s, the internet was a curiosity for most. Few understood what it was. Fewer still knew what to do with it. Then, in 1993, Marc Andreessen and Eric Bina released Mosaic, the first web browser with a graphical interface. Everything changed.


That was the moment. The browser transformed the internet from a technical experiment into something anyone could use. And with that, the future arrived quietly, awkwardly, and full of promise.


The Rise of the Web

The first websites were laughably simple by today’s standards. They were text-heavy, slow, and often broken. But they were still a revelation. Suddenly, you could read the New York Times from your living room, send email, or access the Library of Congress.


It wasn’t about what you could do. It was about the idea that you could do it at all.


What followed was a rapid wave of evolution. HTML gave websites structure. HTTP and TCP/IP made communication possible. JavaScript brought interactivity. Browsers competed, standards emerged, and plugins extended capability. From static pages to dynamic apps, from simple sites to global platforms, the internet became essential.


It took years, but the path was clear. The web grew from curiosity to necessity.


The Pattern Repeats

Now, here we are again. Only this time, the transformation isn’t about the web. It’s about intelligence. Just as browsers evolved into full-stack platforms, GPTs are beginning to evolve into something much more powerful. MCPs.


GPTs, or Generative Pre-trained Transformers, are today where browsers were in the early nineties. Just smart enough to capture attention, not yet capable enough to change everything. But that is changing, and changing fast.


The first time around, it took a decade to go from Mosaic to Facebook. This time, we might go from GPT-4 to autonomous agents writing your code, managing your calendar, and driving your product roadmap in just a few short years.


The parallels are striking and instructive.


Browsers Then, GPTs Now

Here’s how the cycles compare:

1993 to 1996 (Web)

2023 to 2025 (AI)

Mosaic and Netscape launch

GPT-3.5 and GPT-4 release

Static, read-only web

Stateless, prompt-based GPTs

No standards or browser extensions

No memory, context, or native APIs

High potential, limited utility

High curiosity, growing capability

Developers experiment with HTML

Prompt engineers experiment with tasks

Buggy, slow-loading pages

Hallucinations and brittle outputs

Just like early browsers needed structure and support, GPTs do too. They need memory to persist information over time. They need context to understand what matters in a given moment. And they need protocols to take action on your behalf, not just reply in text.

There’s another important parallel. Early browsers began as simple, standalone windows into the web. But over time, they evolved into powerful access points.  Gateways to everything from video calls and banking apps to design tools and cloud storage. Browsers became platforms.


GPTs are following a similar path. Already, they are awkwardly reaching into a growing ecosystem of tools  such as language models, internet search, document summarizers, image generators, even code execution environments. Right now, it is clunky and disjointed. But just like browsers eventually integrated extensions, plugins, and sandboxed applications, GPTs will learn to integrate and orchestrate these capabilities more fluidly.

And that is exactly where MCPs come in.


GPTs to MCPs: The Shift Has Already Begun

We are entering the MCP era. Memory, Context, and Protocols. This is the missing layer between GPTs as chat interfaces and GPTs as real collaborators.


Memory allows models to remember who you are and what you have done before. Context connects them to your documents, data, and daily systems. Protocols allow them to act in the real world, whether that means sending an email, querying a database, or running a workflow.


This is where GPTs begin to function like agents. And that shift is already underway. Tools like OpenAgents, LangGraph, and new orchestration frameworks are beginning to stitch it all together.

Acceleration Is the Curve

It’s not just that the pattern is familiar. It’s that the pace is radically different.


It took nearly twenty years for the web to evolve from early pages to mobile-first platforms. GPT-3 was released in 2020. Just five years later, we are building self-healing codebases, product strategy copilots, and AI agents that quietly operate in the background while we sleep.


This time, the infrastructure is already in place. Cloud computing is mature. Global connectivity is a given. Digital fluency is high. Capital is eager. The conditions are perfect for exponential change.

What Comes Next

If you want to understand where AI is going, don’t look to science fiction. Look to history — then extrapolate boldly.


The early web gave us information access. But it evolved far beyond that. Over time, browsers became platforms that supported real-time collaboration, streamed high-definition video, hosted full design suites, ran entire businesses, and even replaced operating systems. The leap from GeoCities to Google Docs to Figma to ChromeOS was unimaginable in 1995.

AI will take a similar leap.


Today’s GPTs can write emails and summarize documents. But tomorrow’s MCP-powered agents might do far more. Imagine AI copilots that:


  • Continuously monitor your entire product ecosystem, identifying bugs, feature gaps, and competitive threats — then patching code or rewriting requirements on their own.

  • Manage enterprise workflows end to end, initiating strategic decisions based on real-time shifts in financial models, sales performance, or customer behavior — and then communicating those decisions to internal stakeholders.

  • Redesign your UI in real time based on how users are interacting with it — no tickets, no A/B tests, just adaptive design that evolves based on actual behavior.

  • Orchestrate multi-agent systems that operate as your operations, finance, and legal teams — negotiating contracts, forecasting cash flow, filing taxes, and staying within compliance frameworks as rules change.


This isn’t hypothetical. It’s just version 1 of a movie we’ve seen before.


And if that feels ambitious, remember: we went from dial-up bulletin boards to multiplayer online games and global e-commerce in under two decades. AI will get there in a fraction of that time.

Conclusion

We are not witnessing something brand new. We are watching something deeply familiar, only it is happening much faster. AI is not magic. It is momentum. And if you have seen this movie before, you know how it ends. Only this time, it is happening in fast-forward.


From GPTs to MCPs, it’s déjà vu all over again.

 
 
 

Comments


bottom of page