The Price You Were Quoted Is the Price You Pay

When an agent buys for you, the price it quoted has to hold.

That sounds obvious. In practice, it's one of the hardest promises in online shopping. Prices move, and the number you saw a minute ago may not be the number that's true now.

Here's how JENNi approaches price accuracy in online shopping: we check the price again at checkout, and nothing is charged until the shopper approves the final total.

Where prices drift

Prices go stale for ordinary reasons.

A feed updates once and then sits there.
A promotion ends and the old price lingers.
The same item costs different amounts in different places.

None of this is anyone's fault. Shelves change faster than data does. But if a system quotes a price it can't stand behind, the shopper pays for the gap.

In our SKU Graph, every store offer carries a price, a source and the time we last saw it. That timing matters. A price is a fact about a moment, and old facts need handling.

Rechecking at checkout

The quote is not the end of the check.

When a shopper reaches checkout, the checkout re-verifies the current price and availability. If the price evidence is stale, checkout refuses it. It doesn't quietly go ahead on a number it can't trust.

We don't pretend this removes every surprise. Prices can change between one moment and the next, and no system can promise otherwise. What we do have is a checkout that won't proceed on stale prices.

That's a deliberate choice. Stopping an order is better than finishing one at a price nobody can vouch for. A refused checkout is a small annoyance. A wrong charge is a lost customer.

Nothing is charged until you approve the total

Rechecking the price is half of it. The other half is when money moves.

For agents, here's the flow on JENNi's MCP server:

get_buying_options returns availability, price, delivery fee, the delivery promise and the total before tax.
start_checkout returns a hosted checkout_url. The buyer reviews delivery, tax and the total, and pays on that secure page. By itself it creates no order and no charge.
For in-chat checkout, create_checkout and update_checkout build up the order. Nothing is charged until complete_checkout, and that runs only after the shopper approves the total.

Payment uses a one-time shared payment token, never a card number. Card fields are refused in code.

So the agent can research, compare and prepare. The person decides when it's final.

Why this matters more when software is buying

A person who sees a price they dislike can stop. They read the page and they feel the number.

An agent moves faster and reads less. If it acts on a stale price, a small error can repeat across many orders before anyone notices. That's why the guardrails live in the system, not in the hope that nothing changes.

Three rules help any agent builder:

Treat a quote as true for a moment, not forever.
Make the final total something a human approves.
Choose commerce providers that recheck before they charge.

What shoppers should expect

If you shop on shop.jennipro.com, the same ideas apply. You see the delivery fee and the total before tax up front. Tax is added at checkout, where you review the final total. You approve it, and only then does payment happen.

There's no step where a number quietly changes after you've said yes. The total you approve is the total you pay.

The short version

Quotes can go stale, so checkout looks again. Money moves only after a person approves the total. And the payment itself never exposes a card number to the agent.

None of that is flashy. It's the plain machinery that lets someone hand a shopping task to software and still feel in charge of the result.

Build on it

Agent builders can connect to JENNi's MCP server at https://shop.jennipro.com/mcp. Shoppers can see how it works at shop.jennipro.com.