haggl.ai Works With Every AI Agent — No Buyer Integration Required

One of the most common questions we hear about haggl is: “Does the buyer’s AI agent need to integrate with your platform?”

The answer is no. haggl.ai works with every AI agent, out of the box, with zero integration on the buyer side. The buyer’s agent doesn’t need to know about haggl, install anything, or be pre-configured in any way. If it can read a webpage and make an HTTP request, it can negotiate.

This is by design. haggl.ai is a vendor-side protocol. The vendor installs it. The buyer’s agent discovers it. That’s the entire story.

How Discovery Works

When a vendor installs haggl, a single meta tag is added to their site:

<meta name="haggl-negotiate"
      content="https://haggl.ai/api/negotiate?vendor=acme" />

That’s it. When any AI agent visits the vendor’s page—whether it’s ChatGPT, Claude, Gemini, a custom procurement bot, or any future agent that doesn’t exist yet—it sees this meta tag the same way it reads any other HTML element.

The meta tag points to a negotiation endpoint. The agent fetches it. The endpoint responds with a fully self-describing protocol: what data the vendor wants, what each data point unlocks, and how to submit an offer. The agent doesn’t need documentation, an SDK, or prior knowledge of haggl. The endpoint explains itself in plain language that any LLM can parse.

Why Zero Buyer Integration Matters

Most commerce protocols require both sides to integrate. That creates a chicken-and-egg problem: vendors won’t adopt until buyers do, and buyers won’t adopt until vendors do.

haggl.ai eliminates this entirely. The vendor installs a script tag, defines their pricing rules, and they’re live. From that moment, every AI agent that visits their site can negotiate—today, tomorrow, and for every new agent that launches in the future.

There is no buyer-side SDK. There is no agent directory to register in. There is no partnership or API key exchange. The protocol is open, self-describing, and works the moment the vendor publishes the meta tag.

What the Buyer’s Agent Actually Does

Here’s the full sequence from the buyer agent’s perspective:

1. Browse. The agent visits the vendor’s website, just like it would visit any other site while shopping for its user.
2. Discover. The agent notices the haggl-negotiate meta tag in the page’s HTML. This is no different from reading any other meta tag—like og:title or description.
3. Read the endpoint. The agent fetches the negotiation URL. The response is a structured, human-readable description of the negotiation protocol: what ICP data the vendor values, what discounts each data point can unlock, and the format for submitting a request.
4. Negotiate. The agent submits whatever customer data it has (company size, industry, usage patterns) in the format described. The vendor’s haggl endpoint evaluates the data against the vendor’s pricing rules and responds with a personalized offer.
5. Return to the user. The agent brings back the offer—a confirmed price, a checkout link, or contract terms—along with what was exchanged to earn it.

At no point does the agent need to “support haggl” or “integrate with haggl.” It simply reads a webpage, follows a URL, and negotiates in structured JSON. These are capabilities that every modern AI agent already has.

Compatible With Every Agent—Including Ones That Don’t Exist Yet

This is the key architectural decision behind the protocol. Because haggl is self-describing and uses standard web primitives (HTML meta tags, HTTP endpoints, JSON), it is forward-compatible with every agent that will ever be built.

Today’s agents—ChatGPT with browsing, Claude with computer use, Google’s Gemini agents, vertical procurement bots—can all negotiate via haggl without any awareness of the protocol in advance. Tomorrow’s agents will be able to do the same, because the protocol lives on the vendor’s page and explains itself on first contact.

No agent registry. No version negotiation. No handshake. The vendor publishes. The agent discovers. The deal happens.

What Vendors Need to Do

If you’re a vendor, here’s your checklist:

1. Add the haggl embed — one script tag on your site.
2. Define your ICP — what customer data matters to you and how much discount each data point is worth.
3. Set your pricing rules — minimum and maximum discount ranges, product tiers, and any constraints.
4. Go live. Every AI agent that visits your site can now negotiate.

That’s the entire integration. No buyer outreach. No partner integrations. No waiting for adoption. Your endpoint is live for every agent on the internet the moment you publish it.

For Agent Developers: You Don’t Need to Build Anything

If you’re building an AI agent—whether it’s a general-purpose assistant, a shopping agent, a procurement tool, or anything else—you don’t need to integrate with haggl. You don’t need our SDK (we don’t have one for buyers). You don’t need an API key.

If your agent can browse the web and read HTML, it will encounter haggl endpoints on vendor sites. When it does, the endpoint will explain what it is and how to negotiate. Your agent can choose to negotiate or move on—just like a human deciding whether to ask for a discount.

The protocol is fully documented, but your agent doesn’t need to read the docs in advance. The endpoint itself contains everything the agent needs.

TL;DR

• haggl.ai is vendor-side only. Vendors install it. Buyers don’t need to do anything.
• Discovery is automatic. The negotiation endpoint lives in a standard HTML meta tag that any agent can read.
• The protocol is self-describing. No prior knowledge, SDK, or API key required on the buyer side.
• It works with every agent. ChatGPT, Claude, Gemini, custom bots, and every agent that will be built in the future.
• Standard web primitives. HTML meta tags, HTTP endpoints, JSON requests—nothing proprietary, nothing exotic.

Ready to make your products discoverable and negotiable by every AI agent on the web? Get your embed code or read the protocol spec.

Last updated: April 14, 2026