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

Choose Botpress if you want a bot platform: a visual studio or a TypeScript project with its ADK, workflows, state and code inside the agent, many channels from its Hub, and its own helpdesk for the people who take over. 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 as configuration in your app's project, Vatio runs it, and every reply your team reports becomes a test before you approve the next version. Both host the agent, call your APIs, hand conversations to people and test changes before release. They differ in how much of the logic lives in the agent and how it knows the user.

## What Botpress is

Botpress is an AI agent platform for customer support, with three ways to build: **Studio**, a visual drag-and-drop builder; **Viber**, which builds, tests and launches an agent through conversation; and the **ADK**, a TypeScript framework for building agents from code. Agents run on Botpress Cloud.

- **In Studio.** A bot is workflows of nodes. An Autonomous Node uses a model to decide what to say and which tools to use, with its own instructions, tools, knowledge bases and variables, and you can override the model per node. An Execute Code card runs JavaScript in a node, calls APIs with Axios and reads secrets from configuration variables. Knowledge bases include tables for structured data.
- **With the ADK.** `adk init` scaffolds a project where conversations, workflows, tools, actions, tables, knowledge, triggers, custom webchat components and test files each live in their own file. `adk dev` runs it against your own development bot with a local Dev Console; `adk deploy` ships it to your production bot on Botpress Cloud.
- **How it reaches your users' data.** Your page can pass data about the current user to Webchat with `updateUser`, and a workflow or tool calls your API. For your own front end, the Chat API authenticates each user with a key you sign yourself as a JWT, with an encryption key you set.
- **Where it runs.** Webchat, as an embed code or a React library, and channel integrations from the Hub: WhatsApp, Messenger, Instagram, Telegram, Slack, Microsoft Teams, Discord, Viber and others.
- **Handoff.** New workspaces hand off to Botpress Desk, its helpdesk for monitoring conversations and stepping in; existing workspaces can keep the HITL integration and its dashboard of tickets.
- **Testing.** Studio's emulator shows what an Autonomous Node received, returned and tried. In the ADK, tests are `.eval.ts` files with assertions on the reply (text, pattern or a model's judgment), tool calls, state, workflows and timing, run with `adk evals`.

## 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

| | Botpress | Vatio |
|---|---|---|
| Who builds it, where it lives | You, in Studio or Viber, or as a TypeScript project with the ADK; Botpress Cloud runs it | Your coding agent, as configuration in your app's project; Vatio hosts the conversations |
| Your users' own data | The page passes user data to Webchat; workflows and tools call your API; the Chat API takes a user key you sign | 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 | The Studio emulator; test files with assertions in the ADK | 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 | Webchat and the Hub's channel integrations | Web widget and browser SDK, iOS, Android and Flutter SDKs; WhatsApp and Instagram |
| Human handoff | Botpress Desk, or the HITL integration | 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 Botpress is the better choice

- **You want the conversation's logic inside the agent:** workflows, state, triggers and custom code, in a visual builder or in TypeScript. In Vatio, each tool is one HTTP request, and branching lives in your backend.
- **You want custom components in the chat,** rendered from React in Webchat.
- **You need channels beyond chat in your app, WhatsApp and Instagram,** such as Telegram, Slack, Microsoft Teams or Discord.
- **You want to choose the model,** per node if needed. Vatio picks the model, the same one for every agent.
- **You want to write your own test assertions** on tool calls, state and timing, alongside the code.
- **Your support team wants a helpdesk** that comes with the agent platform.

## When Vatio fits better

- **You're building an app with Claude Code, Cursor or Codex** and want the agent in that app's project, next to the API its tools call, rather than in a second project to maintain.
- **The agent acts for signed-in users.** Your backend signs a short-lived RS256 token with a key Vatio never sees, so Vatio 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.
- **Tests come from the people reading conversations.** A supervisor reports a wrong reply and writes what should have happened, with no test file to write, and every such note is checked before you 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 Botpress 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 Botpress. Then bring over what your bot worked from:

1. **Knowledge into entries.** Gather the documents and tables your knowledge bases were built from; for websites, copy what the agent needs from the pages, since Vatio doesn't read websites. Put it 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.** An Autonomous Node's instructions, or the instructions your ADK code gives the model, become the agent's `instructions` in `vatio.yml`, with the rules it must never break listed there.
3. **Code into your backend, calls into tools.** An Execute Code card or an ADK tool that calls your API becomes a Vatio tool: one HTTP request, described in YAML, with its secrets set with `vatio secrets set`. Logic that branched, made a second call or computed a result moves into your backend, as one endpoint that does the whole job. Workflows that must always run the same way go there too.
4. **Identity.** Replace the user data your page passed to Webchat with a verified identity. Ask your coding agent to sign a token 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.
5. **Handoff rules.** Write the situations your bot handed off on 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, and whoever replies in the inbox takes the conversation over ([Human in the loop](https://vatio.ai/docs/handoff)).
6. **Run both, and carry your tests over.** Keep Botpress answering while you try Vatio's preview. The chat in **Try the agent** in the inbox is a signed-out visitor, so for 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. Have the conversations your tests covered, flag each wrong reply with what should have happened for `/vatio-improve`, and keep each one it gets right with `vatio test add`.
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 the Webchat embed with Vatio's script tag or `@vatio-ai/widget`. In a mobile app, use Vatio's iOS, Android or Flutter SDK.

For step 3, a code card that fetched a user's open tickets with Axios becomes `tools/my_tickets.yml`:

```yaml
description: The signed-in user's open support tickets and their status.
when_to_use: The user asks about a ticket or a request they opened.
access: private
request:
  method: GET
  base_url: "$env.APP_API"
  path: /me/tickets
  headers:
    Authorization: "Bearer $auth.token"
respond:
  data:
    tickets: "$.tickets"
```

There is no user id in it: your endpoint verifies the token and answers for that user. See [Tools](https://vatio.ai/docs/tools) and [Private tools](https://vatio.ai/docs/authentication/tools).

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 Botpress's own documentation, listed below, for what it offers today.

## Sources

- [Botpress](https://botpress.com/)
- [Botpress documentation](https://botpress.com/docs/)
- [Autonomous Node](https://botpress.com/docs/studio/concepts/nodes/autonomous-node/)
- [Execute Code](https://botpress.com/docs/studio/concepts/cards/execute-code/)
- [Studio emulator](https://botpress.com/academy-lesson/studio-ui-emulator)
- [Introduction to the ADK](https://botpress.com/docs/adk-v2/get-started/introduction/)
- [ADK CLI reference](https://botpress.com/docs/adk-v2/cli/cli-reference/)
- [Write and run evals](https://botpress.com/docs/adk-v2/testing/evals/)
- [Webchat methods reference](https://botpress.com/docs/webchat/interact/reference/)
- [Chat API introduction](https://botpress.com/docs/api-reference/chat-api/introduction/)
- [Botpress Hub](https://botpress.com/hub)
- [Integrations in Studio](https://botpress.com/docs/studio/concepts/integrations/)
- [Configure Human Handoff](https://botpress.com/docs/studio/get-started/manage-your-agent/human-handoff/)

## Frequently asked questions

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

Botpress fits when you want a bot platform: a visual studio or a TypeScript project with its ADK, workflows and state inside the agent, many channels from its Hub, and its own helpdesk. 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 as configuration in your app's project, and the replies your team reports become tests that every new version is checked against before you approve it.

### Botpress has a code-first ADK. How is Vatio different?

The ADK is a TypeScript framework: you write conversations, workflows, tools and actions as code in a project of their own, and Botpress hosts it. Vatio's agent is configuration in your app's project: vatio.yml, a YAML file per tool and Markdown knowledge entries. Each tool is one HTTP request to your API, so the logic stays in your backend and there is no agent code to maintain.

### How does a Vatio agent know which user it's talking to?

From your app's sign-in, verified by Vatio. Your backend signs a short-lived RS256 token with the key from vatio auth --new-key. Private tools forward that token to your API, which reads the user from it, and a private tool cannot take a user id as a parameter.

### Can I move my Botpress tests to Vatio?

Vatio's tests come from reported replies and vatio test add, not test files. Have the conversations your Botpress tests covered with Vatio's preview, and once a reply is right, keep it with vatio test add and a note on what it should do. Each one becomes a test that Vatio replays against every new version, and a version that breaks one live passes is not published unless you override it.

### Where do handoffs go in Vatio?

To whoever you choose. The agent asks for a person by calling a tool you declare, when a situation you described in its when_to_use applies or the user asks for one, and your backend alerts that person (a WhatsApp message, a Slack channel, an email) with a link to the conversation in Vatio's inbox. Whoever replies takes it over, from the inbox or from the WhatsApp Business or Instagram app; until then the agent keeps answering.

## Related guides

- [Tools](https://vatio.ai/docs/tools): Give the agent your API as tools.
- [Handoff](https://vatio.ai/docs/handoff): When the agent passes a conversation to your team.
- [Choosing how to build your app’s agent](https://vatio.ai/docs/guides/vatio-vs-frameworks-and-no-code): When an agent framework, a no-code builder or a runtime like Vatio is the right call.
- [Vatio vs Voiceflow](https://vatio.ai/docs/guides/vatio-vs-voiceflow): A platform for chat and voice agents, or an agent defined in your app's project. When each fits, and how to move.