Skip to content
AZCY

Customer conversations

AI that doesn't know your business makes things up.

DockAI

An AZCY platform.

An engineer reviews a tablet beside server equipment

An AI assistant that answers customers from your own information, admits when it doesn't know, and hands over to a person with the whole conversation intact.

Every organization that put a general-purpose AI in front of customers discovered the same thing in the same week: it sounds confident, and on the questions that matter it makes things up. The problem was never the AI. Nothing connected it to what the business actually knows.

The shape of it

What moves, and what happens to it.

  1. What you already know

    Your documents, your website, your FAQs, and your systems. The answers exist — they have just never been reachable from a conversation.

  2. Look it up, then answer

    The assistant finds the relevant passage in your material before it answers, shows where the answer came from, and takes a real action when the question needs one.

  3. The customer, or a person

    A reliable answer backed by your material, or an honest handover to a person who can see the whole conversation. Both are good outcomes. Guessing is not.

Capabilities

The parts that carry the argument.

  • No source, no answer

    If the assistant cannot point at where an answer comes from, it does not answer. That refusal is what makes it safe to put in front of customers.

  • Widget builder

    Brand colour, tone, and greeting, changed and previewed live. The people who own your brand voice do not need an engineer.

  • Actions, not just answers

    It does things — looks up an order, starts a return, books a slot — within limits you set explicitly, rather than describing how you could.

  • Handover with context

    When a person takes over, they get the whole conversation. The customer never repeats themselves, which is the thing everyone hates about the alternative.

  • Gap detection

    The questions it could not answer, reported. That list is the most useful thing the system produces — it is your documentation's to-do list, written by your customers.

  • One-line embed

    One line added to your website. Getting it onto the page is the easy part, and we treat it that way.

How it fits

Into what you already run.

Nothing here replaces a system that works. These are the questions that decide whether a platform can be deployed at all, so they are answered before the specification.

Integrations

  • Your site, via a one-line embed
  • Document stores and knowledge bases
  • Your APIs, as tools the assistant can call
  • Helpdesk and live-chat systems for handover

Deployment

  • Managed cloud
  • Single-tenant where the knowledge base is sensitive
  • Model choice per deployment, including in-region

Security and custody

  • Your content is never used to train a model
  • Tool permissions are explicit; the assistant can only do what it is granted
  • Every answer is traceable to the passage it came from
  • Conversation retention on your schedule

Specification

Design facts and stated targets. Nothing we have not measured.

Technical specification

Grounding

Method
Retrieval-augmented generation
Sources
Documents · Site crawl · FAQs · APIs
Answer policy
Grounded only — refuse when unsupported
Traceability
Every answer cites its passage

Actions

Model
Tool calling, explicitly permissioned
Handover
Full conversation context transferred
Guardrails
Enforced outside the model

Deployment

Embed
One line
Tenancy
Multi-tenant · Single-tenant
Training
Your content is never trained on
Retention
Operator-defined

The hard problem

Making a fluent model admit that it does not know.

In plain terms: this section is about how we stop the assistant from confidently telling your customers things that are not true. A language model's default behaviour is to produce a plausible answer. It has no internal signal that separates 'I retrieved this' from 'this sounds like the kind of thing that would be true', and the output looks identical either way. That is the whole risk: a wrong answer arrives with the same confidence as a right one, and the customer cannot tell. So the engineering problem in DockAI is not making it answer. It is making it refuse.

Refusal cannot be achieved by asking. A prompt that says 'only answer from the provided context' works most of the time, and most of the time is not a standard — it means the failure is rare, which means it is unmonitored, which means the first person to find it is a customer. So grounding is enforced structurally: the retrieval step runs first, and if nothing clears the relevance bar, the generation step is not reached. There is no path from an ungrounded question to an answer, because the path does not exist rather than because the model was asked not to take it.

That pushes the difficulty into retrieval, which is where it belongs and where it is tractable. Most RAG systems fail here quietly: chunk on a fixed token count and you cut a policy in half, so the passage answering the question is now two passages, each individually irrelevant. We chunk on the document's own structure, keep the heading path with the chunk so a fragment knows what it is a fragment of, and retrieve wider than we generate. The relevance threshold is then a real decision with a real cost, tuned per deployment against questions with known answers — and tuning it is how an organization chooses, explicitly, how often it would rather say nothing than risk being wrong.

Actions are the same argument with higher stakes. An assistant that answers wrongly costs trust; one that acts wrongly costs money. So tools are permissioned individually and split by consequence: reading an order status is not the same class of thing as issuing a refund, and the system does not let a persuasive conversation collapse that distinction. Anything with a consequence a customer cannot reverse routes to a person.

Handover was the last thing to get right and the most visible. An assistant that fails to a human who then asks 'how can I help you today' has wasted the customer's time twice. The transfer carries the conversation, the passages retrieved, and what the assistant already attempted — so the person opens with context rather than with a question the customer has already answered.

The unexpected outcome is that the refusals became the product's most valuable output. Every question the assistant could not ground is either a hole in the organization's documentation or a thing it has decided not to talk about. Collected and reported, that list is a to-do list written by customers — and organizations act on it in a way they never act on a generic content audit.

Questions

The ones we actually get asked.

  • What stops it from making things up?

    The way it is built. The assistant must find the answer in your material before it is allowed to respond. If it finds nothing solid, it says it does not know and offers a person. That is a designed outcome, not a failure.

  • Is our content used to train a model?

    No. Your content is looked up at the moment a question is asked, and it is never used to train an AI.

  • Can it do things, or only answer?

    It can call tools you define — look up an order, start a return, book a slot. Permissions are per tool, and anything with a consequence the customer cannot reverse routes to a person.

  • What happens when it doesn't know?

    It says so and hands over, carrying the whole conversation so the customer does not repeat themselves. The unanswered question is then reported to you, because it is usually telling you something about your documentation.

  • How long does it take to deploy?

    Adding it to your site takes minutes, and the widget is set up without an engineer. The real work is loading in your knowledge and tuning how cautious the assistant should be, tested against your own real questions — that is what determines whether it is any good, and it is worth doing properly.

We build systems like this for other organizations.

DockAI exists because we met the same operational failure enough times to engineer it properly. Yours is probably a different failure. That is the conversation we want, and you will have it with an engineer.