INTERNAL ONLY - not rendered anywhere. Provenance for the claims on this page.

path = repo file relative to sites/main; url = external link;

covers = the claim(s) it backs. (Distinct from the source: local key.)

---------------------------------------------------------------------------

sources:

-- Managed harness vs a framework you build, train & host (the Rasa anchor) --

• path: content/features/cloud-agent-harness.md covers: Managed cloud harness vs a self-built/hosted framework runtime; configure-not-program
• path: pages/landing/harness/index.jsx covers: Harness positioning - cloud control plane vs a runtime you operate
• path: pages/landing/platform/index.jsx covers: Platform / composable building-blocks positioning; LLM-native, no training pipeline
• path: pages/landing/agents/index.jsx covers: Agent capabilities, build-vs-buy framing

-- Data sovereignty without running the framework (rebut Rasa's core attack) --

• path: pages/landing/onprem/index.jsx covers: On-prem / private cloud / air-gapped, self-hosted models on your GPUs
• path: pages/landing/enterprise/index.jsx covers: Enterprise - multi-team RBAC, security stack, scale, deployment
• path: content/features/security.md covers: Encryption, SSO, workspace isolation, compliance
• path: content/features/data-residency.md covers: EU / regional data residency

-- Deterministic control & governance as configuration (rebut regulated-industry attack) --

• path: content/features/agentic-ai-blueprints.md covers: Blueprints - deterministic visual composition of agents/datasets/skillsets
• path: content/features/task-automation.md covers: Scheduled autonomous Tasks (cron) - deterministic repeatable paths
• path: content/features/policies.md covers: Guardrails / customer-controlled retention & usage policies (Policy API); no-training / zero-retention = platform data policy (no feature doc - confirm before asserting)
• path: content/features/pii-redaction.md covers: PII redaction with reversible tokens
• path: content/features/audit-trails-and-compliance.md covers: Audit trails and compliance controls
• path: content/features/retention-policies.md covers: Retention and usage policies with enforcement
• path: content/features/granular-access-control.md covers: Per-context access control; accounts/sub-accounts mirror org structure
• path: content/features/trace-debugging.md covers: Millisecond-precision trace debugger (inspectable, steerable autonomy)
• path: content/features/event-monitoring-and-analytics.md covers: Event monitoring and analytics
• path: content/features/performance-analytics.md covers: Performance analytics + token-level usage/cost tracking

-- No-code + code on one platform (vs Rasa Pro / Rasa Studio split) --

• path: content/features/community-hub.md covers: Community Hub - share/clone blueprints, skillsets, datasets, widgets
• path: content/features/api.md covers: Extensive REST API
• path: content/features/agent-sdk.md covers: SDKs (Node/React/Next/Python/Go), agent SDK - developer surface
• path: content/features/cli.md covers: CLI agent mode - local file/command access for coding agents
• path: content/features/terraform-provider.md covers: Terraform provider / infrastructure-as-code
• path: content/features/openai-compatible-api.md covers: OpenAI-compatible endpoint - portability / low lock-in

-- LLM-native, models, keys (vs NLU training + BYO models) --

• path: content/features/model-catalogue.md covers: Wide range of model providers, swappable per agent, own/self-licensed models
• path: content/features/bring-your-own-key.md covers: Bring your own model API keys
• path: content/features/oauth-secrets.md covers: Your own secrets, credentials, and OAuth connections

-- Channels & native channel depth (concede Rasa voice; ChatBotKit breadth) --

• path: content/features/realtime-voice.md covers: Realtime low-latency voice conversations
• path: content/features/twilio-integration.md covers: Telephony - inbound/outbound phone voice and SMS via Twilio
• path: content/features/ai-avatars.md covers: Lifelike real-time avatars (Rasa has voice but not avatars)
• path: content/features/recall-integration.md covers: Live meeting bots - Google Meet, Zoom, Microsoft Teams
• path: content/features/email-integration.md covers: Email agents
• path: content/features/whatsapp-integration.md covers: WhatsApp native channel
• path: content/features/slack-integration.md covers: Slack native channel (attachments, voice/video input)
• path: content/features/telegram-integration.md covers: Telegram native channel
• path: content/features/messenger-integration.md covers: Messenger native channel
• path: content/features/instagram-integration.md covers: Instagram native channel
• path: content/features/google-chat-integration.md covers: Google Chat native channel
• path: content/features/microsoft-teams-integration.md covers: Microsoft Teams native channel
• path: content/features/messaging-attachments.md covers: Attachment processing across channels
• path: content/features/vision-capabilities.md covers: Vision / image and video input
• path: content/features/inbox.md covers: Unified Inbox across channels and bots

-- Agent capabilities & tools (vs custom actions on an action server) --

• path: content/features/secure-code-execution.md covers: Secure code execution overview (Python/JS/shell)
• path: content/features/sandboxes.md covers: Isolated, ephemeral sandboxes; coding agents
• path: content/features/agent-skills.md covers: Portable drop-in skills for shell/CLI coding agents
• path: content/features/abilities-catalogue.md covers: Pre-built ability templates + custom abilities
• path: content/features/skillset.md covers: Skillsets - grouped abilities, dynamic install/uninstall mid-conversation
• path: content/features/agentic-sql.md covers: Agentic SQL over HubSpot / Postgres / CSV / Excel / JSON
• path: content/features/browser-automation.md covers: Headless browser automation
• path: content/features/web-search.md covers: Web search ability
• path: content/features/mcpserver-integration.md covers: MCP server - expose skillsets as MCP tools
• path: content/features/mcp-sdk-integration.md covers: MCP client - consume any MCP server

-- Knowledge / RAG / memory (vs Rasa Enterprise RAG, self-hosted) --

• path: content/features/datasets.md covers: Managed datasets, document processing, website crawling
• path: content/features/dataset-reranking.md covers: Second-pass reranking
• path: content/features/notion-integration.md covers: Notion sync
• path: content/features/memory-system.md covers: Persistent memory across sessions

-- Multi-agent & automation --

• path: content/features/multi-agent-orchestration.md covers: Multi-agent orchestration on the platform
• path: content/features/bot-to-bot-communication.md covers: Native bot-to-bot abilities
• path: content/features/spaces.md covers: Shared Spaces for persistent knowledge
• path: content/features/webhooks.md covers: Webhooks and triggers for automation

-- Application layer, portals, multi-tenancy, white-label --

• path: content/features/app-platform.md covers: App Platform - Chat, Inbox, Connect, Task, Trace, Usage
• path: content/features/connect.md covers: Connect - managed third-party integrations
• path: content/features/portals.md covers: Portals - white-labeled custom-domain app deployment
• path: content/features/partner-api.md covers: Partner API, parent-child sub-accounts, account isolation, reselling
• path: content/features/team-management.md covers: Teams - built-in collaboration across bots, datasets, automations
• path: pages/landing/whitelabel/index.jsx covers: White-label / resell positioning (native multi-tenancy Rasa lacks)

-- Pricing (flexibility claim only; numbers intentionally NOT rendered) --

• path: config/subscriptions.yaml covers: Tiers exist (free -> self-serve -> enterprise); keep page generic, no numbers
• path: config/limits.yaml covers: Per-plan limits behind the tiers

-- Rasa (external) - re-verify competitor claims on each review --

• url: https://rasa.com covers: Rasa positioning - "developer platform for enterprise AI agents"; CALM, Studio, Voice, Enterprise RAG, Orchestration, MCP; self-host/private/air-gapped
• url: https://rasa.com/docs/pro/intro/ covers: Rasa Pro / CALM / Developer Edition; CALM can run fully on-premise with no external LLM calls
• url: https://rasa.com/docs/pro/installation/licensing/ covers: License key (RASA_LICENSE) required; free Developer Edition license - re-verify
• url: https://rasa.com/developer-terms covers: Developer Edition terms - conversation-volume cap (structural, no numbers on page)
• url: https://rasa.com/pricing covers: Rasa Growth/Enterprise commercial tiers - verify structural cost framing, no numbers on page
• url: https://github.com/RasaHQ/rasa covers: Classic Rasa Open Source - Apache-2.0, in maintenance mode; direction is CALM/Hello Rasa
• url: https://github.com/RasaHQ/rasa/blob/main/LICENSE.txt covers: Apache 2.0 license for classic Rasa Open Source (re-verify path on each review)
• url: https://rasa.com/blog/best-voiceflow-alternatives covers: Rasa self-positioning + attacks - deterministic control, data ownership, regulated industries, lock-in, "production is fragile"; lead-gen targets (Voiceflow, Botpress, Kore.ai, Retell, Vapi, Synthflow, Decagon, Bland, ManyChat)
• url: https://rasa.com/blog/rasa-vs-dialogflow covers: Rasa vs Dialogflow - data sovereignty / self-host framing; migration reasons; new target Dialogflow CX date: Wed, Jul 8, 2026, 12:00 AM source: local

If you are weighing a Rasa alternative, you are building a conversational AI agent - something that understands a request, follows your business logic, and takes a real action - and the open question is how much of the machinery you want to own. ChatBotKit and Rasa both get you to that agent. Both ground it in your knowledge, run your logic, connect a range of model providers, and reach it through voice as well as text.

The difference is the operating model. Rasa is a developer framework: you author flows and business rules in code, write custom actions, build a dialogue model, and then host and keep alive the whole runtime - model server, action server, and the cluster underneath - on your own infrastructure. That is the price of its greatest strength, which is control. ChatBotKit is a managed, LLM-native platform: you configure an agent - its backstory, knowledge, abilities, and channels - and it runs on a cloud harness you never stand up. There is no framework to build, no model to train, and nothing to operate. Both can be deployed inside your own perimeter, and both can be deterministic where it counts - so this is not open versus closed, or control versus none. It is a framework you run yourself versus a platform that is already running. What follows is an honest read on where each one fits.

What Rasa Does Well

Rasa is a serious, developer-minded platform for building conversational agents, and its strengths are genuine:

• Open-source foundations - the classic Rasa Open Source framework is Apache-2.0, free to read, fork, and run (now in maintenance mode as the platform moves to CALM).
• Deep, code-level control - full access to prompts, policies, flows, and the underlying code, with the freedom to extend or replace any module without waiting on a vendor roadmap.
• Data ownership by design - self-host on your own infrastructure, a private cloud, or a fully offline, air-gapped environment; Rasa hosts none of your data, and CALM can run with no calls to external models.
• Mature dialogue management - a patented approach and an Orchestrator that pair guided, deterministic control with autonomous reasoning, a real fit for regulated, high-stakes conversations.
• Built-in voice - real-time voice as part of the platform, not only text - something many chat-only tools lack.
• A modern LLM path - CALM shifts dialogue understanding onto language models, easing the old intent-labelling and NLU-training burden.

If you have the engineering and ML capacity to build and run it, and owning the whole stack down to the source is the point, Rasa is a capable framework.

Where ChatBotKit Is Different

You can stand up a strong conversational agent on either side. The differences below decide how much you build, train, and operate versus how much is already running when you arrive.

No Framework to Train, Host, or Run

Start with what each product asks of you. A Rasa project is a framework you operate: you write flows and a domain, code custom actions and stand up an action server, run a build step to produce a dialogue model, and then host the model server, the action server, and the stores and brokers around them on your own Docker or Kubernetes - and keep all of it patched and upgraded. That is the work behind the control. ChatBotKit takes it off the table entirely. You configure an agent rather than program, train, and deploy one, and it executes on a managed cloud harness you never provision. There is no training pipeline to run, no action server to keep alive, no cluster to scale, and no upgrade treadmill. The engineering goes into the agent's behavior, not into the plumbing beneath it.

Own Your Data Without Owning the Operations

Rasa's sharpest argument is sovereignty: for banking, healthcare, or government, the data has to stay in your environment, so - it concludes - you must self-host the framework. The requirement is real; the conclusion is not the only option. ChatBotKit deploys the managed platform inside your perimeter: your own cloud account (an AWS, Azure, or GCP VPC under your IAM), a private data center, or a fully air-gapped network, paired with self-hosted models on your own GPUs and your own model keys. Your data never crosses your boundary, ChatBotKit does not train on it, and it opts into zero data retention with the providers it calls, while retention and usage policies decide how long records live and when they are purged. You get the sovereignty Rasa sells without adopting an open-source project to build, secure, and operate - the platform stays managed and supported whether it runs in our cloud or yours.

Deterministic Control That Is Not a Coding Project

Rasa's other core pitch is architectural governance - precise, deterministic control over what the agent says and does, which it argues you get by owning the code and its policies. Determinism matters, especially in regulated flows, and you do not have to build and host a framework to have it. On ChatBotKit, Blueprints and Tasks lay down fixed, repeatable paths; guardrails, structured abilities, and policies hold behavior inside the lines; PII redaction with reversible tokens shields sensitive data; and full tracing, a millisecond-precision trace debugger, and event monitoring make every decision inspectable and correctable. When the work is open-ended instead, the autonomous agent handles the cases you never scripted. Here control is configuration, not a codebase you have to maintain, secure, and keep current.

No-Code and Code on the Same Agent

Rasa keeps its two audiences on opposite sides of a line: Rasa Pro is the pro-code framework for engineers, and Rasa Studio is a separate no-code interface built on top for business users. ChatBotKit puts both on one artifact. Build code-free in a dashboard and a visual Blueprint Designer - wiring agents, datasets, skillsets, and abilities into a working system, with a Community Hub of templates to start from - then reach the very same agents through an API and SDKs for Node, React, Next, Python, and Go, a CLI, a Terraform provider, and an OpenAI-compatible endpoint. A business user and an engineer collaborate on a single agent, not on a UI layered over a framework and the framework beneath it.

LLM-Native From the Start, No Legacy Pipeline Beneath

Rasa is moving to language-model-driven dialogue with CALM, which is the right direction - but it arrives on top of years of intent-based NLU machinery, and the open-source framework under it is now in maintenance mode. ChatBotKit was built managed and LLM-native from the outset: there are no intents to label, no NLU model to train, and no legacy pipeline to carry forward. You give an agent a backstory, knowledge, and abilities, choose from a wide range of model providers, and swap the model behind any agent without retraining anything. And nothing about the choice is a one-way door - an OpenAI-compatible endpoint and SDKs keep your code portable, your knowledge and configuration export cleanly, and our team helps you move data in or out.

Every Channel, Managed - Voice Included

Give Rasa its due: it ships built-in voice, which most chat tools cannot claim. ChatBotKit matches voice and widens the surface. One agent configuration reaches an embeddable web widget, WhatsApp, Slack, Telegram, Messenger, Instagram, Google Chat, Microsoft Teams, email, and SMS and phone-call voice via Twilio, plus low-latency realtime voice, lifelike avatars that give an agent a face and presence, and bots that join live Zoom, Google Meet, and Microsoft Teams meetings - with every conversation, spoken or typed, flowing into a single Inbox. The channels carry depth as well: file attachments, native voice and video input, and email agents you define. On Rasa each connector is a component you wire, host, and maintain; here they are managed channels you switch on.

More Than a Conversational Assistant

Rasa is optimized around one shape: the conversational agent for text and voice. ChatBotKit treats "agent" as an open category driven by a single configuration. From the same knowledge and abilities you can stand up support and sales agents, coding agents that run in your shell or CI with local file and command access, voice and telephony systems that hold live calls, avatars with a presence, research agents, and form-fillers. Agents take real action through a secure code sandbox, agentic SQL over your data, a headless browser, web search, and both sides of MCP - consuming any MCP server and publishing your own skillsets as MCP tools for outside clients to call. Rasa connects agents to tools and APIs, including through MCP as a client; here MCP runs in both directions and the sandbox is the agent's own.

An App Layer and Branded Portals

Rasa hands engineers a framework and business users Studio, but the product around the agent - the interface, sign-in, admin, tenant isolation, per-client billing - is still yours to build. ChatBotKit ships that layer as ready-made applications teams use daily: Chat, a hub for multi-agent conversations; Inbox, one place to work every conversation across channels and bots; Connect, managed third-party integrations; and Task, scheduled autonomous runs - with Trace and Usage alongside for debugging and spend. Fold any of them into a Portal - a branded site on your own domain with its own user access - and hand it to a department, a client, or the whole company. And the Partner API provisions isolated parent-child sub-accounts, each with its own data, members, limits, and billing, so an enterprise can map that isolation onto its own org chart, and an agency can white-label and resell agents as a product line.

What Ships With the Platform

Everything you would build and operate around a Rasa deployment - the agent, the knowledge, the tools, the governance - is already running here. This is what comes standard with ChatBotKit.

Agents That Take Real Actions

• A library of ability templates plus custom API abilities, grouped into skillsets an agent installs and removes itself as a conversation moves.
• A code sandbox where agents run Python, JavaScript, and shell in isolated, single-use environments with no line to your infrastructure - no action server to host.
• Agentic SQL that answers plain-language questions over HubSpot, Supabase/PostgreSQL, and CSV, Excel, or JSON files.
• Headless browser control, web search, vision, image and video generation, and audio and video transcription.

Managed Knowledge (RAG)

• Semantic datasets built from PDFs, Word files, and spreadsheets, sharpened by second-pass reranking, kept current with JavaScript-aware site crawling and live Notion sync - and no vector database for you to operate.
• Durable memory that follows a conversation across sessions - scoped to a contact, tied to a bot, or shared - and retrievable by meaning.

Multi-Agent and Automation, on the Platform

• Native bot-to-bot abilities, visual Blueprints that compose agents, datasets, and skillsets into systems, shared Spaces for common knowledge, and cron-scheduled autonomous Tasks with webhooks and triggers - no separate orchestration runtime to run.
• A Community Hub for publishing and cloning blueprints, skillsets, datasets, and widgets.

Governance, Cost, and Observability

• SSO, granular access control, PII redaction, audit trails, EU data residency, and enforced retention and usage policies - part of the platform, not a project you staff.
• End-to-end visibility: performance analytics, token-level usage and cost tracking, event monitoring, and a trace debugger accurate to the millisecond.

Both Sides of MCP

• Call any MCP server from an agent, and publish your own skillsets as MCP tools for external clients - Claude Desktop, IDEs, custom apps - to consume.

ChatBotKit vs Rasa at a Glance

Pricing: What You Pay, and What You Also Run

With a framework, the license is only part of the bill - so the honest comparison is about shape, not numbers.

Rasa's Developer Edition is free to run, but it is gated by a license key and capped by conversation volume, with commercial Growth and Enterprise tiers above it for scale and support. Underneath any of them, you still fund the servers, the GPUs, the storage, and the engineering and ML time to build, train, secure, and operate the framework. "Free to start" describes the license, not the cost of running it in production.

ChatBotKit prices the whole managed stack as one thing. Begin free, move onto self-serve plans that scale with your usage, and reach for full enterprise options - on-prem and air-gapped included - only when you genuinely need them, with governance and observability part of the platform rather than a separate project. Models, RAG, sandboxes, every channel, and security come with no infrastructure to stand up and no framework to keep alive. Both vendors change pricing, so confirm the current terms directly.

Choose Rasa If

• You want to own and operate the entire stack in code - prompts, policies, flows, and infrastructure - and have the engineers and ML capacity to run it.
• Self-hosting for data sovereignty is a firm requirement and running the framework yourself is acceptable.
• You want deep, code-level governance over regulated conversations and the freedom to replace any module without a vendor roadmap.
• Your team is standing on open-source foundations and wants maximum control down to the source.

Choose ChatBotKit If

• You want a managed, LLM-native platform with no framework to build, train, host, or operate.
• You need data sovereignty - on-prem, your own cloud, or air-gapped - but do not want to run an open-source project to get it.
• You want deterministic control, governance, and full tracing as configuration, not a codebase to maintain.
• You want one agent across every channel - web, WhatsApp, Slack, email, and voice - managed, in a single Inbox.
• You want no-code and code on the same agents, not a pro-code framework plus a separate no-code UI.

Moving from Rasa to ChatBotKit

Bring your knowledge sources into a dataset, then re-express your flows and custom actions as an agent - a backstory plus abilities, in the dashboard, the visual Blueprint Designer, or the SDK for your stack. The flows that must run in a fixed order become Blueprints and Tasks; the intent-and-action wiring becomes the agent's own judgment, watched through the trace debugger. Reconnect the tools it needs, publish to the channels your users are on - keeping voice and adding avatars or a portal when you want them - and there is nothing underneath to train, provision, or patch.

Summary

Rasa and ChatBotKit build the same thing - conversational AI agents grounded in your knowledge, logic, and tools - but they ask for very different commitments. Rasa hands you a framework to author, train, host, and operate, with deep control and genuine data ownership as the reward for running it yourself. ChatBotKit hands you a managed, LLM-native platform where that agent is already running: deployable across every channel, deterministic where you need it, governed and observable by default, and able to live inside your own perimeter - with no pipeline to train and no servers to keep alive. If owning the whole stack down to the code is the goal, Rasa earns it. If you want the control, the sovereignty, and the reach without operating the machinery, ChatBotKit is where that agent runs.