I've been building Pricing APIs for years.
And if you've ever built one — a real one, one that has to serve millions of customers, react to stock levels, competitor moves, time of day, demand surges, and promotional calendars — you know the dirty secret at the heart of most of them.
They're not really real-time.
They're very fast batch jobs wearing a real-time costume.
You precompute prices on a schedule. You cache aggressively. You serve stale data with enough confidence that most customers never notice. And you spend half your architectural energy managing the gap between "what the price should be right now" and "what the price actually says right now."
I've been sitting with that problem for a long time. Then Google Cloud NEXT '26 happened. And something clicked.
What Google Just Announced (And Why It's Not What You Think)
The big headline from NEXT '26 is the Gemini Enterprise Agent Platform — Google's full rebranding of Vertex AI into an end-to-end system for building, scaling, governing, and optimising autonomous AI agents.
Most people read that as an enterprise productivity story. Automate your emails. Summarise your meetings. Build a chatbot for HR.
I read it as an infrastructure story. Specifically, as the missing architectural layer that makes a genuinely real-time Pricing API actually buildable — without a team of 20 people and a multi-year runway.
Let me walk you through what I mean.
The Real Problem With Pricing APIs
Picture Black Friday. 9:00 AM.
Your traffic spikes 40x in 90 seconds. Your inventory for a flagship product drops from 10,000 units to 200 in the time it takes to read this sentence. A competitor just dropped their price by 15%. Three promotional campaigns are live simultaneously. Your demand forecasting model is screaming that stock will hit zero in 11 minutes.
What should the price be right now?
Not in 5 minutes when your next batch job runs. Not based on the snapshot from 3 minutes ago. Right now.
In most systems I've worked with, nobody actually knows. The system serves whatever it last computed and hopes for the best.
The problem isn't compute. It's orchestration. Getting five different signals — inventory, competitor pricing, demand velocity, promotional state, customer segment — to converge on a single decision, in milliseconds, at scale, without hard-coding every possible combination of conditions.
That's not a caching problem. That's a reasoning problem.
Where Gemini Enterprise Agent Platform Changes the Game
Here's what caught my attention at NEXT '26.
Google announced the Agentic Data Cloud — a new way of organising enterprise data so that AI agents can take action on it in real time. At the centre of it is something called the Knowledge Catalog: a live, AI-maintained map of your entire data estate, automatically tagged and connected so agents understand the context and relationships between your systems.
For a Pricing API, think about what that means.
Today, your pricing logic has to explicitly know about the relationship between your inventory system, your competitor feed, your promotions database, and your demand model. Someone had to write that understanding into code. Someone has to maintain it when things change. Every new data source is a sprint.
With a Knowledge Catalog backed by Gemini, your pricing agent doesn't need to be told "when inventory drops below 5%, check the demand velocity signal before adjusting price." It can reason over your connected data estate and arrive at that logic itself — and update its reasoning as your business changes, without a redeploy.
That's a fundamentally different model.
What a Gemini-Powered Pricing API Looks Like
Let me make this concrete. Here's how I'd architect a real-time pricing system on the Gemini Enterprise Agent Platform, using what was announced this week.
The Pricing Agent
Built on the Agent Development Kit (ADK), the Pricing Agent is a persistent, long-running agent that owns pricing decisions for a product catalogue. It's not a model you call once per request. It's a stateful entity with:
- Memory Bank (now GA): persistent context about each product's pricing history, demand patterns, and the reasoning behind previous decisions
- Agent Identity: a verified, auditable identity that allows the pricing agent to call authorised tools — pulling from your inventory system, your competitor feed, your ERP
- Multi-agent coordination: sub-agents for inventory monitoring, competitor scraping, and promotional eligibility can push updates to the pricing agent in real time, rather than waiting to be polled
The Real-Time Signal Layer
This is where the Agentic Data Cloud and the Cross-Cloud Lakehouse (built on Apache Iceberg) come in. Your data doesn't have to move. Your inventory lives in your warehouse system. Your competitor feed lives wherever it lives. The Knowledge Catalog maps the relationships, and the pricing agent queries across them with zero data migration.
On Black Friday at 9:00 AM, the inventory sub-agent fires an event: "Product X — 200 units remaining, sell-through rate 18 units/minute." That event hits the pricing agent's inbox. The agent has context (from Memory Bank) that this product has a 94% attachment rate with a premium customer segment. It checks the promotional state. It queries the competitor feed sub-agent. And it issues a price update within the decision window — not because a rule said so, but because it reasoned to that outcome.
The Governance Layer
This is the part that most AI architecture conversations skip. You cannot have an autonomous agent making live pricing decisions without an audit trail, human oversight triggers, and rollback capability.
The Gemini Enterprise Agent Platform has this built in. Agent Engine provides observability into every decision the agent makes — what signals it considered, what it decided, why. For regulated environments (and retail pricing absolutely counts), this auditability is non-negotiable.
You can also define confidence thresholds: if the pricing agent's recommendation falls outside a predefined band, it doesn't auto-apply — it routes to a human for approval. That's not a limitation. That's the right architecture.
The Part That Actually Surprised Me
I expected the agent platform announcement. I did not expect the managed MCP servers.
Google announced managed Model Context Protocol (MCP) servers across Google Cloud services. For those unfamiliar, MCP is the protocol that lets AI agents call external tools in a standardised way — think of it as USB-C for AI integrations.
What this means for a Pricing API is that your agent can call your authorised pricing tools — apply discount, update price, trigger campaign — through a governed, observable, rate-limited interface. No custom integration work. No bespoke API wrappers. Just a standard protocol your agent speaks natively.
Combined with the A2A (Agent-to-Agent) protocol also announced this week, your pricing agent can directly coordinate with a fulfilment agent, a customer service agent, and a demand forecasting agent — across platforms, not just within Google Cloud. That's the multi-agent mesh that enterprise systems have needed for a decade.
What I'd Build First
If I were starting a new Pricing API project tomorrow, here's where I'd begin on this stack:
Week 1–2: Knowledge Catalog setup
Map your pricing-relevant data — inventory, promotions, competitor feeds, customer segments — into the Knowledge Catalog. Let Gemini tag the relationships. Don't write the logic yourself. Observe what it surfaces.
Week 3–4: Single-product pilot agent
Build a pricing agent for one product category using ADK. Give it read access to your inventory and competitor signals via MCP tools. Run it in shadow mode — it makes recommendations, humans apply them. Compare to your current pricing outcomes.
Week 5–6: Governance baseline
Define your guardrails before you go live. Price floor/ceiling bounds. Confidence thresholds. Escalation paths. Audit log review cadence. This is the work that makes the business trust the system.
Month 2 onward: Expand and measure
Roll out to more categories. Track margin impact, stock turn rate, competitive win rate. The agent gets better as Memory Bank accumulates context. That's the flywheel.
The Honest Take
I'm genuinely excited about what Google announced this week. The Gemini Enterprise Agent Platform, the Agentic Data Cloud, managed MCP servers, A2A — these aren't incremental updates. They're the connective tissue that enterprise AI has been missing.
But I want to be honest about what this isn't, yet.
Building a production-grade pricing agent still requires you to own the domain logic. You have to define what "correct pricing" means for your business. You have to set the guardrails. You have to decide when the agent decides autonomously and when a human is in the loop. The platform gives you the infrastructure. The thinking is still yours.
And that's actually how it should be.
Pricing is a competitive moat. The businesses that will win with this technology are not the ones who hand the decisions entirely to an agent. They're the ones who use agents to act faster on better information — while keeping the strategic reasoning close to home.
That's always been the job of architecture. It's just got a lot more interesting.
Have you worked on real-time pricing systems? I'd love to hear how you're thinking about agents in this space — drop it in the comments.