Blog · Architecture

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.

AI Agents Customer Support Architecture LLM APIs
2Ryun team Read-only by construction

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.

2Ryun 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.

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, how onboarding works, what the refund policy says.

Fast variables

Change without anyone touching the knowledge base: price, stock, availability, credits and balances, order status, appointment slots, KYC approval.

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:

{
  "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)
The live-data path runs in parallel with — and overrides — the knowledge path.

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:

{
  "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

No arbitrary URLs

A system prompt that says “don’t hallucinate” is not an SSRF defense.

No cached live values

The structure of a card can be cached; the number cannot. A cached price is stale price with better latency.

No model-as-authz

The model can choose a connector; it cannot choose a user. A visitor parameter is always overwritten by the verified sub.

No write access for demos

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.

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.

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: citation-ready knowledge bases, read-only data connectors, explicit authoritative fields, live plan cards, and SSRF protection with a failure fallback.

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