Nash — AI Seller Agent for Modern Storefronts

Nash is an AI-native conversion 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. If you're looking for the product pitch, visit nash.pier39.ai.

TL;DR — what Nash includes

Why Nash exists

80,000 AI agents are shopping today. By 2032: 7.4 billion. Every person on the internet will have at least one AI shopping on their behalf — and most storefronts are invisible to them.

Nash solves three problems at once:

1. Recover abandoning shoppers — when a hesitant customer is about to leave, Nash steps in as an AI seller agent. Average recovered revenue: $300K/month per merchant, 20% lift in cart conversion, <50ms agent response.

2. Be reachable by AI agents — Nash-enabled stores expose a standard protocol so ChatGPT, Claude, and any AI shopping assistant can transact at your store on a customer's behalf — with your floor pricing, your rules, your brand voice.

3. Stay in control — every rule, floor, and concession is yours. Nash never sells below the price you set, never gives away inventory you said is locked, and never wanders off-brand.

The technical glue is negotiate.v1, an open HTTP/JSON protocol. Open because adoption matters more than capture — any AI shopper that speaks the protocol works with any Nash-enabled store, and vice versa.

Two products under one brand

Nash for Websites

Engage visitors directly on your storefront. When a customer hesitates, Nash starts a conversation, surfaces the right concession (price, free shipping, bundle, extras), and closes the sale — all while respecting the rules you set.

→ Integration guide

Nash for Agentic Shopping

Make your storefront discoverable and transactable by AI agents. When a ChatGPT or Claude user asks "find me running shoes under $80," Nash-enabled stores are the ones their AI brings back with real offers, not just links.

→ Integration guide

Three audiences, three paths

Architecture

Three layers, deliberately decoupled:

┌─────────────────────────────────────────────────────────────┐
│  LAYER 1 — Agent skills (the brain)                         │
│                                                              │
│   Nash Shopper Agent     Nash Seller Agent                  │
│   • Anchor with comps    • Hold the floor                   │
│   • Decreasing demands   • Cheap-first concessions          │
│   • Walk gracefully      • Decreasing-concession pattern    │
└─────────────────────────────────────────────────────────────┘
                          ▲
                          │ (loaded as system prompt)
                          ▼
┌─────────────────────────────────────────────────────────────┐
│  LAYER 2 — Implementation libraries (the body)              │
│                                                              │
│   Nash Merchant Server            Nash MCP Connector        │
│   • Drops in a chat backend       • 5 MCP tools             │
│   • Serves /negotiate.json        • discover_store          │
│   • Rate-limited, CORS-ready      • start_negotiation       │
│   • You bring catalog.json        • send_message            │
└─────────────────────────────────────────────────────────────┘
                          ▲
                          │ (HTTP/JSON, negotiate.v1)
                          ▼
┌─────────────────────────────────────────────────────────────┐
│  LAYER 3 — Hosted services (canonical reference)            │
│                                                              │
│   negotiate.pier39.ai             mcp.pier39.ai             │
│   • Atlas reference store         • Remote MCP for shoppers │
│   • 4 Dyson products              • Plug into Claude UI     │
│   • Real chat with Chonkers       • One-paste install       │
└─────────────────────────────────────────────────────────────┘

Each layer can be swapped without breaking the others. A merchant could use a different agent skill, a different model, or a non-Python backend — as long as the protocol surface in PROTOCOL.md stays compliant, every shopper still works against them.

The protocol — negotiate.v1

Nash is built on the open negotiate.v1 protocol. Full spec: PROTOCOL.md. Quick summary:

Discovery

Every Nash-enabled store serves a JSON descriptor:

GET /negotiate.json
GET /.well-known/negotiate.json   (mirror)

Response includes negotiate_protocol: "negotiate.v1", store info, products with IDs and list prices, endpoint URL templates, and limits.

Chat surface

Three GET endpoints + two POST equivalents. AI agents drive the conversation purely through GETs (no POST or sandbox needed):

GET /api/store/chat/start?product_id=<id>          → {session_id, greeting, next}
GET /api/store/chat/<sid>/say?message=<urlencoded> → {message, closed, next}
GET /api/store/chat/<sid>                          → {history}

Each response includes a next URL — hypermedia-driven so the shopper agent doesn't need to memorize URL patterns.

Hidden state

floor, levers, and inventory_note for each product live ONLY in the seller agent's private system prompt. They're stripped from every public GET response. The shopper agent never sees them.

Why GET-based

Most AI shopper tools (Claude.ai's web browsing, custom GPTs with actions) only POST when they have explicit Action manifests. GET works universally. Browser-based widgets that want JSON POSTs can use the POST equivalents — both are CORS-permissive.

The components in detail

1. The agent skills

pier39-merchant (Nash Seller) and pier39-shopper (Nash Shopper) are Claude Agent Skills — folder format with SKILL.md + references/. They teach Claude how to converse and close well; they don't include any implementation code, deployment logic, or storefront UI.

• Repo: github.com/sanjana-pier39/pier39-skills
• License: Apache 2.0
• Install: git clone + copy folders to ~/.claude/skills/

Each skill defines decision-tree-style tactics for its side of the conversation. The seller skill teaches floor-holding and concession ladders; the shopper skill teaches anchoring and walk-away discipline.

2. Atlas Premium Appliance — the reference storefront

Live at negotiate.pier39.ai/store. Fictional Dyson outlet with four products:

• Dyson V15 Detect Absolute (vacuum)
• Dyson Airwrap Complete Long
• Dyson Pure Hot+Cool HP07
• Dyson Supersonic Special Edition

Sales rep is Chonkers (configurable in store/catalog.json → rep_name). Click "Chat with Chonkers" on any product page to converse as a human, OR have an AI shopper hit the API endpoints directly.

The storefront also hosts a separate password-gated agent demo viewer at the apex (negotiate.pier39.ai) where two AI agents play out scripted conversations — that's a separate demo for showing the skill in action without needing two AI clients.

Source: this entire pier39-negotiation-demo/ folder is the storefront's source.

3. Nash Merchant Server (pier39-merchant-server)

Pip-installable Python library that gives any store a complete Nash backend in 6 lines:

from pier39_merchant_server import serve
serve(catalog_path="catalog.json")

That serves all the routes: /negotiate.json, /llms.txt, /api/store/catalog, /api/store/chat/* (both GET and POST equivalents), /api/health. Plus per-IP rate limiting, per-session message caps, permissive CORS, OPTIONS preflight.

The merchant brings: - A catalog.json (products with public fields + private floor/levers) - An ANTHROPIC_API_KEY env var - Hosting (anywhere that runs Python — Fly, Render, their existing infra)

That's it. Setup time: ~30 minutes for a developer, including the conceptual work of designing floors and levers.

• PyPI: pypi.org/project/pier39-merchant-server
• GitHub: github.com/sanjana-pier39/pier39-merchant-server
• License: MIT
• Onboarding doc: STORE_SETUP.md

4. Nash MCP Connector (negotiate-mcp)

Model Context Protocol server that exposes 6 native tools to any MCP-aware client (Claude Desktop, Cowork, Claude Code, Cursor, Cline, etc.):

• find_stores(query, category) — search the Nash store directory
• discover_store(domain) — probe a domain for Nash support
• list_products(domain) — get the catalog
• start_negotiation(domain, product_id) — open a chat session
• send_message(next_url, message) — send one shopper turn
• read_history(history_url) — read running chat history

find_stores is what closes the discovery loop: a shopper says "find me a store that sells Dyson vacuums" and Claude returns Nash-enabled matches from the Nash Directory without the shopper ever needing to know a URL.

Two install modes:

Stdio (local): pip install negotiate-mcp or uvx negotiate-mcp, then add to Claude Desktop's claude_desktop_config.json:

{
  "mcpServers": {
    "nash-agent": {
      "command": "uvx",
      "args": ["negotiate-mcp"]
    }
  }
}

Remote (hosted): hosted at https://mcp.pier39.ai/mcp. Add to Claude Desktop via the Settings → Connectors → Add custom connector UI:

• Name: Nash
• Remote MCP server URL: https://mcp.pier39.ai/mcp

No install required — just paste the URL.

• PyPI: pypi.org/project/negotiate-mcp
• GitHub: github.com/sanjana-pier39/negotiate-mcp
• MCP Registry: io.github.sanjana-pier39/negotiate-mcp
• Hosted endpoint: https://mcp.pier39.ai/mcp
• License: MIT
• Onboarding doc: SHOPPER_SETUP.md

5. The hosted MCP at mcp.pier39.ai

The same negotiate-mcp package, but configured with MCP_TRANSPORT=streamable-http and deployed as a Fly app. This is what powers the "Add custom connector" install path — shoppers paste a URL instead of installing software locally.

• Deployed via Dockerfile + fly.toml in mcp-connector/
• Env vars: MCP_TRANSPORT=streamable-http, HOST=0.0.0.0, PORT=8000
• No secrets needed (the MCP makes outbound calls to public storefronts; doesn't hold any API keys)
• Includes a runtime patch that disables MCP's DNS-rebinding protection (which assumes localhost-only deployment)

The deploy story is in mcp-connector/Dockerfile + fly.toml. Documented in mcp-connector/PUBLISH.md.

6. Nash Directory (negotiate-directory)

A single JSON file in a public GitHub repo listing every Nash-enabled storefront. The MCP's find_stores tool fetches this file (cached 5 min per process) so AI shoppers can search for stores by query or category.

• Repo: github.com/sanjana-pier39/negotiate-directory
• Live URL: https://raw.githubusercontent.com/sanjana-pier39/negotiate-directory/main/registry.json
• License: CC0 for the data; MIT for the tooling/docs
• How stores get listed: PR to add a single JSON object inside the stores array. Maintainers verify the store's /negotiate.json is reachable and merge.

Each entry includes name, domain, tagline, categories, sample product names, and the date added. The tag set converges over time; standard categories today: appliances, electronics, furniture, fashion, fitness, books, home, office, etc.

This single file is the matchmaking layer between Nash-enabled stores and the AI agents shopping on customers' behalf. Without it, shoppers need to know URLs by hand. With it, they ask the AI and get answers.

7. MCP Server Registry entry

Anthropic's official MCP Server Registry has a canonical listing for io.github.sanjana-pier39/negotiate-mcp published via the mcp-publisher CLI. The registry pulls metadata from the package's server.json manifest and verifies ownership via the mcp-name: io.github.sanjana-pier39/negotiate-mcp marker in the PyPI README.

This entry feeds:

• The MCP Inspector and CLI tools' discovery
• Smithery's auto-import (when published to Smithery)
• Future Claude Desktop in-app browse/install (when Anthropic ships that surface)

Quick-start paths by audience

I run a store — get Nash on my site

1. Read STORE_SETUP.md
2. Write a catalog.json for your products (with merchant judgment on floors + levers)
3. pip install pier39-merchant-server
4. python -c "from pier39_merchant_server import serve; serve(catalog_path='catalog.json', host='0.0.0.0')"
5. Deploy on Fly/Render/your infra
6. Point your domain at it
7. You're now Nash-enabled — discoverable by every AI shopper that speaks negotiate.v1

I want to use Nash as a shopper (Claude)

1. Read SHOPPER_SETUP.md
2. Open Claude Desktop → Settings → Connectors → Add custom connector
3. Name: Nash, URL: https://mcp.pier39.ai/mcp
4. Restart Claude Desktop
5. In any chat: "Find me the Dyson HP07 and get me a deal. Try to keep it under $500."

I want to use Nash as a shopper (ChatGPT)

1. Visit the Nash Custom GPT
2. Click "Start chat"
3. Tell it what you want

I just want to see it work

Visit negotiate.pier39.ai/store → click any product → click "Chat with Chonkers" → converse as a human.

I want to build a custom shopper or seller in another language

1. Read PROTOCOL.md
2. Implement either side in your language of choice
3. Test against Atlas at https://negotiate.pier39.ai/negotiate.json
4. Done

Distribution surface — where each component lives

Major design decisions

Open protocol over proprietary API. Adoption matters more than capture. An open protocol grows the ecosystem; a closed product blocks the ChatGPT half of the market.

GET-based conversations. Most AI fetchers are GET-only. POST equivalents exist for browser widgets, but the canonical surface is GET so shopper agents always work.

Hypermedia (next URLs in responses). The shopper agent never has to construct URLs from templates — each response tells it where to go next. This makes shopper-side implementations trivial.

Hidden state in system prompt only. Floor and levers never appear in any public response. Even if a malicious shopper tries to enumerate the catalog API, they only see public data. The seller agent enforces the floor through its prompt, not through post-hoc validation.

Stdio + HTTP MCP modes from one codebase. The same negotiate-mcp package runs as a local stdio server (Claude Desktop's classic install) AND as a remote HTTP server (Anthropic's "Add custom connector" UI, Smithery, etc.). One env var (MCP_TRANSPORT) flips between them.

Library-first for stores. A merchant integrator shouldn't have to read the protocol spec; they should be able to pip install and pass a catalog. The protocol is for implementers building in other languages or for understanding what's happening under the hood.

Sonnet 4.6 by default for the seller. Cheap enough (~$0.05–$0.15 per conversation) that public-facing deployments are affordable, smart enough that the seller tactics land. Opus is overkill; Haiku occasionally fumbles.

Roadmap

License

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

See also

• PROTOCOL.md — formal negotiate.v1 spec
• STORE_SETUP.md — onboarding for merchants
• SHOPPER_SETUP.md — onboarding for shoppers
• pier39-skills — the underlying Claude Agent Skills
• Atlas live demo — try Nash with Chonkers

Nash · built on the open negotiate.v1 protocol · MIT