Current AI and the Web of AI’s Hidden Power Grab

Open agent standards promise interoperability, but the real fight is over identity, governance, and who controls the new AI plumbing.

Current AI has become a useful lens on the emerging web of AI, but the real story is less utopian than it sounds. What looks like a movement for openness is also a brutal fight over standards, interoperability, identity, governance, and who gets to control the plumbing once AI agents start crossing real system boundaries.

I can always tell when an industry is leaving the demo phase: the acronyms show up.

MCP. A2A. AG-UI. x402. UTCP. Suddenly the same people who spent two years selling “magic” are back in the least sexy business in tech — standards, compatibility, auth, versioning, governance. Bellissimo. We’re doing plumbing again.

That’s the real story behind the TechCrunch piece on Current AI, the nonprofit trying to build a world wide web of AI. It sounds romantic. Open. Slightly utopian. But I’ve been around startups long enough to know what this usually means: everyone loves openness right up until they realize openness means they don’t own the tollbooth anymore.

My hot take is simple. Open agent standards are not a kumbaya movement for the good of humanity. They’re a survival response to integration hell.

Because agents are useless if they can’t talk to anything outside their own little kingdom.

The demos were cute. The integration bill just arrived

This is the part the polished demos skip. It’s easy to make an agent look smart in a sandbox. It’s much harder to make it useful when it has to touch real systems, real money, real approvals, and the deeply cursed internal software stack of an actual company.

AWS put this more politely than I would in its post on the Strands Agents SDK. Most teams still rely on “hand-rolled adapters and bespoke orchestration code,” and the mess gets worse every time you add a new agent, tool, or frontend. That sentence alone tells me somebody there has actually shipped software instead of just making keynote slides.

AWS frames the emerging agentic stack as a set of complementary protocols — MCP, A2A, UTCP, AG-UI, x402 — not one winner-take-all standard. That matters. It’s the internet lesson all over again: different layers solve different problems, and pretending one protocol does everything is how you end up with a very expensive mess and a founder explaining delays to investors with the thousand-yard stare.

Their example is a grocery concierge called Pantry, and I like it because it’s concrete. Pantry checks inventory, finds substitutions, charges the customer, schedules delivery, and streams updates back to the app. In other words, it does what real systems do: it crosses boundaries. Inventory system here. Payment rail there. Human approval somewhere else. Customer interface on top. Chaos in the middle.

That’s the whole game.

An agent is only as useful as the systems it can reach. AWS says agents need access not just to model output but to tools, other agents, humans, and payments. I’d add one more thing: accountability. The second an agent touches billing or procurement, nobody cares how elegant your prompt stack is. They care who approved what, what broke, and why the charge hit the wrong card at 2:13 a.m.

I learned this the hard way years ago building ALYT, a home automation platform with hub hardware, mobile apps, and cloud services. Everyone loves the shiny demo where the lights turn on from your phone. Very few people enjoy the part where the firmware version on the hub doesn’t match the mobile release, the cloud auth token expires, and Apple decides your app metadata needs one more review cycle because reasons. Products fail at the seams. They always have. AI agents are just the latest thing discovering gravity.

That’s why Current AI and this broader web of AI push matter. Not because “open” is morally superior by default. I like openness, but I’m not naïve. It matters because serious AI products are hitting the same boring, brutal reality: without AI agent interoperability, every useful deployment turns into custom glue code and maintenance debt.

And custom glue code is where margins go to die.

This isn’t new. It’s the internet relearning an old lesson

The funniest part of this whole moment is how futuristic everyone sounds while rediscovering ideas the internet has been chewing on for decades.

The W3C WebAgents Community Group report points back to Dagstuhl Seminar 21072 in 2021 and Dagstuhl Seminar 23081 in 2023, both focused on Agents on the Web. So no, this isn’t random hype invented by a VC with a beige Substack and a pastel website. There’s actual lineage here.

The W3C report traces a path from DARPA’s CoABS to DAML, then to OWL and OWL-S — a long, nerdy history of trying to make machines discover, interpret, and coordinate with each other over web infrastructure instead of through bespoke middleware. My nonna would not care about OWL-S for even one second, but she would understand the underlying point: if every shop in town speaks a different dialect, buying bread becomes a project.

And we’ve done this before at scale. The report notes that AgentCities had 41 agent platforms in 21 countries in 2002, then 60 in 2003, then 160 by 2005. Read that again. Two decades ago, people were already trying to build networks of interoperable agents and avoid fragmentation. Different tools, same human behavior.

The W3C also calls out current efforts including Model Context Protocol, Agent2Agent Protocol, Agent Network Protocol, and Eclipse LMOS. That turns today’s alphabet soup into something more legible. Not a random pile of startup branding. A fresh pass at an old infrastructure problem.

I’ve seen founders act like their stack is unprecedented because they wrapped an LLM around it and gave it a moody black landing page. Sorry, ragazzi, but half of tech is just rediscovering standards after wasting money reinventing them. I say that with love because I’ve done my share of reinvention too.

The web didn’t become powerful because every site used the same backend. It became powerful because common protocols let wildly different systems coexist. That’s the dream now for open agent protocols.

Not one giant brain. A network.

Open standards usually win. Then somebody builds a gate on top

Here’s where I become slightly annoying at dinner.

Open standards usually do win at the infrastructure layer. I believe that. But they do not eliminate power. They relocate it.

Once interoperability becomes normal, the leverage shifts upward: discovery, identity, trust, default interfaces, governance, billing, distribution. The roads become public, then somebody builds the map, the tolls, and the traffic lights and calls it an ecosystem.

Google’s enterprise docs are a perfect example. On paper, Gemini Enterprise lets admins connect A2A agents hosted on any platform into the Gemini Enterprise web app. Great. That’s real Agent2Agent support. According to Google’s documentation, A2A is “an open communication protocol and a universal language for agents” that lets agents “discover each other, collaborate, and securely delegate tasks.”

Strong statement.

Then platform reality walks in wearing steel-toe boots. To use it, admins need the Gemini Enterprise Admin role, must enable the Discovery Engine API, and must already have a Gemini Enterprise app. Google also notes support for A2A v0.3 streaming, and if you’re on A2A v1.0.0 or later, you need compatibility packages.

Which is normal. Practical. And revealing.

Open road. Managed gate.

Google’s other docs say the A2A protocol was donated by Google Cloud to the Linux Foundation in June 2025. Good move. Smart move. Also a move that tells you exactly where this is headed: vendors want the protocol to feel neutral while competing like maniacs on the layers around it.

IBM is even more explicit, which I weirdly respect. In its June 2026 launch of the Agentic Control Plane for watsonx Orchestrate, IBM says: “AI agents only deliver value when you can see what they’re doing, control how they behave, and scale what’s working.” That is not idealistic language. That is enterprise language. Which means somebody in Armonk has met a compliance department before.

IBM promises visibility, governance, reuse, and scheduling across enterprise agents. Translation: sure, let the agents talk. But somebody still needs to supervise the little maniacs.

This is the founder lesson people keep pretending not to know. Nobody wants to own the roads if they can own the map.

Or the login screen.

Or the app directory.

Or the policy engine that decides which agent gets trusted first.

That’s why I think the real AI war is moving below the model and then immediately back above the protocol. The raw model layer still matters, obviously. But once AI agent standards stabilize, the next battle is who becomes the default control surface for an “open” network.

And defaults are where empires get built.

The hard part isn’t making agents talk. It’s making them trustworthy

Interoperability without trust is just a faster way to spread bad decisions.

This is where a lot of the web of AI rhetoric gets a little too cute for me. A world full of agents talking to tools and to each other sounds great until you remember that every new connection is also a new attack surface. More capabilities means more ways to screw up, more ways to get spoofed, and more ways to let a confident machine do something stupid at machine speed.

The most grounded source on this is NIST. In its analysis of responses on AI agent security, NIST says commenters “widely agreed that AI agents present novel security threats and that these security concerns present a barrier to adoption.” That’s not a niche concern from paranoid CISOs. That’s broad consensus.

NIST also says traditional cybersecurity principles still matter but “will require adaptation to satisfactorily address agent security.” Exactly. Identity, least privilege, logging, approvals, environment separation — none of that goes away. But agents change the shape of the problem because they chain actions, delegate tasks, and use tools dynamically.

And the implementation details already show the gap between “open” and “safe.” Google’s Gemini Enterprise docs warn that developers must configure Model Armor via the REST API because the settings in the Gemini Enterprise console don’t automatically protect A2A agents. That’s not a theoretical edge case. That’s real product plumbing saying, very politely, “please don’t assume the checkbox covers this.”

Google also notes that A2A agents can use OAuth 2.0 for end-user access control or rely on IAM-based controls depending on deployment. Again, this is what the real fight looks like. Not “will agents change everything?” Yes, yes, va bene. The harder question is: who handles identity, delegation, permissions, audit, and revocation when one agent calls another agent that touches a third-party tool that triggers a payment?

That sentence alone is why half of enterprise AI pilots age like milk.

IBM’s pitch around the Agentic Control Plane leans hard into built-in security, governance, and compliance controls across cloud and on-prem environments. Cynical take: nice upsell. My actual take: they’re not wrong. The winners here may not be the companies with the flashiest agents. They may be the ones that make agent behavior legible enough for legal, finance, security, and ops to stop hyperventilating.

I’ll be honest about something. Even after two decades building systems, AI agents still make me uneasy in a way normal software doesn’t. Not because they’re smarter — most of the time they’re not — but because they create an illusion of competence that seduces operators into granting too much autonomy too early. I’ve shipped IoT platforms for carriers and energy companies. I’ve seen what happens when software gets one permission too many. With agents, the blast radius is social as much as technical. People trust the tone before they verify the action.

That’s dangerous.

Abstract illustration depicting interconnected AI networks, symbolizing hidden power dynamics in technology and the web.

Big Tech is backing open agent protocols because customers forced it

The plot twist here is almost funny.

The incumbents are not rallying around open agent protocols because they all woke up with a sudden passion for digital freedom. They’re doing it because enterprise customers hate lock-in, hate brittle integrations, and really hate paying six times for the same plumbing under different branding.

According to The Information, OpenAI, Anthropic, and Google agreed to develop agent standards together with the Linux Foundation. Read that slowly. These companies are in a knife fight everywhere else, and they still found religion on standards. That tells you the pain is real.

AWS says organizations implementing agent architectures face major challenges around interoperability, vendor independence, and future-proofing their investments. That sentence could have been written by any CTO who got burned by proprietary workflow tooling in the last decade. Once you start wiring agents into customer support, procurement, analytics, internal search, finance, and payments, switching costs become vicious.

And customers know it.

That’s why this is bigger than Current AI as a nonprofit story, even if the TechCrunch framing around a world wide web of AI is useful. The real momentum isn’t coming only from idealists. It’s coming from buyers asking very boring questions like: Will this still work if we change vendors? Can our internal systems talk to external agents? Are we rebuilding the same integration every quarter? Who owns the identity layer? What happens when the model provider changes API behavior?

I spend a lot of time between Torino and Los Angeles, and one thing is true in boardrooms on both sides of the Atlantic: customers do not care whose protocol wins. They care whether the thing breaks less often.

That’s it.

Google’s docs show these standards are moving into shipping infrastructure. IBM’s launch shows the governance layer is already being packaged. AWS is explicitly teaching people to think in stack layers, not single-vendor abstractions. This is what market pressure looks like when the AI industry stops flirting and starts integrating.

Openness here is not charity.

It’s demand.

Europe should not miss this layer again

Now let me put on my very Italian, very pro-European hat for a second.

Europe missed too much of the consumer internet platform era. We can blame capital markets, fragmentation, culture, whatever — and some of those explanations are fair — but the result is obvious. We use infrastructure and platforms mostly built elsewhere, then spend years debating how to regulate access to systems we didn’t create. I have zero interest in repeating that movie with agentic computing.

The good news is this layer is still open.

That’s what makes this moment important. The institutions and battlefields are still being formed: W3C community work, Linux Foundation governance, NIST security framing, and active enterprise implementation from AWS, Google, and IBM. This is not settled. The rails are still contested.

And Europe historically does better at rails than at dopamine apps.

The W3C’s role matters for exactly that reason. The fact that the WebAgents report is already mapping efforts like MCP, Agent2Agent, Agent Network Protocol, and Eclipse LMOS tells me this is not too early for European participation. It’s almost late, but not too late.

The Linux Foundation angle matters too. Google donating A2A in June 2025 is a reminder that foundational layers are still up for grabs. If Europe wants influence, this is where it should show up with engineers, standards bodies, enterprise buyers, and actual products — not just position papers and politely panicked panels in Brussels.

I say this as someone born and raised in Ivrea, the town of Olivetti, where engineering ambition used to come with the assumption that Europe could build foundational technology, not just consume it elegantly. I’d much rather see Europe become indispensable in identity, governance, trust, compliance tooling, and enterprise-grade interoperability for the web of AI than spend another decade congratulating itself for regulating products built in San Francisco and Shenzhen.

Governance is not sexy. But neither was TCP/IP at dinner.

If the next phase of AI depends on trusted digital infrastructure — identity layers, auditable delegation, policy enforcement, secure cross-agent messaging, enterprise control planes — then Europe has a real chance to matter.

But only if we build.

Not just comment.

The monopoly to watch won’t look like the last one

Here’s my bet.

The next AI monopoly probably won’t look like a model monopoly. It’ll look like the company that becomes the default identity layer, discovery layer, or control plane for every agent pretending to be open.

That’s why I find the Current AI story interesting. Not because I think nonprofits magically save ecosystems — they don’t — but because the fight over the world wide web of AI is really a fight over whether the plumbing stays plural long enough for a real ecosystem to emerge. Open protocols are necessary. I’m fully on board there. But they do not guarantee an open market.

We probably are going to get a web of AI.

The question is whether it feels like the early internet — messy, permissionless, alive — or like cable TV with better branding.

Frequently asked questions

What is Current AI trying to build with the web of AI?

Current AI is pushing a world wide web of AI built on open agent standards so AI systems can interact across tools, agents, humans, and payments instead of staying trapped in isolated vendor ecosystems.

Why do open agent standards matter for enterprise AI?

Open agent standards matter because enterprise AI deployments become expensive and fragile when every agent requires custom integrations, bespoke orchestration, and duplicated identity, approval, and governance work across systems.

What is the biggest risk in a web of AI?

The biggest risk in a web of AI is not communication alone but trust, because interoperable agents create new attack surfaces and require strong identity, permissions, logging, approvals, and governance controls.