# Vatio vs Chatbase: which one for your app's agent?

Choose Chatbase if you want an agent trained on your website, documents and Q&A in a no-code dashboard, deployed to many channels at once, with ready-made actions for services like Stripe, Calendly and Shopify. Choose Vatio if you're building an app with a coding agent and want an agent inside that app that acts for its signed-in users through your own API: your coding agent writes it in your app's project, Vatio runs it, and every reply your team reports becomes a test before you approve the next version. Both answer from your content, call your APIs and hand conversations to people. They differ in who builds the agent, where its configuration lives and how changes reach your users.

## What Chatbase is

Chatbase is a platform for conversational agents for customer experience: support, sales and guidance, across chat, email and voice. It says no code is required.

- **How it's built.** In the Chatbase dashboard: you create an agent, add sources, write instructions and deploy it. Sources are uploaded files, text snippets, website crawls, Q&A pairs, Notion pages and support tickets from Salesforce or Zendesk. Changes to sources apply within seconds, and websites and Notion pages can re-sync on a schedule.
- **Actions.** Ready-made actions include escalations, live chat, Shopify, Stripe, Cal.com, Calendly, lead and data collection, Slack and web search. A **custom action** is either a server action, which calls your API with the inputs the agent collects and returns the response to it, or a client action, whose code runs in the visitor's browser and is registered with `registerTools`. Each action has a **When to use** description, and procedures can run actions as steps.
- **How it reaches your users' data.** Identity verification takes a JWT your server signs with HS256 and the secret from the dashboard, with `user_id` or `sub` as the only required claim, passed to the widget with an `identify` call. Its fields create or update a contact, which custom actions and Stripe actions use.
- **Where it runs.** A chat bubble, an iframe, a hosted help page, iOS and Android SDKs, email, phone, Slack, WhatsApp, Messenger, Instagram, Zendesk, Salesforce, Shopify, WordPress and Zapier.
- **Handoff.** The Escalations action creates a ticket in a helpdesk you've connected (Chatbase's own, Zendesk, Salesforce, Intercom, Freshdesk, HubSpot and others), and Chatbase live chat hands the visitor to a person in real time.
- **Testing and improvement.** The Playground tries answers, and Compare runs the same message against several models. In Activity, you revise a wrong answer, and the revision is saved as a Q&A source the agent uses from then on.

## What Vatio is

Vatio is an agent for the app you're building, with a coding agent or an app builder. It has two steps. The fastest, from any chat: add the remote MCP server `https://vatio.ai/mcp` as a connector in Claude, ChatGPT or Cursor, sign in with a Vatio account and ask for the agent; it is created in a preview to try, and nothing reaches your users until you publish ([Vatio in Claude and ChatGPT](https://vatio.ai/docs/mcp)). To build the agent into the app's code: in the project run `npx @vatio-ai/skills`, then `/vatio-init`, and `/vatio-improve` daily. Your coding agent reads the app, asks what the code doesn't answer and writes the agent into your project: instructions in `vatio.yml`, tools that call your API, and knowledge entries, which you can review like the rest of your code.

Vatio runs the conversations in your app, through the web widget and the iOS, Android and Flutter SDKs. Your team follows them in the inbox and reports wrong replies. Each report with a note becomes a test: `/vatio-improve` prepares the fix, Vatio replays every reported case against preview, and you approve each publish.

## The main differences

| | Chatbase | Vatio |
|---|---|---|
| Who builds it, where it lives | You, in Chatbase's dashboard, without code | Your coding agent, as files in your app's project; Vatio hosts the conversations |
| Your users' own data | Server actions call your API; identity verification (an HS256 JWT) ties the user to a contact that actions use | Private tools forward the user's verified token to your API, which reads the user from it; a private tool can't take a user id |
| Testing and improvement | Playground and Compare; a revised answer becomes a Q&A source; changes apply within seconds | Reported replies become tests, replayed against preview; a version that breaks a case live passes isn't published unless you override it with `--force` |
| Channels | Website widget, help page, iOS and Android SDKs, email, phone, Slack, WhatsApp, Messenger, Instagram, Zendesk and more | Web widget and browser SDK, iOS, Android and Flutter SDKs; WhatsApp and Instagram |
| Human handoff | A ticket in a connected helpdesk, or live chat | A tool you declare calls your backend, which alerts whoever you choose with a link; they take over by replying in Vatio's inbox |

## When Chatbase is the better choice

- **You want an agent running from content you already have,** without opening a project or a coding agent.
- **Your answers live on your website or in Notion.** Chatbase crawls and re-syncs them; Vatio doesn't read websites, so what the agent needs goes into knowledge entries.
- **You need email, phone, Slack or Zendesk tickets,** or a WordPress or Shopify install. Vatio's channels are chat: your app, WhatsApp and Instagram, with replies in text.
- **You want ready-made actions** for Stripe, Calendly, Cal.com or Shopify, lead forms, or actions that run in the visitor's browser.
- **You want to compare and choose the model.** Vatio picks the model, the same one for every agent.
- **Handoffs should become tickets** in the helpdesk your team already uses, with no code of yours in between. In Vatio, your backend can open one with a link to the conversation, but your team answers from Vatio's inbox.

## When Vatio fits better

- **You're building an app with Claude Code, Cursor or Codex** and want the agent built the same way, from the app's project, in files you can review and roll back.
- **The agent acts for signed-in users** through your own API: their account, bookings or orders. Your backend signs a short-lived RS256 token, and Vatio holds only the public key, so it can check who someone is but never claim it.
- **A private tool can't take a user id as a parameter:** the deploy fails if one tries, so nobody can talk the agent into reading another user's data. Your API reads the user from the verified token.
- **You want a change tested before your users get it:** every reported reply is replayed against preview, and you approve each publish.
- **The agent belongs inside your app first,** in the widget or in your own UI with the iOS, Android and Flutter SDKs.

## Moving from Chatbase to Vatio

Start from a chat with the Vatio MCP server (`https://vatio.ai/mcp`), or in your app's project with `npx @vatio-ai/skills` and `/vatio-init`, and say you're moving from Chatbase. Then bring over what your Chatbase agent worked from:

1. **Sources into knowledge entries.** Export Q&A (one Excel file, which includes the answers you revised), text snippets (Markdown) and files (their extracted text) from Chatbase. Websites, Notion pages and tickets can't be exported, so copy what the agent needs from the original pages. Put it all in a folder in your project: vatio-init proposes knowledge from the docs, FAQs and policies it finds and writes one Markdown entry per topic.
2. **Instructions.** Your Chatbase instructions become the agent's `instructions` in `vatio.yml`, with the rules it must never break listed there.
3. **Actions into tools.** Each server custom action becomes a tool: one HTTP request to your API, described in YAML. A client action becomes an endpoint in your backend, because a Vatio tool runs on Vatio's servers. For Stripe, Calendly or Shopify, your backend talks to that service and the agent talks to your backend. Anything that needs branching or a second call goes into one endpoint that does the whole job.
4. **Identity.** Replace Chatbase's HS256 token with Vatio's: ask your coding agent to sign it in your backend with the private key from `vatio auth --new-key` (RS256, with `sub`, `aud` set to your workspace slug and `exp`) and pass it to the widget. On Supabase, an Edge Function can sign it. Any action input that was a user id or email for the user's own data goes away: the endpoint reads the user from the token.
5. **Handoff rules.** Write the situations your escalation action covered in the `when_to_use` of a tool that alerts your team. The tool calls your backend with a link to the conversation, your backend tells whoever should pick it up (a WhatsApp message, a Slack channel, an email or a ticket in your helpdesk), and whoever replies in the inbox takes the conversation over ([Human in the loop](https://vatio.ai/docs/handoff)).
6. **Run both.** Keep Chatbase answering while you try Vatio's preview. The chat in **Try the agent** in the inbox is a signed-out visitor, so to try account questions, ask your coding agent to put the preview's widget in a development build of your app and sign in as a test user. Flag each wrong reply with what should have happened and run `/vatio-improve` until the agent gets them right.
7. **Switch the widget.** Publish when you're ready, by telling your coding agent or running `vatio publish`. Create a publishable key that allows your domain (`vatio keys create publishable --origin https://yourapp.com`, or **Settings → API keys** in the inbox), and replace Chatbase's embed script with Vatio's script tag or `@vatio-ai/widget`. In a mobile app, swap the Chatbase SDK for Vatio's iOS, Android or Flutter SDK.

For step 3, a server action that checked an order, with an order number as its input, becomes `tools/order_status.yml`:

```yaml
description: Status of one of the signed-in user's orders.
when_to_use: The user asks where an order is. Ask for the order number if they did not give it.
parameters:
  type: object
  properties:
    order_number: { type: string }
  required: [order_number]
access: private
request:
  method: GET
  base_url: "$env.APP_API"
  path: /me/orders
  query:
    number: "$params.order_number"
  headers:
    Authorization: "Bearer $auth.token"
respond:
  data:
    order: "$.order"
```

Your endpoint verifies the token and looks the order up among that user's own. See [Tools](https://vatio.ai/docs/tools) and [Knowledge](https://vatio.ai/docs/knowledge).

From then on, the routine is daily: your team reports wrong replies in the inbox, you run `/vatio-improve`, review the tests on preview and approve the update ([Improve](https://vatio.ai/docs/improve)). WhatsApp and Instagram are on every plan ([Pricing](https://vatio.ai/pricing)).

Checked on 14 October 2026. Features and plans change: check Chatbase's own documentation, listed below, for what it offers today.

## Sources

- [Chatbase](https://www.chatbase.co/)
- [Welcome to Chatbase](https://www.chatbase.co/docs/user-guides/quick-start/introduction)
- [Build your first AI agent](https://www.chatbase.co/docs/user-guides/quick-start/your-first-agent)
- [Best practices](https://www.chatbase.co/docs/user-guides/quick-start/best-practices)
- [Data sources](https://www.chatbase.co/docs/user-guides/chatbot/data-sources)
- [Actions overview](https://www.chatbase.co/docs/user-guides/chatbot/actions/actions-overview)
- [Custom action](https://www.chatbase.co/docs/user-guides/chatbot/actions/custom-action)
- [Client-side custom actions](https://www.chatbase.co/docs/developer-guides/client-side-custom-actions)
- [Identity verification](https://www.chatbase.co/docs/developer-guides/identity-verification)
- [Channels](https://www.chatbase.co/docs/user-guides/chatbot/channels)
- [Escalations](https://www.chatbase.co/docs/user-guides/chatbot/actions/escalate-to-human)

## Frequently asked questions

### Should I use Chatbase or Vatio for my app's AI agent?

Chatbase fits when you want an agent trained on your website, files and Q&A in a no-code dashboard, deployed to many channels, with ready-made actions. Vatio fits when you're building an app with a coding agent and want an agent inside it that acts for signed-in users through your own API: your coding agent writes it in your app's project, and the replies your team reports become tests that every new version is checked against before you approve it.

### Can I move my Chatbase sources to Vatio?

Mostly. Chatbase exports Q&A as one Excel file, text snippets as Markdown and files as their extracted text; websites, Notion pages and tickets can't be exported, so take those from the original pages. Put the exports in a folder in your app's project and ask your coding agent to turn each topic into a Vatio knowledge entry. Vatio doesn't crawl websites, so pages become entries too.

### What happens to my Chatbase custom actions?

A server custom action maps to a Vatio tool: its name becomes the file name, When to use becomes when_to_use, its inputs become parameters and its endpoint becomes the request. An action that acted on the user's own data becomes a private tool that forwards the user's verified token. A client action that ran in the browser becomes an endpoint in your backend, because a Vatio tool is a request from Vatio's servers to your API.

### How does Vatio verify who the user is, compared with Chatbase?

Chatbase's identity verification takes a JWT your server signs with HS256 and the secret from its dashboard. Vatio takes a short-lived RS256 token your backend signs with the private key from vatio auth --new-key, and holds only the public key, so it can check a token but never create one.

### Does a change go live right away in Vatio, like in Chatbase?

No. In Chatbase, a source change applies within seconds. In Vatio, a change goes to preview first, where Vatio replays every reported case, and reaches your users when you approve the publish. Knowledge edits made in the inbox are the exception: they change live directly, and every edit is kept as a version you can go back to.

## Related guides

- [Knowledge](https://vatio.ai/docs/knowledge): What the agent answers from: Markdown entries, versioned and published with the agent.
- [Tools](https://vatio.ai/docs/tools): Give the agent your API as tools.
- [An AI chat for your web app or site](https://vatio.ai/docs/guides/ai-chat-widget-for-your-website): One script tag puts the agent in your web app or site, themed to your brand and able to recognize signed-in users.
- [Vatio vs Intercom Fin](https://vatio.ai/docs/guides/vatio-vs-intercom-fin): Fin is a support team's agent across helpdesk channels; Vatio's is built by your coding agent in your app. When each fits, and how to move.