B2B AI PlatformB2B AI Platform
Choosing AI Chatbot Integration
B2B AI Platform

Choosing AI Chatbot Integration

Emma RobertsWords by Emma Roberts

One route to AI chatbot integration buys the wiring from a vendor. The other builds the wiring and keeps the keys. The first course is a platform contract. You sign with a vendor whose connector library already speaks to your help desk or CRM, paste a script tag into the footer, and the assistant is answering in a fortnight, with the vendor holding the credentials and the upgrade path. The second course is an application contract. The chat interface can still come off the shelf, but identity checks, authorisation and every write into an order table sit in a service your own team manages, and the model proposes a tool call that your code then validates, authorises and executes.

Both courses are defensible, and the fork between them runs through three questions: which layer has the permissions, who repairs the connector when a CRM schema changes, and what the bot may do on the day a downstream system returns an error. The Refact's buyer's guide presents the third question to vendors bluntly: "what systems does this bot read and what does this bot write to, and what happens if these systems conflict with each other?" A vendor that answers the first two from a slide and skips the third is selling a widget.

The three routes into the systems that run the business

The native connector is a prebuilt, vendor-maintained link between the chat platform and a named system, configured in an admin panel and maintained by the vendor. HappyFox sets out the trade plainly: fast setup and fewer moving parts on one side, limited customisation beyond the features the vendor supports on the other.

The iPaaS bridge places a workflow builder such as Zapier or Make between the widget and your systems, triggered by events such as a ticket being created or a payment failing. Qualimero provides setup in one to three days without coding. HappyFox warns that the same route grows expensive and fragile as volume rises.

The owned service layer is a set of small, task-specific operations sitting behind your own authentication, called by the orchestration layer and logged by you. Riseup Labs says the equivalent is a custom interface with backend integration: full control over chatbot architecture and interface, at higher development time and cost.

Those three are the subjects of this page. Every section below gives each of them a value on the same attribute, so the decision rests on the attributes themselves.

Attributes that separate the routes, set side by side

Credential ownership, read scope, write scope, repair ownership and time to a live answer separate the three routes, and each route answers every row differently. Timings in the final row are Qualimero's, from its published comparison of integration approaches.

| What the row measures | Native connector | iPaaS bridge | Owned service layer | | Who holds the credentials | The vendor's tenant | The connected app, through its own authorisation | Your service, behind your own authentication | | Read scope | The records the vendor's existing integration already scopes | Whatever the workflow is pointed at | The fields named in your integration contract | | Write scope | Tickets, notes and contact fields the vendor's data model supports | Whatever the connected app's authorisation allows | The tasks in the contract, with confirmation on the ones that move money or entitlement | | Who repairs a broken schema | The vendor, on its release cycle, for the systems on its list | You, in the workflow editor | You, in the service you own | | Time to a live answer | Hours, once a supported system is connected | One to three days for a workflow | Two to four weeks for API work, longer where a data pipeline has to be built |

Read scope, write scope and the integration contract

Scope is fixed long before anyone asks about it, and the demo never shows it.

A native connector accesses the records the vendor's existing integration already scopes and writes the tickets, notes and contact fields the vendor's data model supports. That covers a great deal of support work. Qualimero places help desk and CRM connections at the second of its three integration levels, delivering context-aware answers and per-ticket memory, and the reach stops at the edge of the connector.

An iPaaS bridge accesses whatever the workflow is pointed at and writes whatever the connected app's authorisation allows. Its scope is legible in a workflow editor, which is a genuine advantage, and its fragility lives in the same place, because event design and retries belong to you.

The owned service layer accesses and updates the fields listed in an integration contract.

That contract is the document to write before a single connector is configured. It records the user group and source system, the fields the bot may read, the actions it may take, the authentication method and the confirmation rule, the failure and handoff path, the system owner and the success measure. Riseup Labs makes the same point from the build side, asking teams to keep chatbot access on controlled API layers and then apply authentication and permission controls on top. Written out, the contract is short enough to review in one meeting.

[
  { "task": "get_order_status", "reads": ["orders.status", "orders.carrier"],
    "writes": [], "auth": "signed_in_customer", "confirm": false, "on_failure": "handoff" },
  { "task": "create_support_ticket", "reads": ["customer.id"],
    "writes": ["tickets.new"], "auth": "signed_in_customer", "confirm": true, "on_failure": "queue" }
]

Two limit rules follow from it. Retrieval answers a question and a transactional action changes a record, so each needs its own entry with its own permissions. Refact notes that answering where an order is requires a live query against the order table, and that a paragraph retrieved from a policy document does a different job. Grounding has a second distinction. Riseup Labs notes that accuracy in most applications improves by connecting the chatbot to trusted sources such as documentation or policies, and that this work sits apart from training a model in the strict sense. QuickBlox notes that the word chatbot covers a fixed menu, a context-aware conversation and an autonomous agent, and that the label on its own tells you almost little about capability.

Where the permission limit actually lives

Permissions belong in application code and in the downstream service. Credentials live on the server. Retrieved pages and user messages arrive as untrusted input. Riseup Labs reaches the same place from the build side, setting authentication and permission controls on the API layer and logging every interaction for monitoring and debugging. A system prompt has no enforcement weight of its own, and an integration plan that leans on one is already broken.

A native connector moves the limit into the vendor's tenant. That is a reasonable trade while the actions stay read-only and the systems stay on the vendor's list. It becomes the wrong trade the moment a cancellation path must not inherit the permissions granted for a read-only status check. An iPaaS bridge inherits whatever the connected app's authorisation scope allows, so the limit ends up as tight as the integration chosen from a dropdown. The owned layer sets the limit in code you can review, which is where the confirmation step and the idempotency key on a booking are located.

HappyFox publishes the audit to run against whichever route you pick: what customer data the bot can read, what actions it can take, what always requires a human, how logs and transcripts are stored and who can access them, and which topics are blocked outright.

How each route ages, and whose backlog absorbs the decay

Integration decays, and the only real question is whose backlog contains the decay. Refact reports that the connector which worked in July can stop working by October as CRMs change structures and APIs change versions, and recommends a monthly reading of the twenty most-failed conversations alongside a quarterly check of every integration endpoint. Kaily's 2026 guide lists the failures that recur below that drift: API version conflicts, authentication failures and incompatible data structures.

A native connector absorbs the drift inside the vendor's release cycle, for the systems on the vendor's list. Qualimero's platform-native route is quick for exactly that reason, and constrained for the same one. An iPaaS bridge keeps the decay visible in an editor anyone can open, and grows expensive and fragile as volume rises. A service layer you possess keeps the decay visible and yours, which is the honest cost behind the control Riseup Labs explains.

Measuring the first month after go-live

Four measures decide whether the integration works, and they have to be read on the same weekly cycle: The bot's performance includes the share of conversations it handles without a human, the rate at which it hands off, the time to resolution, and the satisfaction score linked to the conversations it resolved. Read containment beside satisfaction, and treat a rising handoff rate as a signal about the knowledge base.

Refact warns that containment read on its own flatters a bot that is deflecting customers, and gives an example of a shop that cut its cost per ticket, watched volume fall, then watched reviews turn hostile while the dashboard reported success. Take the twenty conversations that failed hardest and tag where the intent was missed; push each tag into a flow, a training document or an escalation rule.

The same discipline applies whichever route you chose. What changes is who does the reading: the vendor, you in a workflow editor, or your own team against your own logs.

Interface behaviour, and how much of it each route lets you change

The NN/g study of real users working with site chatbots found that a bot reachable from one page only gets abandoned once the user navigates away, that a follow-up answer posted as a fresh message pushes the list the user was comparing out of view, and that suggested questions work better as clickable buttons than as text the user has to retype. Participants judged the bot on those details, and the details sit outside the model.

A native connector gives you the vendor's version of that behaviour and the vendor's roadmap for changing it. An iPaaS bridge provides the channel's rendering and few other features. The owned layer gives you presence on every page, prompt buttons that reflect the page the user is on, and detail that expands in place, at the cost of building and maintaining each of them.

This is where integration decisions become visible to the customer. A bot that vanishes at the point of purchase seems like an unfinished product, whichever architecture sits behind it.

Why the model is the swappable part

Orchestration, memory and the model connection are three separate things, and only the third one changes when a better model ships. GetStream's integration documentation shows a memory layer paired with the Vercel AI SDK or LangChain and swapped between OpenAI, Claude, Gemini, xAI or a custom model without changing the application logic.

Build the connection so the model can be replaced in a day. Keep prompts, retrieval configuration and tool schemas in your own repository. Keep the evaluation set that tells you whether the swap improved anything. A vendor-managed connector rarely allows that, and the constraint is worth pricing in at the point of purchase, because the model you integrate this quarter will not be the one you run next year.

Sources