Tuesday, July 28, 2026

The HTTP of AI Shopping: Inside UCP, MCP, and the Open Protocol Stack

In a nutshell (TL;DR)...

This document explores the shift toward "Agentic Commerce," where AI agents independently execute shopping tasks. This ecosystem is powered by three key open protocols: MCP for live data access, UCP for transaction management (carts, identity, and payments), and A2A for dynamic negotiations between software agents. These open standards are vital for a friction-free, competitive future in retail.

In a previous post I talked about the rise of Agentic Commerce and how it will transform the way we shop online. I asked you to imagine asking your Personal AI Assistant: "Find me a waterproof hiking jacket in olive green under $200, apply my store rewards, and ship it to my apartment by Friday."

Five years ago, that prompt would yield a list of web links. Today, the AI Agent doesn't just find the jacket, it checks real-time inventory, verifies your loyalty tier, negotiates dynamic discounts, and executes the purchase without you ever loading a checkout page.

I’ve also delved into the magic sauce that makes this happen but let’s try and bring together the main components into one post and try to understand what is at play. It is an underlying stack of open protocols, a collection of open-source technical standards forming what experts are calling the "HTTP of Agentic Commerce".

If you want to understand how software will trade billions of dollars over the next decade, you need to understand the protocols making it happen: MCP, UCP, and A2A.

1. The Context Layer: Model Context Protocol (MCP)

Before an AI agent can buy anything, it needs access to real-time information. Language models are inherently isolated; they don't natively know if a store has 3 items left in stock or if a price dropped five minutes ago.

Enter Model Context Protocol (MCP), open-sourced by Anthropic.

MCP acts as a universal adapter between AI models and external data tools. Think of it as USB-C for AI: instead of developers writing custom API connectors for every single product database, store backend, or CRM, MCP provides a standardized format for agents to query live data.

What MCP Handles in E-Commerce:

Live Inventory Checks: Quoting real-time stock counts across multiple warehouse locations.
Spec Parsing: Extracting structured technical specifications (e.g., precise dimensions, fabric weight, voltage) from unstructured databases.
Contextual Inputs: Feeding user preferences, sizing profiles, and past purchase histories securely to the AI model.

2. The Commerce Layer: Universal Commerce Protocol (UCP)

While MCP provides data context, it isn't built to orchestrate end-to-end retail transactions. Querying an API for stock is easy; creating a multi-item cart, applying promotional codes, initiating identity verification, and managing payments requires a formal commerce standard.

To solve this, Google teamed up with retail and infrastructure giants—including Shopify, Etsy, Target, Walmart, Visa, and Stripe—to release the Universal Commerce Protocol (UCP).

UCP defines an open-source communication specification for e-commerce operations. It doesn't replace existing merchant platforms like Shopify or WooCommerce; it gives AI agents a set of standard functional primitives to talk directly to them.

Core UCP Primitives:

Catalog & Discovery: Exposing structured, real-time product catalogs directly to AI crawlers.
Cart Management: Enabling agents to create, modify, and calculate sub-totals for multi-item carts programmatically.
Identity & Loyalty Linking: Recognizing that "John Doe" is a Gold Tier member at a store, applying member pricing automatically without forcing a manual login on a website.
Checkout & Orchestration: Tokenizing payments and completing transactions securely while keeping the merchant as the official Merchant of Record.

3. The Negotiation Layer: Agent-to-Agent Protocol (A2A)

The ultimate evolution of agentic commerce isn't just a buyer bot interacting with a static website backend—it's software negotiating with software.

Agent-to-Agent (A2A) protocols establish rules for buyer agents (representing consumers) and seller agents (representing brands) to interact dynamically.

How A2A Dynamics Work in Practice:

Dynamic Bundling: A buyer agent requests a camera, lens, and tripod. The brand's seller agent calculates real-time margins and responds: "If you buy all three together, I can offer an instant $45 bundle discount."
Inventory Clearing: A merchant's AI agent notices excess seasonal inventory and dynamically grants targeted discounts to consumer agents searching for deals in that specific category.
Automated Terms Negotiation: Negotiating bulk order delivery timelines or return window extensions for enterprise purchases.

The Big Shift: Why Open Protocols Win

Why does this open architectural stack matter so much? Because walled gardens create friction, and friction kills conversion.

If every AI assistant required a proprietary integration to buy from every merchant, only massive platforms (like Amazon) would survive. Open standards like UCP, MCP, and A2A democratize the landscape. They allow a boutique clothing store running on a standard e-commerce platform to sell to a consumer using ChatGPT, Gemini, or a standalone personal AI assistant seamlessly.

The web was built on open transport protocols like HTTP and HTML. The era of agentic commerce is being built on data, transaction, and negotiation protocols. Brands that adopt these standards early won't just keep up, they will be the first ones discovered when software starts doing the shopping.

Tuesday, July 21, 2026

The "Anti-AI" Prompt: How to Force AI to Write Content That Actually Sounds Human

In a nutshell (TL;DR)...

Audiences are exhausted by generic, AI-generated text filled with corporate fluff and predictable clichés. To create a standout blog post, stop using vague tone adjectives like "friendly yet professional." Instead, use advanced prompting techniques—like stylistic constraints, linguistic profiling, and strict word bans—to force the AI to write with the variance, grit, and authenticity of a human author.

I have this feeling that we are entering into a new phase of "AI Fatigue"...

I wanted to find out if the concept of “prompt writing” or “prompt engineering” has changed somewhat since I started this blog in January 2026. I’ve read so many emails, posts and articles that I can start to see the signs of AI generated content by the first two sentences. I mean, it’s no secret that parts of my blog posts are generated by AI, but I do re-write huge swathes of it, either to make it more readable and it also helps me understand the research I’ve done too.

AI generated content tends to be grammatically perfect (with lots of inexplicable em dashes), flawlessly structured, but feels entirely devoid of life. It’s full of cliches like "delving deep," things being a "testament to innovation," and reminders that we live in a "fast-paced digital landscape."

When every brand uses the exact same base models to generate content, the entire internet starts to sound like a mid-level corporate PR brochure.

If you want your blog to stand out, you have to actively break the AI's default habits. The secret isn't giving up on AI; it's changing how you prompt it.

The Problem with Vague Adjectives

When most people want a blog post to sound better, they stuff their prompt with descriptive adjectives:

"Write a fun, engaging, professional, but casual blog post about e-commerce trends."

To a Large Language Model (LLM), this is contradictory noise. The AI averages out those words and reverts to its safest, most sterilized default settings. Human writers don't write by thinking about adjectives. They have their own unique pacing, specific way of saying things, and stylistic nuances that make them, them. To get human-like output, you have to give the AI concrete operational rules, not feelings.

3 Tangible Techniques for the "Anti-AI" Prompt

Here’s a handful of thoughts to inject into your prompting routine that can possibly help strip away that robotic veneer:

1. Program "Burstiness" (Sentence Variance)

Unless you’ve not noticed, AI text is incredibly uniform. It loves to write sentences that are all roughly the same length, creating a rhythmic monotony that puts readers to sleep. Humans write erratically. We follow a long, complex thought with a short one. Like this. Sometimes those sentences are also incredibly long. You’ll notice this blog. Doesn’t have very long. Sentences.

You can explicitly program this behavior into your prompts.

The Prompt Directive:"Vary your sentence structure using high burstiness. Alternate between long, explanatory sentences that build context and short, punchy sentences (under 5 words) that deliver impact. Avoid uniform paragraph lengths."

2. Implement a Strict Cliché Ban

AI models are trained on patterns, which means they default to the most common phrases on the internet. By creating a digital "swear jar" for overused AI tropes, you force the model to find more creative, authentic ways to express an idea.

The Prompt Directive:"You are strictly prohibited from using the following words and phrases: 'In today's fast-paced world', 'delve', 'testament to', 'game-changer', 'revolutionize', 'tapestry', 'beacon', or 'in conclusion'. If you feel tempted to use these, rephrase the concept using simple, direct language."

3. Use Linguistic Profiling (The "Mirror" Technique)

The absolute best way to make an AI sound like a human is to give it a specific human to copy. Instead of asking it to guess what "casual" means, feed it a sample of your own writing—or text from an author you admire—and ask it to reverse-engineer the mechanics.

The Prompt Directive:"Analyze the text sample below for its linguistic profile. Pay attention to vocabulary level, use of active vs. passive voice, how technical concepts are simplified, and the frequency of personal pronouns (I, we, you). Once analyzed, rewrite the draft below matching this exact linguistic profile."

Putting It Together: The Master Framework

The next time you sit down to draft a piece of content, bypass the basic text box and feed the AI a highly structured role.

Here is a comprehensive framework you can copy and paste:

Role: You are an elite developmental editor and ghostwriter known for a minimalist, direct, and engaging writing style.

Task: Rewrite the provided outline into a comprehensive blog post section.

Constraints:

Tone: Grounded, practical, and candid. Speak like a helpful peer, not a rigid lecturer.
Voice: Use active voice exclusively. Use personal pronouns (you, we) to connect with the reader.
Pacing: Mix complex thoughts with sharp, sudden conclusions. Keep paragraphs to a maximum of three sentences.
Formatting: Optimize heavily for scannability. Use bolding on key phrases to guide the reader’s eye, and break up dense data using simple bullet points or markdown tables where appropriate.

[Insert your raw notes/outline here]

By shifting your focus from what the AI writes to how it structures its thoughts, you transition from generating generic text blocks to crafting genuinely compelling narratives. The tool hasn't changed—but your boundaries have.

Wednesday, July 15, 2026

The Great AI Memory Bank: How Your Data Gets Consumed (and How to Keep It Private)

In a nutshell (TL;DR)

To secure your data, consider these strategies:
Anonymization Pipelines: Replace sensitive identifiers with placeholders (e.g., [NAME]) before data leaves your network.
Zero Data Retention (ZDR): Mandate that providers process prompts in memory only, without saving logs or using data for training.
Local Models & Secure Orchestration: Keep data within corporate firewalls by running local models or utilizing secure protocols like MCP.
Targeted Encryption: Encrypt or mask sensitive prompt segments, such as using unique emoji sequences, to keep text unreadable to the provider.
It's been two weeks since I last posted! But I am back after the day job got in the way with a major project and a tight deadline. Last post I talked about the dangers of copy and paste and how easily information can end up in the hands of the LLMs
Whenever we type a prompt into an AI assistant, it is easy to imagine our words vanishing into the digital ether the moment we hit 'send'. But Large Language Models (LLMs) have incredibly sticky memories. While it is easy to accidentally slip sensitive data into an AI tool, it is equally important to understand what the AI actually does with that information once it has it.

LLMs are designed to consume, process, and generate text, which means treating them like a private diary or a secure vault can lead to unintended, and highly public, consequences. Here is a look at how your confidential information gets consumed and redistributed by AI, and the best practices you can use to keep your private data safe.

The Consumption and Redistribution Cycle

When you feed Personally Identifiable Information (PII) or corporate secrets into an external LLM, you are exposing that data to several hidden risks:

Data Logging and Storage

Many AI providers log user prompts to monitor for abuse, debug their systems, or improve their overall services. Once your confidential data is stored on a third-party server, it becomes vulnerable to unauthorized access or potential data breaches on the provider's end.

Training Data Contamination

The prompt you submit today could inadvertently become the training data of tomorrow. Even though some enterprise providers have strict policies, there is always a baseline risk that PII from user prompts might be absorbed to further train or fine-tune future versions of the models.

Output Leakage and Regurgitation

LLMs are known to memorize information from their pre-training phases as well as from prompts processed during active inference. This can lead to a phenomenon where the model unintentionally regurgitates your sensitive information verbatim in its responses to completely different users. In fact, the OWASP Top 10 for LLMs lists "Sensitive Information Disclosure" as a critical vulnerability, noting that poor input handling can cause models to leak PII, business strategies, or system credentials directly into the public domain.

Defending Your Data: Precautions and Safe Methods

Fortunately, you do not have to unplug your routers and swear off AI entirely. There are several highly effective precautions and architectural strategies you can implement to interact with LLMs safely:

1. Build Anonymization and Mapping Pipelines

The most practical defense is to scrub the data before it ever leaves your network. By using tools like Named Entity Recognition (NER), you can automatically identify sensitive entities and replace them with generic placeholders—for example, swapping a real name and email for `[FIRSTNAME]` and `[EMAIL]`. This allows the LLM to understand the context of the prompt without ever seeing the raw data. On your end, you keep a secure, temporary map of these placeholders. When the LLM replies, a mapping-based de-anonymization module simply swaps the real information back in, ensuring 100% accuracy without exposing the data to the cloud.

2. Demand Zero Data Retention (ZDR)

If you rely on cloud-based AI vendors, mandate a "Zero Data Retention" agreement. Under ZDR, the provider processes your prompt and immediately returns the response without writing your request to any persistent storage, training queues, or logs. The data exists only in memory for the exact duration of the API call, effectively shifting your risk profile from uncertain to bounded.

3. Utilize Local Models and Secure Orchestration (e.g., MCP Servers)

For the highest level of control, organizations can run fine-tuned, smaller language models entirely within their own corporate firewalls, ensuring data never leaves the internal infrastructure. When connecting AI to internal databases, utilizing secure architectural patterns like the Model Context Protocol (MCP) can help safely orchestrate how context is provided to the AI without exposing raw data to public endpoints.

4. Targeted Encryption

For highly regulated environments, researchers are developing targeted encryption techniques. This involves encrypting only the sensitive sub-parts of a prompt, sometimes even translating them into unique sequences of emojis (like EmojiCrypt), so the text remains unreadable to humans and providers, but retains enough structure for the LLM to process. While computationally expensive and complex to implement, it represents the bleeding edge of prompt privacyLarge Language Models (LLMs) pose significant security risks because they can unintentionally memorize and redistribute sensitive information, such as PII and corporate secrets. Primary dangers include unauthorized data logging, training data contamination, and output leakage where models regurgitate your data to others.

AI models are incredibly eager to learn, which makes them fantastic assistants but terrible secret-keepers. By adopting smart anonymization pipelines, demanding strict retention policies, and securing your integrations, you can enjoy all the productivity benefits of generative AI without accidentally donating your private data to the world.