Google’s AI agent platform takes pole position but work stays

Enterprises are rapidly moving from a synthetic intelligence that answers questions and generates content to at least one that performs tasks and takes actions. In keeping with Google Cloud Chief Executive Thomas Kurian, this shift requires a fundamentally different approach to infrastructure and software. Google’s view is that only a tightly integrated portfolio – spanning silicon to applications and the whole lot in between – can effectively support this transition.

A linchpin of this transition is the emergent data and AI platform, what we call the system of intelligence and what Google is initially exposing as its Knowledge Catalog. This capability ultimately abstracts and harmonizes analytics and operational applications. As well as, we see an evolving system of agency – what Google calls a system of motion, comprising the Knowledge Catalog and the Agent Platform.

We expect measurable business value will ride on top of this infrastructure and that’s where the actual battle lines can be drawn. Specifically, we see frontier model vendors, of which Google is one, rapidly constructing out capabilities that can change into fundamental to the longer term of software – which we predict can be the largest transformation within the history of the software industry.

On this Breaking Evaluation, we contextualize the announcements and news from Google Cloud Next 2026 using the framework we’ve been iterating on for the three years, architected by George Gilbert.

Opening setup: TPU 8, the info foundation and the move from chat to actions

The kickoff this week was Google’s big TPU 8 announcement – 8t and 8i – with the Acquired guys hosting. It was positioned as the subsequent big step in Google’s silicon roadmap and a part of a broader message that Google desires to be seen because the only hyperscaler with a frontier model, a differentiated data stack and a reputable path to delivering agents at scale. There was also a little bit of semantic gymnastics around whether a tensor processing unit is an application-specific integrated circuit – Google said “it’s not an ASIC,” slightly a more general-purpose chip.

Call it what you wish – it’s specialized silicon built to run modern AI efficiently, and it’s central to Google’s argument that economics and performance are going to matter greater than ever. Surprising to us on the TPU pre-announcement was, while there have been loads of “2X, 3X, 9.8X” claims, there was virtually no mention of metrics around performance per watt, arguably a very powerful measure for operators which are energy-constrained.

TPUs are each impressive and demanding to Google’s strategy. Our view, nevertheless, is that Nvidia Corp. stays a vital partner of Google’s (and of other hyperscalers), regardless of their in-house silicon efforts. In other words, we don’t see TPU as directly competitive to Nvidia, slightly we see it as a capability that provides Google differentiable advantage via its ability to integrate hardware and software tightly. It also allows Google to best manage the gap between accelerator demand and provide. Regardless, access to Nvidia’s CUDA ecosystem is prime in providing optionality to developers and with the ability to provide access to the world’s largest and most vital AI ecosystem.

The larger setup on this Breaking Evaluation is that Google has been doing yeoman’s work for years in the info platform layer. It’s not only BigQuery. It’s the metadata layer on top, plus integration with the operational database Spanner. In our view, Google is the only hyperscaler that has been meaningfully competitive with Snowflake and Databricks as an information platform – and that work has been an extended construct toward what’s now showing up as an agent platform story.

That is where the conversation starts to get really interesting. For many years, the industry built silos – analytic data silos and operational application silos. Agents that transform a business – agents that may perceive, reason, determine, act and learn – don’t unlock much value in the event that they’re siloed. You find yourself with automation, but you don’t change how the business works.

That is the context for the premise Kurian recommend this week. The industry has moved past retrieval-augmented generation-based chatbots – request and receive a solution – and right into a world where agents, and teams of agents, act on behalf of humans and take motion. That shift pulls a brand new set of infrastructure requirements into the critical path. It needs to be integrated.

Google’s positioning is that it believes it’s the only “full stack” hyperscaler that may bring the pieces together – silicon, infrastructure, data, models, applications and services – right into a coherent system for agentic workloads. At the identical time, many frontier model vendors don’t have a cloud platform, which creates a structural advantage for Google because it tries to show model capability into enterprise deployment. Kurian (and other executives) presented the stack slide below (and variants), throughout the conference to intensify this point.

Takeaway: TPU 8 is the headline, however the more essential story is Google’s try to connect its silicon, data platform and frontier model posture into an integrated agent platform narrative.

Service as software: Why agents force the entire enterprise to re-architect

On this section we revisit our framework for the way the software industry is changing. Later on this research note, we map Google’s model and check out to reconcile the way it matches into our vision of the longer term.

The core idea within the slide below is, in our research, we imagine your complete software industry model is changing, moving from software-as-a-service to “service-as-software.” When the industry moved from on-premises to SaaS, the whole lot modified – the technology model, the business model and the operating model. Vendors stopped shipping software and began operating it. Value delivery became continuous – and the organization needed to be built around that reality.

The shift underway now could be broader. SaaS re-architecture primarily modified software corporations and the knowledge technology function that consumed them. Service-as-software changes your complete enterprise. Any company can scale with less labor by embedding intelligence into workflows and delivering outcomes through software. Over time, that pushes more businesses toward platform economics – and the markets that reward platforms tend toward winner-take-most, with software-like marginal economics conferring competitive advantage to firms that lean into AI.

Agents are the catalyst. Agents don’t unlock much value in the event that they live inside silos. They add real value when they modify business outcomes end-to-end. That’s the purpose of the center a part of the slide above – the system of intelligence or SoI. Google introduced its Knowledge Catalog, which begins to unlock a number of the capabilities of the SoI that we’ve previously described. The purpose is broader, nevertheless, is that this layer connects agents to the operational and analytic reality of the enterprise in order that they can perceive, reason, determine, act and learn across the business, not inside a single department.

The foremost constraint we’re attempting to resolve is shown at the underside of the slide. For 60 years, enterprises built silos – analytic data silos, operational application silos after which the organizational silos that formed around them. Each department finally ends up with its own applications and its own data stores. That structure will not be designed for agents that need cross-functional context and permissions to drive outcomes resembling “compress the hire-to-onboard cycle,” “reduce quote-to-cash friction” or “cut days out of incident response” — and achieve this with human language prompts that reimagine your complete workflow, slightly than “pave the cowpath” by automating existing processes.

Key takeaways

• SaaS modified software vendors and IT – Service-as-software changes entire enterprises as they scale with less labor and deliver outcomes through software;
• Agents create value once they operate across silos – not once they automate isolated tasks;
• The SoI becomes the enterprise “intelligence layer” – a knowledge/catalog-like control point that sits above systems of record and departmental data/app stacks.

Five stages of information platform maturity: The onramp to a digital twin

The slide below is the maturity path from departmental reporting to something that starts to resemble a digital twin of the enterprise – the actual time digital representation of a company. Once we discuss this idea, we frequently indicate that historically in the info business, we predict when it comes to “strings” that databases understand. Here we predict otherwise – when it comes to concepts that humans understand, resembling people, places, things and activities (for instance, processes).

We imagine this represents a profound shift in software. The system of intelligence is an emerging layer and maybe the most beneficial piece of real estate within the emerging AI software stack. It may well’t sit on top of a pile of disconnected metrics and dashboards — business intelligence infrastructure. Somewhat, it needs a substrate that models the business in a way agents can use – with enough context, timeliness and consistency – to drive decisions and actions which are trusted and repeatable at scale.

On the left fringe of the chart, Level 1 is where most corporations began – running reports against siloed operational applications. It’s mostly manual, mostly departmental, and there’s little self-service. Level 2 is where the fashionable data platform story took off – a BigQuery, Snowflake or Databricks-style approach where teams standardize key metrics and dimensions to feed “cubes” from different applications. That improves self-service, but in practice the organization still behaves like departments with their very own data and views of the reality.

Level 3 is the primary real step toward modeling the business as an alternative of just reporting on it. Real-time events start flowing from operational systems into the info platform, and the info platform enriches those events in return. The entities and the events start reinforcing one another, and that’s where “context” becomes something you’ll be able to actually compute, not only describe.

Level 4 and Level 5 move into behavioral modeling and prediction. That is where products like Salesforce Data Cloud or SAP’s data cloud are headed – models of processes derived from their application footprints, with richer behavioral patterns and predictive signals. The essential nuance is these don’t must change into walled gardens. Consider them as value-add layers that sit on top of today’s data platforms and increase fidelity and actionability.

The north star is the digital twin – a real-time digital representation of the enterprise that captures people, places, things and activities/processes. That’s the prerequisite for layering a system of intelligence on top and expecting agents to do greater than automate small tasks.

Key takeaways

• Level 1 to Level 2 is reporting to self-service analytics – but still largely departmental;
• Level 3 adds real-time events and richer business modeling – entities and events enrich one another;
• Levels 4 and 5 introduce behavioral insight and prediction – as an overlay/value-add layer, not necessarily a walled garden;
• The tip state is a digital twin of the enterprise – the substrate required for a system of intelligence and outcome-level agents.

Bridging nondeterministic and deterministic: The missing step for agents

We now move to the handoff that has to occur if agents are going to take motion with confidence. The generative layer gives you creativity – for instance, tokens, language, synthesis, exploration. But enterprise motion requires determinism – the foundations, the guardrails and the auditable trail that claims what happened, why it happened and what the system should do (and is allowed to do) next. In our view, that is the core bridge between nondeterministic intelligence on top – deterministic execution underneath – tied together tightly enough that you would be able to trust the consequence.

The best approach to give it some thought is goals and guardrails. Agents have goals – what they’re trying to perform – and guardrails – what they need to do and the foundations they need to follow. These next stages are the deterministic layers that turn “smart” into “secure and operable” (below).

On this slide, the 4 stages take the maturity model from “analytics helping humans” to “systems coordinating work”:

• Level 6 – Enterprise knowledge graph: That is the connection map – what we sometimes confer with because the 4D map of the enterprise. The instance used here is financial services – a bond issuer, the bonds they’ve issued, and the investors who bought them. The purpose isn’t the bond example. The purpose is the enterprise needs first-class objects and relationships so agents can traverse reality, not spreadsheets.
• Level 7 – Semantic motion layer: That is where actions get modeled. Guardrails get richer since you move from “the world as relationships” to “the world as actions with constraints.” That is the step where the enterprise starts expressing what may be done – under what conditions – and what have to be true before and after an motion.
• Level 8 – Real-time digital twin: Levels 6 and seven are still overlays – they refer back to underlying analytical state and operational systems. Level 8 is where the model becomes the source of truth. That’s the purpose where the legacy systems start getting unplugged. The digital twin isn’t any longer a reporting layer – it’s the operational heartbeat.
• Level 9 – Autonomous operations platform: That is the far fringe of the model. Workflow logic itself gets stored as data, which suggests the system can learn, optimize and constantly improve. At that time the organization isn’t just running workflows – it’s refining and optimizing them.

One reason that is so essential in our view is it answers the “How do you get there?” query that kept coming up. Specifically, the feedback from Geoffrey Moore after we first laid out service-as-software in a serious way – the thought is compelling, but enterprises need specific steps to get from point A to point B. The last two slides – the five stages of information platform maturity and these 4 deterministic stages – are the work that fills in that bridge. It’s also why, candidly, this has been iterative. We thought the model was “done” in January – then it got deeper, since the deterministic layers are where the hard problems live.

The underside line: Agents don’t dramatically speed up value in silos. They compound value once they can navigate enterprise state, take actions under rules, and leave an audit trail. That is the bridge we see between generative output and governed execution.

The complete-stack digital twin: Turning rules into expertise

The slide below is the subsequent step past the deterministic layers. The underside stack – mapping plus rules – is the part that makes agents secure. It defines what’s allowed, what have to be true, and the way actions get executed without blowing up the business. But that only covers a slice of how corporations actually operate. The larger chunk is tacit knowledge – the stuff people call “tribal knowledge” – what experts do when the foundations conflict, when the info is incomplete, and when the situation is ambiguous.

That’s why the slide above separates the deterministic digital twin (the orange/gold “scaffolding”) from the cognitive digital twin (the blue “crystallization”). The deterministic layer is the governed backbone. The cognitive layer is how the organization captures the “why” behind decisions and learns over time.

The viral “context graph” chatter that hit the VC and vendor community late last 12 months was essentially about this problem. Context is what you reach for when deterministic logic breaks down. The logical workflow is:

• Agents run inside rules and mappings until they hit an exception;
• Exceptions go to humans – humans are within the loop;
• The system learns from the human’s reasoning traces – reinforcement learning turns those traces into improved performance over time;
• The system is penalized for flawed actions and rewarded for proper ones and that creates a flywheel effect where scaling laws kick in and outcomes may be operationalized.

The essential nuance is you’ll be able to’t cover the enterprise with deterministic rules alone. Within the view laid out above, the foundations are essential, but they’re not the entire game. Most of how an organization works lives in judgment calls, conflict resolution, prioritization and experience. That’s the 90% problem.

The “gold standard” example cited here is an organization called Mercor Inc. The concept is that even when the implementation is difficult, an authority teaches their considering process, teaches the right way to grade the reasoning process, and even teaches what flawed reasoning looks like. That “teach and grade” loop is the one reliable approach to capture the why behind expert judgment. Other approaches attempt to do it cheaper since it’s less onerous on the expert, but they lose fidelity.

An easy approach to explain the mechanics is punishment and reward: If the agent says one plus one equals three, it gets penalized; if it says one plus one equals two, it gets rewarded. Over time you get compounding behavior improvement. That’s the flywheel.

The important thing connection back to the sooner slide is that deterministic rules make tacit knowledge capture easier. When the foundations are explicit, you chop the surface area of ambiguity. Humans don’t have to clarify the whole lot, only the exceptions – and the system can learn faster since it knows exactly where the foundations stopped being sufficient.

That is relevant for Google since the agent platform conversation is starting to indicate more maturity. It’s still early, however the steps have gotten clearer – and the deep dives this week at Google Cloud Next 2026 reinforced that the trail forward isn’t just more capable models. That’s essential nevertheless it’s the mix of deterministic scaffolding plus a scientific approach to capture and refine expert judgment that represents state-of-the art today.

Bottom line: The deterministic twin makes agents secure. The cognitive twin makes them useful at scale. The compounding comes from tightly integrating the 2 together so exceptions change into training data and expertise turns into an asset.

Mapping Google’s data+AI announcements to the system of intelligence and system of agency

We imagine probably the most useful approach to decode Google’s data and AI announcements is to strip away the product names – “Knowledge Catalog” and “Agent Platform” – and map the underlying capabilities to the layers that we described earlier on this research. Google’s terminology is a bit of inverted relative to ours. Google tends to discuss “system of intelligence” as the fashionable data stack and “system of motion” as the brand new agent layer. Our view is different – the system of intelligence is the harmonization layer that makes motion secure and repeatable, and it’s what ultimately feeds the system of agency.

Understanding different language and mapping Google’s parlance to ours on the functional level helps to spotlight each progress and gaps.

System of intelligence: What Google has, and what’s still missing

Level 1 – Mapping layer (entities and lineage)
Google is doing real work extracting database management system technical metadata and lineage. Additionally it is pulling unstructured, document-oriented tacit knowledge right into a knowledge graph – and we acknowledge that’s advanced. The shortfall is unification. Google can extract entities, nevertheless it doesn’t yet unify those entities across systems right into a single, authoritative reference. “Customer” shows up in lots of places. Resolving “customer” across all those systems stays the hard part. Not less than that is our current understanding of where Google is at.

A practical approach to say this, as we said earlier, is that databases store strings – the knowledge graph desires to speak in things people understand. The move from strings to things – after which from things to activities and processes – is where the large value realization happens, and it’s also where the work gets hard.

Level 2 – Rules layer (from dimensional semantics to application semantics)
Google’s catalog captures data quality rules, BI metrics and business glossary content – dimensional semantics. That’s useful, nevertheless it stops wanting full application semantics – the business process rules which are entangled and entombed inside legacy application silos. That is the layer where Palantir Technologies Inc. often comes up as a reference point for our work – not since it covers the whole lot, but since it shows what “process rules as data” looks like whenever you go deep. We imagine Google desires to cover loads more ground than Palantir can cover at its pace and inside its constrained domain — but that doesn’t make the step any easier. Nor does it mean that Palantir, and its CEO Alex Karp, don’t have ambitions to broaden its scope.

Level 3 – Institutional memory (how vs. why)
Google has the substrate to capture agent reasoning and store it. The unified trace viewer (Trace Explorer inside Google Cloud Trace) is an actual step since it shows how an agent got to an consequence. That will not be the identical as capturing human expert reasoning – the why – which is what drives judgment and confidence. It’s a nuanced gap, nevertheless it’s the difference between replaying a path and learning a call system that may be trusted.

Level 4 – Decision guidance (context synthesis, confidence still thin)
Google can synthesize context and enable complex multi-retrieval. That enables an agent to retrieve more relevant material and make a judgment. The missing piece is confident, scored guidance from the system of intelligence itself – the flexibility to say “here’s what to do and here’s our confidence rating,” grounded in a library of human-grade “why” and in process-aware semantics. Without the “why,” the system can feel closer to static institutional memory than decision guidance.

System of agency: The training loop is the tell

On the system-of-agency side, the important thing requirement is the training loop – every layer needs feedback. Agents do work, get scored, get reinforced, and then you definitely speed up value. That is where Google’s agent evaluation and optimization work is vital.

• Agent evaluation is multi-turn scoring – evaluating the complete chain, not only a single request/response. That’s closer to how real work happens;
• Agent optimizer looks across clusters of failures and suggests refinements. That stood out since it’s the primary time this starts to feel like “agent ops,” not only agent demos. Databricks showed something similar last 12 months, and it left a mark since it turns failures right into a roadmap for improvement.

Why this mapping is relevant in the sector

We heard a consistent theme from customers in that there may be real excitement, nevertheless it’s still early for many of them whenever you push past Kurian’s keynote narrative – “up to now 12 months we didn’t just see adoption, we saw transformation.” Expert employees are being redeployed toward constructing, deploying and managing agents – that’s where numerous the near-term “productivity gain” goes. In other words, the productivity story is increasingly coming from the work of making agentic capability, not only consuming it. So in that sense Kurian’s proclamation holds water. But this continues to be an elusive reality for the overwhelming majority of enterprises.

This also explains why Palantir keeps coming up in these conversations. Palantir’s forward deployed engineers or FDEs effectively did this work for patrons – constructing the deterministic foundation (mapping plus rules/ontology) after which layering motion on top of it. That deterministic foundation is what makes motion secure. The open query is how quickly the broader market can construct that foundation with no need a military of specialists – and the way quickly Google can industrialize the “why,” not only the “how,” so agents can act with confidence.

Bottom line – Google is putting credible pieces on the chess board – for instance, lineage + metadata extraction, a graph-oriented approach to unstructured knowledge, multi-turn agent evaluation and failure clustering via optimizer. But gaps exist – unifying entities across systems, moving from dimensional semantics into real process semantics, and capturing the human “why” so decision guidance becomes confident, scored and repeatable.

This is figure that is still.

Coding agents because the onramp to universal agents and why Google’s platform push

The agent platform discussion has centered around coding. The market is converging on the increasingly obvious undeniable fact that to construct a universal knowledge-work agent, you begin with the coding agent, because the best way agents interact with the world is thru tools – and power use increasingly means writing code to call those tools. That’s why Anthropic leaned into coding first and why the coding stack is now the battleground across the frontier model vendors.

We see the competitive pressure showing up in lots of places. Anthropic’s Claude Code is gaining massive traction, OpenAI is pushing Codex, Grok has to have a reputable coding agent capability to be competitive as a frontier model, and Google is taking a distinct route by constructing an enterprise agent platform that tries to show the “harness” into something broader. The news around SpaceX Corp. owner Elon Musk having an choice to buy Cursor underscores the purpose: In the event you don’t have a first-class coding agent story, you fall behind quickly.

In the only terms, the progression on the slide above is:

• Start with a coding harness – get the coding agent right;
• Evolve toward an agent operating system/platform built on MCP – with proprietary extensions (memory, observability, developer controls);
• Expand into an enterprise agent platform – where governance, identity, memory and power/motion policy change into first-class.

Anthropic’s early advantage is that “coding first” path is the fastest way into general-purpose agent behavior. The harness gives developers a high-control environment – user interface/command-line interface, orchestration, tool use, context management – and it becomes the training ground for what later turns into broader knowledge-work agents. Their Conway work is the logical next step – an try to assemble a fuller platform on top of MCP, with proprietary extensions and enterprise features that transcend pure coding.

Google’s push is different. It’s attempting to construct the enterprise control plane for agents – and it has some things the frontier labs can’t easily deliver on their very own, at the least not yet, even when the frontier labs carve off pieces of the platform experience and live inside enterprise stacks.

Three practical differences stand out to us:

• Governance and agent identity – Identity was once “the agent acts because the user.” That’s insufficient when agents do work on their very own – and when agents act on behalf of other agents. The safety model has to evolve from purely resource-based controls (what data you’ll be able to touch) to intent-based controls (given this context, what motion is allowed). The enterprise needs policies which are enforceable at runtime, not only checked at login.
• Memory that doesn’t change into a brand new silo – If enterprises allow memory to get trapped inside a vendor’s proprietary stack, switching costs explode and the organization recreates silos – only now the silos are agent-shaped. The memory model needs to be shared, governed, and harmonized. Some personal preference can stay local, but procedural memory – how work gets done – needs to be accessible across agents and folks or coordination breaks down.
• Unifying the info and motion space – Tools and actions on one side, memory and data on the opposite – when those unify, the result becomes a semantically harmonized knowledge graph. We see this as the trail to an enterprise digital twin – a digital representation of the enterprise that agents can act on with confidence.

Net-net, we imagine the frontier labs are going to maintain pushing hard on coding agents since it is the fastest path to credible tool use. Google’s advantage comes from turning that into an enterprise-ready platform layer – governance, agent identity, intent-based policy and shared memory – so customers don’t find yourself with a brand new generation of silos and lock-in disguised as “agent progress.” Work stays for Google and others, however the direction is becoming clearer.

Google Cloud Next 2026: Pole position, recent battlegrounds and the OEM query

Google is betting the farm on an integrated stack – TPU, frontier model, data platform, agent platform and applications as one cohesive system. That’s Google’s differentiation. In our view, it’s directionally right, and it also pulls Google into recent territory where the winners can be decided by adoption, operating leverage and the flexibility to show “context” into “motion” without breaking security boundaries. We see Google as having a powerful technical story here, but its vision statement to businesses may very well be framed in additional “wallet” than technical terms.

This brings an interesting query for the likes of Snowflake and Databricks. Those two are climbing “up” from the read path – give me context from the info platform – after which stretching toward richer context. The query is: What happens once they’ve read and reasoned, and the way do they operationalize the choice the agent makes? That’s where motion becomes the differentiator, and it’s why coding capability matters a lot as the start line for agent maturity. If the agent can’t reliably execute, then all that context is just evaluation theater.

Google is moving in the precise direction – nevertheless it’s also crossing into the sector occupied by Palantir and Celonis SE, and even the mixing layer that vendors resembling Salesforce Inc.’s MuleSoft helped define. We see this because the hard part. Specifically harmonization across operational systems, data systems and workflows – with enterprise-grade governance. That is where we imagine our “system of intelligence” has to emerge as an actual product layer – regardless of what Google calls it.

A couple of takeaways from this:

• The integrated stack is Google’s edge – and the constraint. Google can bring more capabilities than most players. But once customers demand cross-app harmonization, the competitive options expand fast – Palantir, Celonis, Salesforce, ServiceNow Inc. and others all have designs on that layer. Google will partner with these firms but the subsequent bullet is vital.
• “Whither SaaS” hinges on OEM mechanics and trust boundaries. Frontier model players will partner with SaaS corporations – the open query is whose model becomes the popular original-equipment-manufacturer option. Gemini has a positioning advantage inside Google’s footprint. The problem is what happens when the SaaS OEM will not be running on Google Cloud. If the info has to go away the SaaS vendor’s security perimeter to make use of Gemini because Gemini runs in Google, that becomes some extent of friction – and we’ve seen how sensitive enterprises are to that boundary.
• Coding harness first – because motion is the brand new standard. The market is telling us that coding is the onramp to agent credibility – Claude Code and Codex have made that obvious. Google’s approach is to embed coding throughout the platform, not treat it as a separate product. We agree that’s a viable architecture – but the purpose is it needs to be fully integrated into the agent platform to be simplest. If the harness is adjoining slightly than native, it becomes a spot competitors can exploit.
• The ecosystem flywheel is shifting – and Google is benefiting. Amazon Web Services Inc. won the early cloud era by attracting startups and tech-centric organizations into an innovation flywheel. We see the same dynamic developing in AI – teams that need to be best at AI are gravitating toward Google, and that ecosystem migration is critical. Microsoft Corp. stays ubiquitous, and AWS will fight hard, however the AI-native cohort is an actual tailwind for Google.
• TPU capability is a strategic advantage – even when Nvidia stays the reference model. Google is certainly one of the few players with real depth in custom acceleration. That provides it leverage on supply and price. But we’d still expect serious customers to want Nvidia in the combination – since the ecosystem and the low-cost curve are still being set there. We’ll add a bonus slide to this topic next.

Bottom line: Google looks prefer it’s taking pole position within the agent platform conversation because it may possibly bring the complete stack and since its data platform has been doing the yeoman’s work for years. The work that is still is the hard part – turning “read context” into “take motion,” constructing the harmonization layer at enterprise scale, and solving the OEM/perimeter problem so Gemini may be consumed where the info lives, not only where Google runs.

TPU 8 and the ‘GPU-rich’ advantage

We open and shut on the identical topic: TPU. The last point is the one which changes the tone of the entire week – Google’s TPU capability gives it a structural advantage in AI compute, and it is going to show up in product velocity.

The Epoch AI chart on “H100 equivalent” capability below suggests Google has more AI compute than another cloud, driven largely by TPUs – a brute-force approach compared with Nvidia, but one which lets Google control its own destiny on supply and deployment.

This ties to an idea raised on the Latent Space podcast: “GPU-rich” vs. “GPU-poor.” Google looks “GPU-rich,” which helps explain why generative AI and agents are showing up broadly across its product line. Microsoft, against this, looks “GPU-poor” on this slide – which helps explain prioritization decisions (Office first), uneven rollout gen AI enablement across its Azure services, and the downstream pressure it has created elsewhere within the stack.

There’s a separate point that should be said: None of that is “TPUs are eroding Nvidia’s moat.” The demand for accelerated compute is so large that quality accelerators will sell, in a big part because Nvidia can’t satisfy all demand. Google will use TPUs primarily to power its own services – not as a merchant silicon vendor.

A couple of takeaways to anchor this evaluation:

• TPU capability should translate into feature velocity – Google can “put agents in all places” since it has the compute headroom to do it;
• Microsoft’s AI posture advantages materially from the OpenAI relationship and Nvidia allocation, however the tradeoffs show up in product prioritization and cloud services cadence;
• Amazon’s position looks different – Trainium (and the consolidation of Inferentia into that roadmap) is real, but Google appears to be separating with its annual cadence and platform consistency.
• Nvidia stays the quantity leader and CUDA stays the dominant development environment – the “bundle” strategy (CPU+GPU+networking+system-level architecture) raises the bar for everybody.

Net-net, we imagine Google’s TPU advantage is less about claiming an “Nvidia alternative” and more about enabling Google’s own stack to maneuver faster – especially on the software layer, where capability becomes the difference between selective enablement and pervasive agent rollout.

Motion items for CIOs, CTOs and AI architects

In the subsequent 30 to 60 days, run a structured “agent platform bake-off” with Google, AWS and Microsoft Azure in the combination. Force it into an artificial production workflow that crosses multiple systems (not a demo). Pick one high-value, end-to-end process, tie it to your actual data and policies, put Apache Iceberg in the combination and rating it on the things like security/auditability, semantic consistency across systems, time-to-value and the operational requirements to maintain it running.

Your goal must be to reply the next query with proof: Can Google’s integrated stack (data platform agent platform+control plane) change into the governed layer your agents run through, or does it remain a powerful set of parts that also requires an excessive amount of custom glue? If it clears that hurdle, we’d advise going deeper with Google; if it doesn’t, treat it as tactical capability. Regardless, for now, keep your control-plane strategy vendor-neutral until the business value clarity dramatically outweighs lock-in risk.

Image: theCUBE Research/ChatGPT

Disclaimer: All statements made regarding corporations or securities are strictly beliefs, points of view and opinions held by SiliconANGLE Media, Enterprise Technology Research, other guests on theCUBE and guest writers. Such statements are usually not recommendations by these individuals to purchase, sell or hold any security. The content presented doesn’t constitute investment advice and shouldn’t be used as the premise for any investment decision. You and only you might be accountable for your investment decisions.

Disclosure: Most of the corporations cited in Breaking Evaluation are sponsors of theCUBE and/or clients of theCUBE Research. None of those firms or other corporations have any editorial control over or advanced viewing of what’s published in Breaking Evaluation.