Forem: Ruvimbo Delia Hakata

From HTTPS to UCP: Shopping Is About to Stop Being Your Problem

Ruvimbo Delia Hakata — Mon, 25 May 2026 06:16:30 +0000

The narrative of digital transformation in retail has been remarkably consistent. First, get online. Then build an app. Then optimize checkout. Add loyalty points, push notifications, maybe a chatbot.

For years, this was the right strategy. It moved retail from physical-only to omnichannel, giving customers access, convenience, and choice.

But something fundamental shifted at Google I/O 2026.

The conversation is no longer about getting customers to your storefront—digital or physical. The question retailers must now answer is: When your customer's agent comes shopping, will your business be ready?

This is the move from HTTP/HTTPS (where humans browse sites) to the Universal Commerce Protocol (UCP) (where agents act across platforms). It redefines not just the technology of retail, but the entire relationship between businesses, customers, and shopping itself.

The Technology: Where HTTPS Met Its Match

To understand what's happening, it helps to think about HTTP's role in web history. HTTP standardized how browsers and servers communicate, unlocking the web as we know it. Similarly, UCP is designed to standardize how agents—autonomous systems acting on behalf of customers—can understand and transact across different retailers, payment systems, inventory platforms, and fulfillment networks.

But UCP isn't just a protocol upgrade. It's accompanied by three critical technical announcements that fundamentally change what's possible:

1. Gemini Spark and Proactive Agent Commerce

Spark is a browser-based agent that doesn't wait for you to ask. It reads your calendar, understands your commitments, and anticipates your needs. This is where shopping transforms from a task you remember into a background process that simply happens.

For someone like me—juggling data science work, team leadership, community projects, and a dozen other commitments—Spark represents a genuine return of time. When I see on my calendar that I'm on "snack duty" for a weekend game, the agent can:

Understand the context (when, where, how many people)
Recall my constraints (dietary preferences, budget ranges, previous choices)
Proactively set up an Instacart order
Remember to exclude nuts because someone in the group has allergies
Present the order for approval before checkout

This isn't a recommendation. This is delegation.

2. Agent Payments Protocol (AP2) and Trust Through Guardrails

With great delegation comes the need for security. AP2 allows customers to set strict, tamper-proof guardrails that agents must follow:

Spending caps per transaction
Brand whitelists and blacklists
Category restrictions
Approval thresholds

Every transaction creates a cryptographically secure digital paper trail. The customer maintains full accountability and can revoke agent access instantly.

This solves what traditional fintech couldn't: How do you let an autonomous system handle money on your behalf while maintaining control?

3. Gemini Nano and Offline-First Shopping

The final piece is perhaps the most underrated: Gemini Nano 4, an on-device model powerful enough to run complex reasoning entirely locally—in airplane mode, with no internet connection.

This matters because shopping doesn't always happen online. Sometimes you're in a mall with spotty WiFi, trying to make style decisions for formal wear, and you need product information, sizing guides, or virtual try-on capabilities without relying on the network.

With Nano, a custom retail app can:

Store product catalogues locally
Run visual recognition for style matching
Provide detailed product comparisons
Offer sizing guidance
Create virtual try-ons

All without a data connection. The technology disappears, and you get back to what actually matters: the decision.

Why This Matters Personally (And Why It's Bigger Than Me)

For years, I've approached shopping the same way I approach most of life: pragmatically. I don't have time for multiple apps, price comparisons, or decision paralysis. I have outcomes I need.

The problem is that retail was built assuming everyone wants to browse, compare, and feel in control of the process. But that's not universal. People shop differently based on their constraints.

For the time-poor (me): The best shopping experience isn't browsing. It's delegation. Spark handles the thinking; I handle the approval.

For the efficiency-focused: It's not about the most beautiful app. It's about an agent that understands your priorities—best deals, minimal time, trusted brands—and orchestrates the entire journey. Tools like Antigravity 2.0, Google's agent-first development platform, allow retailers to build custom agents that act as mission control. These agents can map optimal routes across stores, identify real-time deals, research product quality, and even execute purchases under strict conditions using AP2. For someone who refuses to waste time but won't sacrifice value, this is transformative.

For the expert shoppers (like my cousin with formal wear): It's about augmentation. Having an on-device assistant that knows her style preferences, past purchases, and body measurements while she's physically shopping—even offline—amplifies her decision-making without replacing it.

The retail insight here is stark: Customers aren't losing interest in shopping. They're losing patience for friction. They're not abandoning carts because the prices are too high; they're abandoning because the decision-making burden is too heavy, the process too fragmented, the experience too disconnected from how they actually live.

The Business Case: Capturing the Opportunity Cost

Most retailers think about lost sales in terms of price, stock, marketing budget, or abandoned carts.

But there's another category that deserves attention: sales lost because shopping didn't fit into the customer's life.

A customer doesn't buy because they're busy. Another delays because they're overwhelmed by options. Another avoids the store because the trip feels exhausting. Another abandons the cart because comparing offers is too much work.

This is opportunity cost—and it's enormous.

Agentic retail has the potential to recover this by helping customers shop around their actual constraints, not just their preferences.

The business question shifts from: "What does this customer want?"

To: "What is making this purchase harder than it needs to be?"

Why Retailers Need to Get Agent-Ready Now

Here's where the strategic opportunity lies for retailers, especially those looking to compete globally.

UCP is open-source and protocol-based, which means it's not controlled by any single platform. But adoption requires retailers to think beyond their website or app. The backend systems—product data, inventory accuracy, pricing consistency, return policies, loyalty rules, payment flows—must be reliable enough for agents to understand and trust.

A traditional digital transformation question: "How do we get customers to our website or app?"

An agentic commerce question: "Are our systems clean, accurate, and trustworthy enough for an autonomous agent to recommend us?"

This sounds subtle, but it's profound. A beautiful website helps humans decide. Clean, consistent, machine-readable data helps agents recommend you.

The Universal Cart, which works across Search, YouTube, and Gmail, is an example of this in action. It can even apply intelligent reasoning—flagging when a processor selected in one cart isn't compatible with a motherboard in another, catching errors before purchase.

For retailers, this means:

Invest in data infrastructure. Product catalogues, stock positions, pricing feeds, and policy documentation must be accurate and machine-readable.
Think about agent-first UX. Not every customer needs a beautiful storefront anymore; some need to be easily found and trusted by an agent.
Build for transparency. Agents will explain why they recommended your product over a competitor's. Can your systems support that narrative?

The Intelligence Question—And Why It Matters for Trust

Here's where this gets complex.

Traditional retail systems mostly see what you bought. An agentic system understands what you intended to buy, what you compared, what you rejected, what mattered most, and what constraint shaped the final decision.

That intelligence is valuable. It could improve demand planning, reduce waste, enable better promotions, and help retailers understand market behavior with real nuance.

But it also raises uncomfortable questions:

Who owns intent data? If an agent learns that you're willing to spend more on sustainable products, or that you're price-sensitive, who controls that insight?
What does real consent look like? A checkbox saying "I agree to share shopping data" isn't consent; it's legal cover.
Can you see what your agent shared? Transparency has to flow both ways.
Can you revoke access? Consent must be revocable, not permanent.
Why was this recommended over that? The agent's reasoning should be explainable.

This isn't just a technical problem to solve; it's a governance conversation.

The retailers who build agentic commerce responsibly—with transparent data handling, genuine consent, and customer control—will win trust. Those who treat it as an opportunity to extract data quietly in the background will eventually face backlash.

The strongest competitive advantage in agentic retail won't come from having the best algorithms. It will come from being the brand customers trust their agents with.

What Comes Next

The shift from HTTP to UCP represents more than a technology transition. It's a redefinition of what retail is for.

Shopping in the age of agents isn't about having more options. It's about removing the friction that keeps people from getting what they need.

For me, that means delegating the thinking.
For others, it means efficiency.
For some, it means confidence in a decision.

The retailer—and the technology platform—that understands this will thrive.

But understanding it means asking better questions:

What's making this purchase harder than it needs to be?
Are our systems ready for agents to trust us?
Are we building this responsibly?

These are the questions that will separate retail leaders from everyone else in the agentic era.

The question is no longer: "Does your retail business have an app?"

The question is: When your customer's agent comes shopping, will your business be ready?

And more importantly: Will your customer trust you with their agent?

This is a submission for the Google I/O Writing Challenge

Cooking an AI Campaign in 5 Minutes with Google Cloud AI APIs

Ruvimbo Delia Hakata — Sat, 23 May 2026 13:41:45 +0000

About a month or so ago, during the Build with AI season, Google Developer Groups Johannesburg in South Africa hosted a build-a-thon with a concept I genuinely loved.

The whole concept was structured like a kitchen lab, with a key focus on local small businesses . Small to medium sized businesses dominate Southern Africa, so when I first read and saw the post i could instantly relate.

I loved the idea of turning code into usable business tools and a buildathon where we could be cooking up ideas together.

Different ingredients. Different flavours. Different tools. Immense impact!

I was excited to share the tutorial before the buildathon, but life and timing happened. So instead of letting the project sit in a notebook, I decided to turn it into an article anyone can follow, as they experiment with AI-powered marketing workflows.

But before we get technical, let me explain why I chose to build a multilingual marketing pipeline using Google Cloud AI tools.

There is a bigger vision here. This isn't just about generating automated ads. It’s about creating systems where entrepreneurs can describe what they sell, define their audience, click a few buttons, and instantly receive dynamic, multilingual marketing assets they can actually use for one of the biggest advertising platforms, Radio, hence the audio content in local languages.

This project is simply the appetizer, a baseline and starting point for builders.

If AI can help market sneakers in multiple South African languages, what stops a small business from doing the same for lipstick, skincare, jewellery, furniture, or handmade products?

The Recipe: One Prompt, Multilingual Radio Copy

Colab Notebook Link: https://colab.research.google.com/gist/DeliaRudy/7e989ab921036166acdc43289022941a/business_story_telling.ipynb

The lab focuses on a simple workflow:

A user describes their product or campaign idea.
Gemini refines the marketing message.
Google Text-to-Speech converts it into audio.
Translation tools localise the campaign into multiple languages.
Additional models extend multilingual support even further.

Instead of creating separate campaigns manually, the system helps generate a full multilingual experience from a single idea.

And honestly, this is where things became exciting for me.

Because many SMEs struggle with one major thing:

Creating consistent marketing content repeatedly.

Not because they lack creativity.

But because content creation takes time, resources, voiceovers, editing, localisation, and strategy.

AI changes that workflow dramatically without hurting their bottomline.

Step 1: The Prep Work (Gemini as the Brain)

Every campaign starts with an idea. We start by taking a simple user input (e.g., "Takkies Ad for tech girlies with puns on tech") and passing it to Gemini on Vertex AI to act as our creative partner.

We use gemini-2.5-flash to structure this raw idea into a professional 15-second radio script.

import vertexai
from vertexai.generative_models import GenerativeModel

# Initialize Vertex AI (assume PROJECT_ID and LOCATION are set)
vertexai.init(project=PROJECT_ID, location=LOCATION)

model = GenerativeModel("gemini-2.5-flash")

Step 2: The Flavor Profile (Translation with Context)

For radio advertisemnets, language matters deeply. People connect differently when they hear something in a language that feels familiar to them. For this lab, we focused on English, Afrikaans, isiZulu, and isiXhosa.

You can use the standard Cloud Translation API for bulk text or use an LLM like Gemini. The notebook highlights these as option A and B. In my opinion using Gemini allows for more context-aware, creative translations that preserve the "vibe and energy" of the ad.

# @title Translation using the Cloud Translation API - Option A

from google.cloud import translate_v2 as translate

translate_client = translate.Client()
languages = {
    'af': 'Afrikaans',
    'zu': 'Zulu',
    'xh': 'Xhosa'
}

llm_translations = {}

for lang_code, lang_name in languages.items():
    prompt = f"Translate the following marketing script into {lang_name}. Keep the tone professional yet catchy for a South African audience: {english_script}"

    response = model.generate_content(prompt)
    llm_translations[lang_code] = response.text

    print(f"--- {lang_name} (Gemini) ---")
    print(response.text)

   # @title Translation using Gemini (Vertex AI) - Option B

llm_translations = {}
for lang_code, lang_name in languages.items():
    prompt = f"Translate the following marketing script into {lang_name}. Keep the tone professional yet catchy for a South African audience: '{english_script}' output should be just plain text"
    response = model.generate_content(prompt)
    llm_translations[lang_code] = response.text
    print(f"--- {lang_name} (Gemini) ---")
    print(response.text)
    print()

Step 3: The Presentation (Text-to-Speech)

Now we need to plate the dish. We use the Google Cloud Text-to-Speech API to convert our generated scripts into high-quality, natural-sounding audio files.

Here is how you generate the Afrikaans version. You can wrap this in a function to loop through your translated scripts, swapping out the language_code and name (e.g., using af-ZA-Standard-A for Afrikaans).

from google.cloud import texttospeech

def synthesize_text(text, language_code, voice_name, output_filename):
    client = texttospeech.TextToSpeechClient()
    synthesis_input = texttospeech.SynthesisInput(text=text)

    # Select the voice parameters
    voice = texttospeech.VoiceSelectionParams(
        language_code=language_code,
        name=voice_name
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3
    )

    # Generate the audio
    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    with open(output_filename, "wb") as out:
        out.write(response.audio_content)
    print(f"Audio content written to file '{output_filename}'")

# @title Synthesizing Afrikaans Audio
# Using the standard Cloud TTS API for Afrikaans
synthesize_text(llm_translations['af'], "af-ZA", "af-ZA-Standard-A", "ad_afrikaans.mp3")

Going Beyond the Basics: Vertex AI Model Garden

Whilst working on completing the lab, I ran into an interesting architectural challenge. While the standard TTS API is constantly expanding, it doesn't currently offer a native voice for Xhosa (xh-ZA) and Zulu (zu-ZA). Think of a radio advert in South Africa excluding these two languages, would it fare well in Kwazulu Natal or part of the Eastern Cape?

This is where Vertex AI’s Model Garden shines, going beyond calling the gemini models and looking for open models that support text-to-speech.

Did you know: You can deploy specialized open-source models (like SeamlessM4T, which supports over 100 languages including Zulu and Xhosa) directly to an endpoint and route your specific language requests there.

What Comes Next?

Right now, this pipeline demonstrates the mechanics: prompting, refining scripts, translating content with context, and generating multilingual voiceovers.

The goal of sharing this isn't to replace human creativity. It’s to show how easily developers can reduce the barriers that stop small businesses from showing up consistently online. Sometimes innovation doesn’t start with massive enterprise infrastructure—sometimes it starts with a build-a-thon, a simple Python script, and a community willing to experiment together in the kitchen.

Share your feedback in the comments/questions. I would love to hear what you think of this lab.

Prototyping Real-time Social Sentiment with Python

Ruvimbo Delia Hakata — Sat, 11 Oct 2025 21:50:54 +0000

I recently spoke at PyCon Africa 2025 about "Prototyping Custom AI Enterprise Solutions." My talk was all about helping businesses understand what people are saying about them online, in real-time, using AI. It's a big problem because there's so much social media data, and most old-school tools can't keep up. This often leaves companies reacting to problems instead of being ready for them.

The Problem: The "Enterprise Gap" in Social Data

Imagine a brand manager needing to know, right now, the sentiment around a new product launch or an influencer campaign. The sheer volume and velocity of social data (think millions of tweets, comments, reviews) make manual classification impossible. Worse, traditional rule-based systems often lack the nuance to accurately interpret human language, especially across different contexts or regional dialects. This creates a critical "enterprise gap" where valuable insights are lost, leading to reactive decision-making and missed opportunities.

Our "Ticket": An AI-Powered Sentiment Monitor

To address this, we defined a prototype with the following technical requirements (a simplified "ticket" for our internal dev team):
Feature: Real-time Social Media Sentiment Analysis
Input: Stream of raw social media posts (e.g., from Twitter, Reddit, etc.)
Output: Classified sentiment (Positive, Neutral, Negative) per post.
Aggregates: Daily sentiment breakdown charts, themed WordClouds, and PDF summaries.
Key Challenge: Must be able to handle diverse language, slang, and evolving social media discourse efficiently.

Why Prototyping is Key for Enterprise AI

Python, with its rich ecosystem, was the obvious choice for rapid prototyping.This isn't just about building a throwaway model. Rapid prototyping in Python allows us to:

Validate hypotheses quickly: Does this approach actually deliver value for the brand team?
Iterate fast: Get feedback from stakeholders and pivot without heavy refactoring.
Demonstrate ROI: Show tangible results to secure buy-in for full-scale production.

Resources & Further Exploration:
GitHub Repo: https://github.com/DeliaRudy/Brand-Sentiment-Monitor] (Feel free to fork, experiment, and provide feedback!)

I'm keen to hear your thoughts. What frameworks or models have you found most effective for sentiment analysis in real-world scenarios? What challenges have you faced with scaling similar solutions?

Building GenAI Apps in Java

Ruvimbo Delia Hakata — Mon, 22 Sep 2025 04:38:28 +0000

This article is a summation of the lessons from my demo/talk titled: Building Production-Ready GenAI Apps in Java with Vertex AI.When I was prepared to deliver this session online session earlier, I had one clear goal: to move past the hype. Too often, conversations about generative AI get stuck at “look what this model can do.” I wanted to take it further to show how we can actually deliver business-ready applications that solve real problems inside organizations.

Why Java?

For this demo, I went with Java. I know it might raise eyebrows since Python dominates most AI conversations. But here’s the thing: across enterprise environments, especially in Africa, Java is still the backbone.

It powers banks, mobile apps, and core business systems. Python is great for rapid experiments, but when it comes to scalability, integration, and long-term maintainability, Java quietly does the heavy lifting.

By choosing Java, I wanted to make a point: if AI is going to bring real business value, it needs to live where the business already lives.

The Business Problem I Framed

I anchored the demo in a gaming scenario. Picture this: a mobile game with thousands of active players. The company is swimming in data demographics, session times, devices, revenue per user. But raw data doesn’t drive growth.

The marketing team doesn’t want CSVs. They want to know how to reach their players.

So, I built a persona generator:

Data ingestion: demographics + behavior from GA4 API
Context enrichment: a RAG pipeline that blends analytics with internal data (support tickets, logs)
Persona creation: Vertex AI generating customer personas linked to business goals

The output? Not just charts but stories, pain points, and strategies. That’s the jump from numbers to business clarity.

The Toolchain

The stack was simple but effective:

GA4 API →customer behavior data
Java service layer → prompt orchestration
Vertex AI (Gemini models) → persona generation
Cloud Run → deployment with one command

A few things I had to emphasize in the session:

Data quality drives output quality. I had a value a big “97%” bold on a slide for this reason.
Prompts = business logic. Phrase them wrong, and you’ll get fluff. Phrase them right, and you’ll get insights.
AI without responsibility is reckless. Deploying without safety, governance, and monitoring is like shipping code without testing.

Practical Guidance

If you want to try something similar: start with a real business problem. My demo solved customer personas generation deadlocks, but the same setup could power sentiment tracking for PR, financial event assistants, or multilingual copy for marketing.

The Takeaway

Generative AI is not a lab experiment anymore. It’s becoming embedded in business processes—funding is flowing, adoption is increasing, and teams using it daily are experiencing productivity boosts.

Production-ready AI isn’t about the model. It’s about pipelines, integration, and responsibility. That’s what separates flashy demos from real business impact.

The companies that win with AI won’t just use it—they’ll integrate it.