Strabo: Declarative Specification and Implementation of Agentic Interaction Protocols
This paper introduces Strabo, a framework that demonstrates the practical relevance of declarative interaction protocols to industry Agentic AI by modeling Google's Universal Commerce Protocol (UCP) checkout process using the Langshaw specification and Peach implementation, successfully verifying interoperability with Google's agents to enable the incremental adoption of formal methods in conventional settings.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
The Big Picture: Teaching Robots to Shop Together
Imagine a future where your personal AI assistant (let's call it "Alice") goes shopping for you. She needs to talk to a store's AI assistant (let's call it "Bob") to buy a shirt, pay for it, and get it delivered.
For this to work, Alice and Bob need to speak the same language and follow the same rules. If Alice says, "I want to buy this," Bob needs to know exactly what that means, what information he needs next, and what he can't do yet.
Currently, big tech companies (like Google) are trying to set these rules. They created a set of instructions called UCP (Universal Commerce Protocol). Think of UCP as a very long, messy instruction manual written in plain English and JSON code. It tells developers how to build shopping bots. However, because it's written informally, it leaves a lot of room for confusion. Developers have to guess the rules, which often leads to errors or bots that can't talk to each other properly.
The Problem: The "academic" world has been building very precise, mathematical rulebooks for robots for years (called Langshaw). But nobody thought these fancy rulebooks could actually work with the messy, real-world protocols used by companies like Google.
The Solution (Strabo): The authors built a tool called Strabo. Its job is to act as a translator and a bridge. It takes the messy Google instructions, turns them into a precise mathematical rulebook, and then builds a "bridge" that lets a robot speaking the precise language talk to a robot speaking the messy language.
The Three Main Characters
To understand how this works, let's look at the three key tools the authors used:
1. Langshaw: The Strict Architect
Imagine you are building a house.
- The Google Way (UCP): You have a sketch on a napkin that says, "Put a door here, maybe a window there." You have to guess where the door goes. If you guess wrong, the house might collapse.
- The Langshaw Way: This is a strict architectural blueprint. It says: "The door must be here. The window cannot be there. You cannot paint the wall blue until the door is installed."
- Why it matters: Langshaw forces you to be precise. It prevents robots from doing things out of order or missing important steps.
2. Peach: The Smart Builder
Once you have the strict blueprint (Langshaw), you need a builder to follow it.
- Peach is the builder. It doesn't need to be told every single step by a human. Instead, it looks at the blueprint and says, "Okay, based on the rules, the only thing I am allowed to do right now is hang the door."
- It handles all the boring, complex math of "Is this step allowed? Did we miss a step?" so the human (or the AI's brain) can just focus on the creative part: "Hang the door."
3. Strabo: The Diplomatic Translator
This is the star of the show.
- The Problem: The Google bots (UCP) speak "Napkin Sketch." The Peach bots speak "Strict Blueprint." They can't understand each other.
- The Solution: Strabo builds a bridge. It sits in the middle.
- When the Peach bot wants to "Create a Checkout Session" (Strict Blueprint language), Strabo translates that into a specific HTTP request (Napkin Sketch language) that the Google bot understands.
- When the Google bot replies, Strabo translates the messy reply back into a clean "Created" signal for the Peach bot.
- The Result: The Peach bot thinks it's talking to another Peach bot. The Google bot thinks it's talking to another Google bot. They never know they are speaking different languages.
What Did They Actually Do?
The authors decided to test this on the Checkout process (buying something).
- They modeled Google's messy rules: They took the Google UCP "Checkout" instructions and rewrote them as a perfect, strict Langshaw blueprint.
- They built the bots: They created a "Platform" bot (the shopper) using the Peach builder.
- They built the bridge: They created a "Proxy" (the Strabo translator) that connects the Peach bot to Google's actual server.
- The Test: They let the Peach bot try to buy things from Google's server.
The Result: It worked! The Peach bot successfully completed transactions with Google's server. This proved that you can use strict, academic rules to control real-world, messy industry systems without breaking them.
Why Is This a Big Deal? (The "Aha!" Moments)
The paper highlights a few surprising things they discovered while translating the rules:
- Hidden Assumptions: Google's instructions didn't explicitly say, "You must wait for a reply before sending the next message." They just assumed everyone knew that. The strict Langshaw blueprint forced them to write that rule down explicitly. This prevents bugs where two bots talk over each other.
- Who Owns What? In the messy Google rules, it wasn't always clear who was allowed to change a piece of data (like the price). The strict rules made it clear: "The Shopper can set the items, but the Store sets the total price."
- Less Code, More Logic: The authors showed that writing a bot using their strict method (Peach) required much less code than writing a bot directly against Google's messy rules. The "bridge" handled all the heavy lifting of connecting to the internet and formatting data. The developer only had to write the logic for what to buy, not how to send the message.
The Bottom Line
The paper argues that we don't have to choose between "messy, real-world industry standards" and "precise, academic safety rules."
Strabo shows that you can have both. You can take a real-world protocol (like Google's UCP), wrap it in a strict, error-proof layer (Langshaw/Peach), and use a translator (Strabo) to make them work together. This means we can slowly introduce safer, smarter AI agents into our current systems without having to rebuild the entire internet from scratch.
In short: They built a universal adapter that lets a robot following a strict rulebook shake hands with a robot following a sketchy napkin, proving that precision and practicality can coexist.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.