Nash — AI Seller Agent for Modern Storefronts

Nash is an AI-native commerce protocol. It identifies customer intent, meets shoppers wherever they are, and deploys specialized agents to drive conversions — at your storefront, inside ChatGPT, in Claude, and anywhere AI agents shop on behalf of humans.

This page is the technical overview for builders. For the protocol-level spec, see PROTOCOL.md.

What ships today

Component	What it is	Where it lives
Nash Protocol (`nash.v1`)	Open HTTP/JSON protocol for AI-mediated commerce	PROTOCOL.md
Nash Merchant Server	Pip-installable Python library — adds Nash to any store	PyPI
Nash MCP Connector	MCP server for Claude Desktop, Cowork, and other MCP clients	PyPI
Nash MCP (hosted)	One-paste install endpoint — no local setup	`mcp.pier39.ai/mcp`
Nash Agent app	Published in the ChatGPT App Store — one-click connect	ChatGPT App Store
Nash Directory	Public registry of Nash-ready brands	GitHub
Nash compliance badge	Embeddable SVG signaling Nash support	`/badge.svg`

What Nash does

Nash is a seller agent that lives on a brand's checkout. It does two jobs:

1. Engages human shoppers at the moment of hesitation. When a buyer is about to abandon, Nash starts a conversation in the brand's voice and helps them across the finish line — using only the responses the brand has pre-authorized.

2. Speaks to AI shopping agents over a standardized interface. ChatGPT, Claude, Cursor, and other AI assistants can discover Nash-ready stores, request offers, and complete transactions — all through the nash.v1 open protocol.

Same agent, two channels. The brand stays in control of voice, pricing rules, and what's on offer.

Three audiences, three paths

Audience	What you do	Where to start
Shoppers	Add the Nash MCP connector in Claude Desktop, or connect the Nash Agent app in ChatGPT	For Shoppers
Merchants	Install `pier39-merchant-server` on your store to become Nash-ready	For Stores
Protocol implementers	Read the spec and build in any language	Protocol

Architecture (three layers)

The Nash stack is intentionally decoupled so any layer can be swapped without breaking the others:

┌─────────────────────────────────────────────────────────────┐
│  LAYER 3 — Discovery                                        │
│                                                              │
│   Nash Directory                                            │
│   Public registry of Nash-ready brands.                     │
│   AI shoppers query it to find stores to transact with.     │
└─────────────────────────────────────────────────────────────┘
                          ▲
                          │ (search + match)
                          ▼
┌─────────────────────────────────────────────────────────────┐
│  LAYER 2 — Protocol                                         │
│                                                              │
│   nash.v1                                                   │
│   Open HTTP/JSON standard. MCP-compatible.                  │
│   The language agents and brands share.                     │
└─────────────────────────────────────────────────────────────┘
                          ▲
                          │ (HTTP/JSON, hypermedia-driven)
                          ▼
┌─────────────────────────────────────────────────────────────┐
│  LAYER 1 — Brand Agent (Nash)                               │
│                                                              │
│   Lives on the brand's checkout.                            │
│   Reads the customer. Responds in the brand's voice.        │
│   Closes the cart.                                          │
└─────────────────────────────────────────────────────────────┘

Brands can run their own agent on top, but as long as it speaks nash.v1, every shopper in the directory can find and transact with them.

The protocol — nash.v1 (one-paragraph summary)

Every Nash-ready store serves a JSON descriptor at /nash.json (and /.well-known/nash.json). The descriptor advertises products, endpoint URL templates, and rate limits. Shopper agents pick a product, open a session, and exchange messages until the session closes. The protocol is GET-based by default (POST equivalents exist for browser widgets) and hypermedia-driven — every response includes a next URL so the shopper doesn't construct URLs from templates.

Full spec: PROTOCOL.md.

Quick-start

I run a store

pip install pier39-merchant-server

Then write a catalog.json describing your products and the responses Nash is allowed to offer. Run the server, point your domain at it, and your store is discoverable by every AI shopper in the directory.

Full walkthrough: STORE_SETUP.md.

I want to shop via Claude / Cowork

Open Claude Desktop → Settings → Connectors → Add custom connector and paste:

https://mcp.pier39.ai/mcp

Then in any chat: "Find me a Dyson HP07 at the best price available."

Full walkthrough: SHOPPER_SETUP.md.

I want to shop via ChatGPT

Open chatgpt.com/apps, search "nash", click Connect on the Nash Agent app, then invoke it in any chat by clicking the + icon in the composer.

I want to build a custom shopper or seller

Read PROTOCOL.md and implement either side in any language.

Distribution

Channel	What's there
PyPI	`pier39-merchant-server`, `negotiate-mcp`
MCP Server Registry	Canonical listing for the Nash MCP
Hosted endpoints	`nash-checkout.pier39.ai` (checkout API + docs), `mcp.pier39.ai` (hosted MCP)
ChatGPT App Store	Nash Agent app

Design principles

Open protocol over proprietary platform. Adoption matters more than capture. An open standard grows the ecosystem; a closed product caps the network at the size of one company.

GET-based by default, hypermedia-driven. Works with every AI fetch tool, even ones that don't support POST. Each response carries the URL of the next valid request, so shopper-side implementations stay trivial.

Brand stays in control. Every response Nash gives is from a set the brand pre-approved. The agent never invents an offer.

License

Skills: Apache 2.0
Library, MCP connector, protocol, docs: MIT