---
id: 6ae601b66e131e610a45e325
title: 'Your AI Support Bot Is Confidently Wrong About Prices '
parentId: 6a8ee8ba4519ef1e0b559284
rootId: 6a74488c985a7e097152c04c
author: Rain
createdAt: 2026-10-31T14:56:54.899Z
updatedAt: 2026-10-31T16:35:38.423Z
---

# Your AI Support Bot Is Confidently Wrong About Prices 

**Why a knowledge base needs a read-only live-data layer — and how to build one without turning your agent into a database client.**

*Tags: AI Agents, Customer Support, Architecture, LLM, APIs*

> 
**By the 2Ryun team.** [2Ryun](https://2ryun.com/?utm_source=medium&utm_medium=article&utm_campaign=live_data_connectors) is a knowledge and AI content platform: teams turn their documents into a structured knowledge base, publish documentation, and run support bots that answer from their own content. This article describes a pattern from our own bot stack.


---

At 2:13 a.m., a customer asks your support bot a simple question:

> 
“How much is the Pro plan?”


The bot answers instantly, politely, and with complete confidence: **$299 per year**.

There is only one problem. You raised the price to **$399** three weeks ago.

The knowledge base was extracted from a document that was true in January. The vector search worked perfectly. The answer was well-written. The model did exactly what it was asked to do. And the customer now has a screenshot that says your own bot quoted the wrong price.

This is not a model problem. It is an architecture problem: **we asked a system optimized for stable prose to answer questions about values that change every day.**

## Two kinds of facts

Support content contains two very different classes of information.

**Slow variables** change when someone edits a document:
- 
What a product is

- 
Who it is for

- 
What the onboarding process looks like

- 
What the refund policy says


**Fast variables** change without anyone touching the knowledge base:
- 
Price, stock, availability

- 
A customer’s credits, balance, or order status

- 
Available appointment slots

- 
Whether a KYC review has been approved


A knowledge base is an excellent tool for the first category. It is a terrible tool for the second. Retrieval doesn’t make stale data fresh; it just makes stale data sound authoritative.

So at 2Ryun we built a second path, alongside the knowledge base: **live data connectors**.

The rule is simple:

> 
**Knowledge answers “what is it?”. A connector answers “what is it right now?”.**


## The shape of the solution

A connector is not another database. It is a narrow, read-only query contract:

```json
{
  "name": "Subscription pricing",
  "url": "https://shop.example.com/api/plans",
  "method": "GET",
  "description": "Current price, stock and purchase links for subscription plans",
  "authoritative_fields": ["price", "stock"],
  "priority": 9,
  "prefer_live": true,
  "on_failure": "knowledge",
  "response_fields": {
    "plans": "data.plans"
  },
  "collections": [
    {
      "name": "plans",
      "path": "data.plans",
      "item_fields": {
        "plan_id": "id",
        "name": "name",
        "price": "price",
        "purchase_url": "url"
      }
    }
  ]
}
```

Four design decisions matter.

### 1. Read-only by construction

The platform only issues `GET` requests. It has no write credentials, no request body, and no ability to update your system. If a business action requires a write, it does not belong in the connector — it belongs in a **task handoff** (the subject of the next story).

This is not just a security posture. It is a product boundary. The moment an agent can “fix” a customer’s order, you have inherited a new class of risk: idempotency, authorization, refunds, partial failures, and a very unhappy finance team.

### 2. Authority is explicit

A model will happily blend a fresh API value with an old paragraph if you let it. So the contract makes authority explicit.

When a connector declares `authoritative_fields: ["price", "stock"]`, those fields override anything the knowledge base says. The prompt marks the live values as authoritative, and the card assembly step refuses to attach a stale knowledge price card when a live plan card exists.

The knowledge base still supplies the parts it is good at: plan names, benefits, audience. The live connector supplies the numbers. Nobody has to guess which source won.

### 3. The contract is declarative

The merchant does not hand the model an open-ended HTTP client. They declare:
- 
where parameters come from (`entry`, `visitor`, `message`)

- 
which response paths may be read (`response_fields`, `item_fields`)

- 
how arrays become cards (`collections`)

- 
what happens on failure (`knowledge` fallback or `hide`)


The model can choose **whether** to call a connector. It cannot invent parameters, read undeclared fields, or construct URLs.

### 4. Failure is a first-class state

Live data is unreliable by nature: timeouts, rate limits, deploys, a database failover at the wrong moment.

A connector failure never breaks the conversation. The bot falls back to the knowledge answer and, if configured, labels the price as “check the purchase page for the current value.” The customer still gets a useful answer. The fallback is visible and honest instead of silently wrong.

## The runtime path

```
User question
   │
   ▼
Keyword gate (price / stock / plan / …)
   │
   ▼
Small routing model picks 0–2 connectors
   │
   ▼
Parallel read-only calls
   │  ├─ params: entry metadata / signed visitor sub / regex from message
   │  ├─ SSRF checks: https, public DNS, no redirects, 64 KB cap
   │  └─ response whitelist: only declared fields
   ▼
VERIFIED LIVE DATA + AUTHORITATIVE fields in the prompt
   │
   ├─ answer text
   └─ server-built plan cards (price + CTA)
```

Two details are easy to miss.

**The router is small and bounded.** We do not ask a large model to plan a shopping session. A short classification call selects from the configured catalog, with a hard timeout and a maximum of two connectors. If it fails, the conversation continues without live data.

**The card is server-built.** The model writes the answer, but the plan card — name, price, period, CTA — is assembled deterministically from live fields. The model never gets to invent a purchase URL or a price inside a button.

## What a plan card looks like

For each item returned by the connector, the server adds a Markdown/JSON card block:

```json
{
  "type": "rich_card",
  "kind": "plan",
  "blocks": [
    { "type": "heading", "text": "Pro", "level": 2 },
    { "type": "keyValue", "items": [
      { "label": "Price", "value": "$399 / year" },
      { "label": "Status", "value": "on sale" }
    ]},
    { "type": "cta", "buttons": [
      {
        "label": "Buy Pro",
        "action": "handoff",
        "handoff_id": "h_subscribe",
        "offer": "<signed payload>"
      }
    ]}
  ]
}
```

The `offer` is signed by the platform. It carries the per-plan URL and parameters, so the client cannot tamper with the price, the plan, or the destination. The card is also marked `kind: "plan"`, which tells the merge step not to append a stale knowledge price card.

## What we deliberately did not do

**We did not let the model call arbitrary URLs.** A system prompt that says “don’t hallucinate” is not an SSRF defense.

**We did not cache live values.** The structure of a card can be cached; the number cannot. A cached price is just a stale price with better latency.

**We did not make the model the authorization layer.** The model can choose a connector; it cannot choose a user. Visitor identity only comes from a signed token, and a `visitor` parameter is always overwritten by the verified `sub`.

And to be precise about the identity plumbing: the signing **secret** stays on the server. The browser only carries a short-lived **token** that the merchant backend signs with that secret; the platform verifies it and extracts `sub`. The secret is never the token, and the token is never reusable across users.

**We did not add write access to make the demo impressive.** A read-only connector is less flashy than “the agent placed my order,” but it is the version you can put in front of a customer without a legal review.

## When this pattern fits

Use live connectors when:
- 
the answer depends on a value that changes without a document edit;

- 
the user is asking a question, not asking the agent to perform a transaction;

- 
the merchant can expose a narrow read-only endpoint;

- 
a short stale answer is worse than a slightly slower correct one.


Don’t use them when:
- 
you need a multi-step write workflow (use task handoff);

- 
the merchant cannot expose any endpoint or grant any read access;

- 
the data is sensitive enough that even a scoped read needs a full OAuth consent flow — that is a different architecture, not a smarter prompt.


## The lesson

The magic of a support bot is not that it knows everything. It is that it knows **which source to trust for which question**.

Knowledge bases are a snapshot. APIs are the present tense. A production agent needs both, with an explicit boundary between them: one side for stable meaning, one side for values that expire, and a contract that says exactly which side wins.

The next time your bot quotes a price, ask a simpler question: **is that price a fact from a document, or a value from a system?**

If you cannot answer that, neither can your bot.

---

## Building this on 2Ryun

We built this pattern into **2Ryun** so teams do not have to assemble it from scratch:
- 
turn documents into a knowledge base with citation-ready entries;

- 
add **read-only data connectors** for prices, stock, balances and order status;

- 
declare authoritative fields so live values override stale knowledge;

- 
render live plan cards with per-plan CTAs;

- 
keep the whole path read-only, with SSRF protection, host allowlists and a failure fallback.


You can explore the platform at **[2ryun.com](https://2ryun.com/?utm_source=medium&utm_medium=article&utm_campaign=live_data_connectors)**.

If you are building a support bot on top of your own stack, the architecture in this article is intentionally portable: one knowledge path, one live-data path, one explicit contract between them.

---

*Next in this series: ****Don’t Let Your Agent Click “Buy”**** — how to support purchases, bookings, and verification without giving the platform write access.*

*Originally published by the 2Ryun team at **[2ryun.com](https://2ryun.com/?utm_source=medium&utm_medium=article&utm_campaign=live_data_connectors)**.*