Industry Leaders on Agentic AI: Perspectives from Google and Goldman Sachs

Why This Matters for Enterprise AI

The hard questions about agentic AI are not technical anymore. The patterns work, the frameworks ship, and the models can plan, call tools, and coordinate well enough to run real workflows. What no one hands you is the decision that governs the roadmap. Do you build the platform or buy it? Who is accountable when an autonomous system acts? And how do you prove any of it paid off?

Two people who answer those questions for a living offer a useful contrast. Saurabh Tiwary runs Cloud AI at Google as VP and General Manager, so he thinks about the infrastructure thousands of enterprises stand on to build agents. Marco Argenti is the Chief Information Officer at Goldman Sachs, so he has to deploy that same capability inside a heavily regulated institution without breaking it. One sells the shovels. The other has to dig in compliance-heavy ground, where a careless trench gets you fined.

This post is a synthesis. Nothing below is a direct quote. It is an interpretation of the public positions each leader has taken and the way Antonio Gulli frames their perspectives in Agentic Design Patterns. Read it as "here is how two serious operators seem to think about the same problem," not as a transcript. If you have followed the agentic design patterns series this far, this is where the patterns meet the people signing off on them.

The two views are not in tension. They are the two halves of the same decision. You cannot govern what you have not built, and you should not build what you cannot govern.

The Platform Question: Build, Buy, or Stand on Someone Else's Stack

Tiwary's vantage point is the infrastructure layer. From where he sits, the interesting work in enterprise agentic AI is not any single clever agent. It is the platform underneath: the thing that lets a company build a hundred agents that share data, call the same tools, and interoperate without a rewrite each time. Google's public direction reflects this. The bets are on managed agent platforms, a catalog of models and tools, and interoperability protocols. The goal of those protocols is simple: let agents built by different teams and vendors talk to each other rather than rot in silos.

Which Layer Do You Own?

That reframes the build-versus-buy question most teams get wrong. The real choice is rarely "build an agent" or "buy an agent." It is which layer you own.

• The model layer. Almost no enterprise should train its own frontier model. You rent it. This part is settled.
• The platform layer. Orchestration, tool registries, memory, evaluation, deployment. Here the decision is live. Buy a managed platform and you ship faster but inherit someone else's abstractions. Build it and you own your destiny and your on-call rotation.
• The agent layer. The actual logic encoding how your business reviews a contract or reconciles an account. This is yours. It is the part no vendor can sell you because it is your moat.

The mistake Tiwary's worldview implicitly warns against is treating an agent as a one-off. A team wires a single agent to a single tool, demos it, and calls it a strategy. Then the second use case arrives and shares nothing with the first. The lesson is to invest in the substrate instead.

Interoperability protocols matter for the same reason. The push to let agents from different frameworks coordinate exists because the future enterprise does not run one agent. It runs a fleet, and a fleet needs a road network. That is the logic behind multi-agent systems, where specialists coordinating beat one monolith trying to do everything.

Enterprise reality: A list of disconnected pilots is a graveyard of demos, not a platform. The companies pulling ahead decided early which layer they own, standardized the tool and memory plumbing once, and made the next agent cheap to build. The first agent is an experiment. The tenth agent is the test of whether you built anything reusable.

Governance and Risk: Agentic AI in Regulated Ground

Argenti's problem is the inverse. His question is not how to build agents fast. It is how to let an autonomous system act inside a bank without creating an unacceptable risk. In a firm like Goldman Sachs, the regulators and the firm itself both have to be able to stomach what the system does. His public posture is consistently measured, and that is the point. In regulated finance, "move fast and break things" stops being a culture and starts being an enforcement action.

The framing that travels well from his world is treating advanced AI less like a feature and more like onboarding a new class of worker. When a firm hires a junior analyst, it does not hand them production access on day one. There is supervision, a review process, scoped permissions, an audit trail, and a manager accountable for the output. The argument is that an agent capable of taking real actions deserves the same treatment. Not because the technology is scary, but because anything that acts on your behalf needs oversight proportional to what it can touch.

That reframing does a lot of work. It tells you the controls are not optional add-ons; they are the cost of giving the system any autonomy at all. Three move from nice-to-have to mandatory:

1. Scoped permissions. A digital worker gets access to what its job requires and nothing more, the same least-privilege principle you would apply to any new hire near sensitive systems.
2. Review and approval gates. High-stakes actions route through a human before they execute, not after. In regulated work, the human-in-the-loop checkpoint is the difference between a draft and a decision.
3. An audit trail. Every action is logged with its reasoning, so when someone asks "why did the system do that," the answer is retrievable rather than a shrug.

This is exactly the territory of AI guardrails and safety: the controls that decide what an agent is allowed to do, and what happens when it tries to step outside the lines. The measured posture is not timidity. It is the recognition that in a regulated industry, the constraint on deployment is rarely the model's capability. It is whether you can prove the system stayed inside its lane.

When to Move Fast, and When Not To

The two views resolve into a practical rule about pace. Match your speed to your blast radius.

• Fast where a mistake is cheap and reversible: internal research assistants, draft generation, summarization, anything a human reviews before it leaves the building.
• Slow where an action is consequential or hard to undo: anything touching money, customer commitments, regulated disclosures, or production systems.
• Slower still where you cannot yet explain the system's behavior. If you cannot audit why an agent did something, you are not ready to let it act unsupervised, no matter how good the demo looked.

Both leaders, read together, point at the same boundary. Tiwary's platform gives you the throttle. Argenti's governance tells you when to ease off it.

ROI and the Shift to Managing AI Workers

The third question is the one finance teams really ask: does this pay off, and how would we know? Here the "digital employee" framing earns its keep a second time, because it changes what you are measuring.

Measure an agent like software and you track uptime, latency, and request volume. Measure it like a worker and you track throughput, quality, and the cost of supervision. That last term is the one most ROI models miss. An agent is not free to run just because the API call is cheap. Someone has to review its output, handle its escalations, and own its mistakes. The honest calculation is the value the agent produces minus the human attention it still consumes.

The Work Shifts From Doing to Supervising

That reframes the organizational change too. The story that agents replace headcount is mostly wrong in the near term. What happens instead is a shift in the kind of work people do: fewer hours producing the first draft, more hours reviewing, correcting, and directing a system that produces it. The scarce skill stops being "doing the task." It becomes supervising a non-human worker that does the task at volume, catching the failure modes a human would never make but a model will.

Enterprise reality: The teams seeing return did not deploy the most agents. They redesigned a workflow around an agent and then measured the whole loop, review time included. An agent that drafts 100 contracts an hour but needs a lawyer to check every one has relocated the work, not saved it. The win arrives when the agent is reliable enough, and the guardrails tight enough, that human review shrinks to spot-checks. That reliability is an engineering investment in evaluation, monitoring, and the unglamorous infrastructure that makes autonomy trustworthy, which is exactly the substrate the platform view was arguing for.

So the two perspectives close the loop on each other. Tiwary's platform makes the tenth agent cheap to build. Argenti's governance makes it safe to trust. And the ROI shows up only when both are true at once — when building another agent is cheap and supervising it is light. One without the other is either a pile of ungoverned demos or a single agent so wrapped in review that it never pays for itself.

Key Takeaways

• The build-versus-buy question is really "which layer do you own." Rent the model, decide deliberately on the platform, and build the agent logic that encodes your business. That last layer is the part no vendor can sell you.
• A pile of disconnected pilots is not a platform. The companies pulling ahead standardized the tool, memory, and evaluation plumbing once, so the next agent is cheap to build and able to interoperate with the rest of the fleet.
• In regulated industries, the constraint on deployment is governance, not capability. Treating an agent like a new "digital employee," with scoped permissions, review gates, and an audit trail, turns the controls from optional add-ons into the price of any autonomy.
• Match your pace to your blast radius. Move fast where mistakes are cheap and reversible; move slowly where actions touch money, customers, or anything you cannot yet explain.
• ROI is the value an agent produces minus the human attention it still consumes. The win is not deploying the most agents. It is making one reliable enough that supervision shrinks to spot-checks.
• The platform view and the governance view are two halves of one decision: you cannot trust what you cannot govern, and you cannot scale what you have to govern by hand.