AI Answers to Pricing Questions: Why Quotes Go Stale

A buyer asks an AI assistant what a service costs. The assistant returns a number or a range. The answer sounds current because it arrives in the present tense. It rarely carries a date or a source timestamp. That missing metadata is where stale quotes begin.

Pricing changes on a schedule the assistant does not share. A clinic raises its new-patient exam fee. A contractor updates its minimum job size. A SaaS company moves to usage-based billing. The model’s training data keeps the old pattern. A retrieval layer pulls a live page, yet the retrieved snippet comes from a directory that mirrors last year’s price. The assistant blends both into one fluent answer with no indication of which figure is current.

The buyer acts on that figure. They budget against it and negotiate with it. The business sees no signal that an outdated quote is circulating. Website analytics show traffic. They do not show the shortlist. Call logs show the prospects who decided to call. They do not show the prospects who accepted a stale price and never called.

aeod.app assesses AI answers to buyer questions by measuring mentions and citations. In pricing prompts, a citation to a source that no longer matches the current rate is the finding. The answer ranks well and remains wrong.

That behavior makes pricing prompts a distinct class of buyer question.

Price questions are a different prompt class

When someone asks an AI assistant which plumber to call, the retrieval target is a business entity. The assistant looks for names, addresses, service areas, review counts, and category matches. Entity resolution ties those signals to a single business. That path governs local shortlists.

A cost question sends the same assistant to a different retrieval set. “How much does Notion cost?” matches pricing pages, plan cards, review roundups, and forum threads. The assistant is looking for a number, a tier name, a billing period, or a per-seat rate. The pages that rank for those tokens are vendor pricing docs and third-party roundups. They rarely contain the structured local data that makes entity resolution work. The entity-resolution path that governs local shortlists does not apply here. A business that ranks well for “emergency plumber Austin” still needs a pricing page to answer “plumber call-out fee.” The retrieval set changes because the question changes.

Constraints compound the difference. A query with “under $15 per seat” adds a numerical filter. The assistant must retrieve pages that state a price, then check whether that price falls under the threshold. That filter rewrites the query and reshuffles the retrieved set. Pages that say “contact sales” drop out. Pages that list a $12 starter tier and a $29 pro tier move up. The same shift appears when billing period or fee structure changes. Each constraint changes which passage the model cites.

Multi-turn pricing threads make this harder. A buyer asks for a base price, then adds seats, then adds annual billing, then asks about overages. Each turn produces a new retrieval pass. The model carries forward some context and drops the rest. Pricing visibility needs tracking separate from category visibility, and multi-turn follow-ups deserve their own read in multi-turn AI visibility follow-up questions.

Comparison questions anchor retrieval to pages that state both vendors’ prices side by side. “A vs B pricing” pushes the assistant toward review sites and forum posts with spreadsheet-style breakdowns. Those pages create a direct numeric contrast. The model quotes one vendor’s entry tier and the other’s enterprise tier from the same source. This pattern shows up in AI comparison prompts.

The retrieval difference explains why pricing answers go stale. A category answer remains stable for months because the underlying business facts change slowly. A price answer depends on a page that a vendor edits, a review site that updates a table, or a forum thread that adds a new comment. The assistant retrieves a snapshot. The buyer reads it as current.

A price audit checks what the assistant names and cites. The measured error rate is next: assistants named the right price 15% of the time.

The measured error rate: assistants named the right price 15% of the time

Across three frontier assistants and 79 widely used SaaS tools, the correct current starting paid price appeared in 15% of answers, checked against each vendor’s published figure.

That number is a claim-level accuracy measure. It asks whether the specific price in the answer matches the vendor’s current published starting paid price. It does not measure whether the assistant mentioned the vendor, cited a page, or placed the brand in a shortlist. A vendor can appear in every answer and still have the wrong number attached to its name. The 15% figure measures the truth of the claim. It does not measure brand visibility.

The failure mode is easy to miss because the answer looks finished. A stale price arrives in the same fluent paragraph as a correct one. It can carry a citation to a pricing page. It can use the vendor’s own product name and plan tier. The reader sees a number, a source, and a confident sentence. The vendor sees a buyer who now has a wrong budget anchor.

That is why price prompts need claim-level review. A visibility dashboard counts mentions and positions. It records that the assistant said the brand. It does not check whether the number beside the brand is current. A business can score well on mention share and still send buyers to a stale price.

The pattern lines up with the citation half-life problem. Assistants rely on indexed pages and cached snippets. They also draw on review sites and older listicles. When a vendor changes its starting paid price, those sources do not update in sync. The assistant keeps drawing on the version it saw before. The answer stays coherent. The price stays old.

The scope is concrete: 79 tools, three assistants, one verified current price per tool. The result is a 15% hit rate on the price claim. That leaves 85% of price answers with a number that does not match the vendor’s current starting paid price.

Where a price answer comes from, and why the number lags, is the next part of the audit.

Where a price answer comes from, and why the number lags

When a buyer asks an assistant what a service costs, the assistant does not read the vendor’s mind. It retrieves. A retrieval-augmented assistant issues a query, receives a ranked set of URLs, extracts passages, and synthesizes an answer. The number in that answer comes from whichever passages the retrieval layer selected.

Those passages have several origins. The vendor’s own pricing page is one. Plan-comparison articles are another. Review aggregators publish their own pricing summaries. Reseller pages list license and subscription rates. Community threads on Reddit and vendor forums contain quotes from users. Each source carries a different update lag.

The vendor page has the shortest source-side lag. The vendor edits it, deploys it, and waits for the search index to recrawl. Third-party pages have longer lags. A comparison article published before a pricing change keeps the old table until an editor updates it. An aggregator refreshes on its own schedule, quarterly in some cases, or when a crawler next visits. A reseller page reflects a negotiated rate that the vendor stopped offering. A community thread preserves a 2023 quote because the thread stays indexed.

The retrieval layer does not know which page is authoritative. It ranks by relevance, link signals, freshness, and passage match. An outdated third-party page with strong domain authority outranks a current first-party page with a thin description. The assistant states the number from the higher-ranked passage. The vendor’s current price exists on the web and remains invisible to the answer.

Price visibility is an eligibility problem first and a ranking problem second. The current price must be present in the retrieved corpus, in a passage that the assistant can extract, before position matters. The same structure applies to category answers: an entity has to exist in the corpus before it can appear in a shortlist (why AI assistants recommend the same businesses). Tracing the answer to the passages that supplied it shows whether the vendor’s own page was retrieved or bypassed.

The source mix determines how fast the number goes stale. The update cycle determines how long the stale number survives. Once that map exists, the audit separates two failure modes: the wrong price and the missing brand.

Two failure modes: the wrong price and the missing brand

A price audit has to keep two outcomes apart. The first is an accuracy failure. An assistant names the business and attaches a stale figure. The live pricing page shows a different number. The buyer gets a specific price from a specific brand, and that price is wrong. The source is a cached third-party profile or an older crawl. The fix is to make the current first-party number the easiest number to retrieve. Update the page and keep the same figure in schema markup. Push corrections to the directories the model already cites.

The second is a presence failure. The assistant does not name the business at all. The answer lists competitors and no stale number exists because no number was given. This outcome is harder to notice. A wrong price produces a complaint. A missing brand produces nothing. The repairs differ. Accuracy work focuses on source freshness and citation consistency. Presence work focuses on whether the business appears in the retrieval set for the prompt and whether its entity is clear enough to attach to the category. Measuring mentions and source citations across buyer questions shows which failure is active.

There is a third case that produces both symptoms. A pricing page is live in a browser and blocked to AI crawlers. The server returns a 200 to a human and a robots.txt disallow or bot challenge to GPTBot, ClaudeBot, PerplexityBot, or Google-Extended. The assistant has no first-party page to retrieve. It fills the gap with third-party figures, an outdated directory listing or a competitor comparison table. The business then looks either stale or absent. The mechanics of that block are covered in blocking AI crawlers from AI answers.

Each failure has a different repair. A stale figure needs a source update and propagation. A missing brand needs retrieval and entity work. A blocked pricing page needs crawler access restored before any source update matters. The audit cannot collapse those into one score. If it does, a team will rewrite a page that no assistant can read, or chase citations when the real defect is an old number in a directory.

When the page is reachable and contains a price, the audit compares that price to the answer. When the page is reachable and contains no price, the audit enters the “contact us for pricing” vacuum.

The ‘contact us for pricing’ vacuum

Retrieval systems work on documents. When a buyer asks “how much does X cost,” the assistant searches indexed pages for a number tied to a named provider. If a pricing page contains a heading, a paragraph about flexibility, and a button, the index has no figure to return. The page exists. The number does not.

Three outcomes follow, and they are observable in assistant transcripts.

The first is omission. The assistant builds a cost answer from sources that carry figures. A business absent from that set does not appear in the list of providers, and the buyer does not learn to ask about it. Nothing was rejected. The name was never in the candidate pool.

The second is substitution. A competitor with “$149 diagnostic fee” or “from $89 per visit” printed in a table becomes the default answer, because the assistant needs a concrete anchor before it writes a cost sentence. The published price does the work of being quotable, whether or not it is the lowest offer.

The third is estimation. With no first-party number, the model falls back on third-party commentary: forum threads, review sites, directory pages that list ranges. The resulting figure is plausible and unowned. It sits above or below the actual quote, and the business has no mechanism to correct it because the citation points elsewhere.

Quote-only pricing is a legitimate commercial choice. Complex implementations and variable scopes resist a single posted figure, and routing a serious buyer to a sales call is often the right commercial move. The issue is treating that choice as neutral. It is a trade: sales-call control in exchange for absence from every answer where a number is the entry condition.

That trade has a measurable cost. Comparing the answers assistants give to pricing questions against the pages the business controls, tracking mentions, citations, and position, shows where the vacuum appears. The useful finding is which pricing questions the business is currently invisible to, and whether that exposure was chosen or inherited.

Reading those answers requires a consistent set of fields. The next section covers the fields that make a quote readable.

Auditing price answers: the fields that make a quote readable

A price quote in an AI answer is only readable if the run behind it is logged with a fixed schema. The same question asked in two markets returns two prices. The same question asked next month returns the price from that month’s page. Without consistent fields, an audit compares a number to a memory.

Record the quoted figure, the currency, the tier or plan named, the date of the run, whether the citing page is first-party or third-party, and the cited URL. Those six fields separate a real quote from a passing sentence. A quoted figure without a currency is incomplete. A quoted figure without a tier names no product. A cited URL without a source type hides whether the answer is reading the business’s own pricing page or a third-party directory.

Add a location field. A national brand with regional branches sees one market quoted at the flagship rate and another market quoted at a sibling branch’s rate. The AI visibility by location post covers how answers shift across geographies. A location field makes that shift visible in the log. It also exposes a sibling branch rate that belongs to another market.

The date of the run pairs with the cited URL. A first-party pricing page with a recent update stamp carries different weight than a third-party directory page with no update stamp. The citation half-life post explains how citation value decays over time. A price answer cites a page that was correct at publication and stale at retrieval. The run date is the only field that places the quote on a timeline.

Repeat each prompt several times. A single run samples one answer from a distribution. Five runs show the spread. If the figure moves between runs, a single logged price is noise. If the figure holds across five runs, the quote is stable enough to audit. The repetition also catches tier drift, where one run names the Pro plan and another run names the Team plan for the same question.

Logging these fields per run keeps the quoted figure and its source in one row with the location. That row is the unit of comparison. It shows whether a stale quote comes from an old URL, a third-party page, a different market, or a plan name that changed.

With the schema filled, a stale price becomes a concrete repair. The log points to the exact URL that needs correction. It also names the market and the plan. The next section covers correcting a stale price without starting over.

What a price audit can and cannot fix

A price audit is a measurement loop. aeod.app runs the same set of pricing questions on a fixed schedule, records the figure each assistant returns, and marks every answer current, stale, or invented. The output is a wrong-quote rate: the share of runs where the number in the answer does not match the published price.

That rate moves. It never settles. Retrieval is rebuilt on every prompt. The assistant embeds the question, searches an index, pulls a handful of passages, and writes a figure from whatever those passages contained during that pass. Edit a pricing page today and tomorrow’s run draws from a different passage pool. One clean run after an edit proves the edit entered the index. It says nothing about whether that passage keeps winning the retrieval step next week.

The workable target is a lower wrong-quote rate over weeks, measured the same way each run. Every change to pricing content gets logged against the answers it moved. A rate table with a visible revision date. A unit definition placed beside the figure. A tier boundary restated in a plain sentence. Each entry carries a date, and the run history on either side shows whether the rate dropped or held flat.

What the audit cannot do is pin a number. No page edit guarantees the next answer is correct. Assistants rebuild retrieval per question, and that retrieval pulls competitor comparison pages and cached summaries alongside the company’s own page. A stale figure sitting in a third-party comparison post stays retrievable after the company’s plan page has been rewritten. Indexes refresh on their own schedules. Model weights stay fixed between releases. A competitor’s page changes. A directory copies an old figure. The rate moves; it does not lock.

That constraint shapes the remedy. Price comparison content gives an assistant more retrieval paths to a current figure than a single plan card. A page that states its price beside two named alternatives, repeating the same figure in a heading and in a table row, offers several passages that satisfy a pricing query. A lone plan card offers one passage, and if retrieval skips it the answer falls back to whatever else the index holds. Comparison pages also match the shape of the prompts buyers type, a pattern covered in why AI assistants recommend the same businesses and in AI comparison prompts and X vs Y verdicts.

Price accuracy behaves like a distribution that gets sampled. A retrieval system that pulls the pricing page on Tuesday returns Tuesday’s number. A model answering from training data returns the number frozen at its cutoff. A cached snippet returns whatever the crawler last stored. The same buyer prompt, run against two assistants or on two days, can produce two figures. That variation is the object to manage.

A business that publishes a current, retrievable price and updates the exact page an assistant cited has a lower wrong-quote rate than a business that publishes nothing. The mechanism is direct: retrieval systems need a source to quote. When the source exists and matches the service, the answer has a place to land. When it does not, the assistant fills the gap with third-party estimates and old forum posts. That gap is where stale quotes come from.

The useful output of an audit is a per-prompt log. For each buyer question, record the quoted figure, the cited source, the assistant, and the date. Read the log over several weeks. When a price changes, note the exact page updated and the next quoted figure for that prompt. That pairing shows whether the change reached the answer. Mentions, citations, and positions tied to specific prompts make the log useful. It shows which page needs fixing first and whether the fix moved the number.

Run the loop on a schedule. Publish the price where retrieval can find it. Update the cited page when the price changes. Keep the log. The wrong-quote rate will drift when the sources drift. The work is to keep sampling from a current source.