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:

-- Self-serve on-ramp: build it yourself, no-code or with code --

• path: pages/landing/free/index.jsx covers: Free / self-serve start - sign up and build immediately (vs sales-led)
• path: pages/landing/platform/index.jsx covers: Platform / composable building-blocks positioning
• path: pages/landing/agents/index.jsx covers: Agent capabilities, build-it-yourself framing
• path: content/features/agentic-ai-blueprints.md covers: Blueprints - visual no-code composition of agents/datasets/skillsets
• path: content/features/app-platform.md covers: App Platform - Chat, Inbox, Connect, Task, Trace, Usage; Portals
• path: content/features/ai-playground.md covers: Playground for building and testing agents before shipping

-- Own it / portability / low lock-in --

• path: content/features/agent-sdk.md covers: SDKs (Node/React/Next/Python/Go), agent SDK - export/build in code
• path: content/features/api.md covers: Extensive API - move data and agents in and out
• path: content/features/openai-compatible-api.md covers: OpenAI-compatible endpoint - portability / low lock-in
• path: content/features/terraform-provider.md covers: Terraform provider / infrastructure-as-code

-- Every kind of agent, not only customer service --

• 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/cli.md covers: CLI agent mode - local file/command access for coding agents
• path: content/features/abilities-catalogue.md covers: Pre-built ability templates + custom abilities
• path: content/features/browser-automation.md covers: Headless browser automation
• path: content/features/web-search.md covers: Web search ability
• path: content/features/realtime-voice.md covers: Realtime low-latency voice conversations
• path: content/features/twilio-integration.md covers: Telephony - SMS and phone-call voice via Twilio
• path: content/features/ai-avatars.md covers: Lifelike real-time avatars
• path: content/features/recall-integration.md covers: Live meeting bots - Google Meet, Zoom, Microsoft Teams

-- Models, keys, connections --

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

-- Managed by default, or in your own perimeter (Sierra = managed service) --

• path: content/features/cloud-agent-harness.md covers: Managed cloud harness; managed in our cloud or yours
• path: pages/landing/onprem/index.jsx covers: On-prem / private cloud / air-gapped, bring-your-own-models
• path: pages/landing/enterprise/index.jsx covers: Enterprise - multi-team RBAC, security stack, scale, deployment
• path: content/features/data-residency.md covers: EU / regional data residency

-- Channels & native channel features --

• 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/email-integration.md covers: Email agents
• path: content/features/messaging-attachments.md covers: Attachment processing across channels
• path: content/features/vision-capabilities.md covers: Vision / image input
• path: pages/landing/messaging/index.jsx covers: Multi-channel messaging / deploy-everywhere positioning

-- Knowledge / RAG / memory --

• 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/website-import.md covers: Website crawling/import into datasets
• path: content/features/notion-integration.md covers: Notion sync
• path: content/features/memory-system.md covers: Persistent memory across sessions
• path: content/features/agentic-sql.md covers: Agentic SQL over HubSpot / Postgres / CSV / Excel / JSON

-- 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/task-automation.md covers: Scheduled autonomous Tasks (cron)
• path: content/features/webhooks.md covers: Webhooks and triggers for automation
• path: content/features/community-hub.md covers: Community Hub - share/clone blueprints, skillsets, datasets, widgets

-- White-label, portals, multi-tenancy, apps --

• 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: content/features/granular-access-control.md covers: Per-context access control; accounts/sub-accounts mirror org structure
• path: content/features/inbox.md covers: Inbox - unified conversation management across channels and bots
• path: content/features/connect.md covers: Connect - managed third-party integrations
• path: pages/landing/whitelabel/index.jsx covers: White-label / resell positioning

-- MCP (both sides) --

• 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

-- Security, compliance, cost, observability (built-in, you operate) --

• path: content/features/pii-redaction.md covers: PII redaction with reversible tokens
• path: content/features/security.md covers: Encryption, SSO, workspace isolation, compliance
• 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/policies.md covers: Customer-controlled retention/deletion (Policy API); no-training / zero-retention = platform data policy (no feature doc - confirm before asserting)
• path: content/features/trace-debugging.md covers: Millisecond-precision trace debugger
• path: content/features/performance-analytics.md covers: Performance analytics + token-level usage/cost tracking
• path: content/features/event-monitoring-and-analytics.md covers: Event monitoring and analytics

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

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

• url: https://sierra.ai covers: Sierra positioning - "Agent OS" for customer-experience agents; enterprise customers; channels (chat, voice, SMS, WhatsApp, email); compliance posture
• url: https://sierra.ai/platform covers: Agent SDK, Agent Studio (no-code), Ghostwriter, simulations/QA, contact-center handoff; developer + white-glove delivery
• url: https://sierra.ai/about covers: Founders Bret Taylor and Clay Bavor; mission - customer experiences with AI; enterprise CX focus
• url: https://sierra.ai/resources/podcasts/bret-taylor-of-sierra-on-ai-agents-outcome-based-pricing-and-the-openai-board covers: Outcome-based pricing model (pay on resolution, escalation free); enterprise-negotiated. Numbers intentionally NOT rendered on page date: Wed, Jul 8, 2026, 12:00 AM source: local

If you are weighing a Sierra alternative, you are building customer-facing AI agents - ones that hold real conversations, take action, and answer to real governance - and you want the right way to get there. ChatBotKit and Sierra both produce that outcome. Each grounds an agent in your knowledge, gives it tools and actions, reaches people across channels, and wraps the result in enterprise controls.

The deeper difference is how the work gets done. Sierra is a done-for-you enterprise engagement: you partner with Sierra's team through a sales-led process, they help you design, build, test, and continuously optimize a customer-experience agent, and you pay on an outcome-based model tied to the conversations it resolves. That high-touch, managed delivery is a genuine strength for enterprises that want a vendor accountable for the result. ChatBotKit is the other shape: a self-serve platform you build on yourself. Start free, build the agent no-code or with the API and SDKs, keep control of every part of it, choose the model and bring your own keys, deploy across web, messaging, and voice, run it managed or inside your own walls. Sierra delivers you an agent; ChatBotKit hands you the platform to build and own one. This is an honest look at where each fits.

What Sierra Does Well

Sierra is a serious enterprise customer-experience platform, and its strengths are real:

• White-glove, managed delivery - Sierra's team partners with you to design, build, test, and continuously optimize your agent, so you are not doing it alone.
• Outcome-based commercial model - broadly, you pay when the agent resolves an issue and not when it escalates, which aligns spend with the value delivered.
• Proven at enterprise scale - Sierra runs customer-service agents for large, high-stakes brands, with deep customer-experience expertise behind the delivery.
• Strong leadership and brand - founded by Bret Taylor and Clay Bavor, with a clear point of view on where enterprise agents are heading.
• Purpose-built CX tooling - drafting agents from your procedures and transcripts, a studio for the CX team, simulations and quality checks, monitoring and experiments, and contact-center handoff.
• A strong enterprise compliance posture - a broad set of certifications and controls suited to regulated customer-service work.

If you are a large enterprise that wants a partner to build and run a polished customer-experience agent for you, that managed, outcome-aligned approach is hard to fault.

Where ChatBotKit Is Different

You can end up with a capable agent either way. The differences below matter once you would rather build and own the agent yourself than have it built and run for you.

Sign Up and Start, Not Scope and Wait

This is the root distinction. Sierra is reached through a sales-led engagement - you talk to its team, scope the work, and they deliver an agent for your organization. ChatBotKit is a product you sign up for and use immediately. There is a free way to start, so you can create an account and have a working agent the same afternoon - no scoping call, no statement of work, no delivery timeline to wait on. You try ideas, ship the ones that work, and change them the moment you want to, on your own schedule rather than a vendor's project plan. For teams that would rather move than negotiate, that on-ramp is the whole difference.

You Build It, and You Keep It

With a done-for-you model, the expertise and the day-to-day operation live largely with the vendor's delivery team. On ChatBotKit you build the agent, which means its configuration, knowledge, and behavior stay with you. That is not the same as being unsupported: you get a no-code visual Blueprint Designer, thorough documentation, a full API and SDKs, and enterprise support and hands-on migration help when you want it. But because you author the agent, you can revise a backstory, add an ability, or swap a model without opening a ticket and waiting - and if you ever leave, you leave with the agent, not just the memory of one. Your knowledge, conversations, and configuration export through the API and SDKs, and an OpenAI-compatible endpoint keeps your code off any single proprietary interface.

Any Kind of Agent, Not Only Customer Service

Sierra concentrates on customer-experience and support agents, and it is very good in that lane. ChatBotKit treats agent as an open category. From one configuration - a single body of knowledge and set of abilities - you can build support agents, coding agents that operate in your shell or CI with local file and command access, realtime voice and telephony systems that hold live phone calls over Twilio, lifelike avatars that give an agent a face and presence, research agents, form-fillers, and internal copilots. The agent reaches its tools through pre-built ability templates, custom API abilities, secure code sandboxes, a headless browser, web search, and both sides of MCP. Customer service is one thing you can build here, not the boundary of the platform.

Pick the Model and Bring the Keys

Sierra runs the model layer for you as part of its managed service - simpler, but a step removed from your control. ChatBotKit keeps that layer in your hands. Span a wide range of providers, swap the model behind any agent without rebuilding it, and pair the catalogue with your own fine-tuned or self-licensed models. Bring your own API keys so calls bill to your provider accounts at your rates, store your own secrets, and set up your own OAuth connections to the services your agents reach, so integrations run under your apps and permissions. The model and the credentials are choices you make and pay for directly.

Managed for You, or Run Inside Your Walls

Sierra is delivered as a managed service, which suits its outcome-based model - but hosting it inside your own boundary is not part of the arrangement. ChatBotKit is managed by default - orchestration, retrieval, sandboxed code, and every channel run on our harness, so your team ships instead of tending infrastructure - but when data must stay inside your perimeter, you have somewhere to go. Deploy into your own cloud account (an AWS, Azure, or GCP VPC under your IAM), a private data center, or a fully air-gapped network with self-hosted models on your GPUs, and add EU data residency on the managed cloud. Your data stays in your perimeter, you hold the keys, and it remains a supported product wherever it runs.

Ready-to-Use Apps, Not Only a Builder

Sierra delivers you a finished agent; ChatBotKit hands you a platform - and with it a set of ready-to-use applications rather than only a builder. Chat is a hub for multi-agent conversations; Inbox puts every conversation across channels and bots in one place; Connect manages third-party integrations; and Task runs scheduled autonomous work. Each can be wrapped in a branded Portal on your own custom domain and handed to a department, a client, or the whole company. The same multi-tenant fabric - isolated sub-accounts with their own data, members, limits, and billing through the Partner API - maps just as cleanly onto your own org chart, and lets an agency or platform white-label and resell agents under its own brand.

Everything a Production Agent Needs, the Moment You Sign Up

A capable customer-service agent is one thing you can build here - and you get the rest of a production platform without a services engagement to unlock it. This is what comes standard with ChatBotKit.

Tools and Real Actions

• Pre-built ability templates and custom API abilities, grouped into skillsets an agent switches on and off itself mid-conversation.
• A secure code sandbox running Python, JavaScript, and shell in isolated, single-use environments with no reach into your systems.
• Agentic SQL that answers plain-language questions over HubSpot, Supabase/PostgreSQL, and CSV, Excel, or JSON files.
• Headless browsing, web search, vision, image and video generation, and audio and video transcription.

Knowledge You Own (RAG)

• Semantic datasets built from PDFs, Word files, and spreadsheets, refined with second-pass reranking, extended by JavaScript-aware website crawling and live Notion sync - and no vector database for you to run.
• Durable memory that carries a conversation across sessions - per contact, per bot, or shared - and searchable by meaning.

Multi-Agent and Automation

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

Governance, Cost, and Observability - Yours to Operate

• PII redaction with reversible tokens, audit trails, SSO, granular access control, and enforced retention and usage policies - on every plan.
• Full visibility - performance analytics, token-level usage and cost tracking, event monitoring, and a millisecond-precision trace debugger to see exactly what an agent did and why.

Both Sides of MCP

• Reach any MCP server from inside an agent, and publish your own skillsets as MCP tools for outside clients - Claude Desktop, IDEs, your own software - to consume.

ChatBotKit vs Sierra at a Glance

Pricing: Self-Serve and Transparent, Not Only an Outcome Contract

The engagement difference shows up plainly in how you pay.

Sierra is known for outcome-based pricing - broadly, you pay when the agent resolves a customer's issue and not when it escalates to a person. That is an appealing idea: it aligns spend with realized value and puts the vendor on the hook for results. The trade-off is that it is negotiated per enterprise, bundled with a managed engagement, with no public self-serve plan or free way to simply try it. Sierra sets its own terms and changes them over time, so confirm the current model directly.

ChatBotKit is priced to stand on its own and to start small. There is a free way to begin, self-serve plans that scale with your usage, and full enterprise options - including on-prem and air-gapped deployment, plus multi-tenancy - only when you actually need them. The whole managed stack - models, knowledge, sandboxes, every channel, governance, and observability - is one platform, and you bring your own model keys so provider usage bills to your accounts at your rates. Prices move on both sides, so check the current plans directly. Easy to start, and yours to grow.

Choose Sierra If

• You are a large enterprise that wants a partner to design, build, test, and run a customer-experience agent for you.
• You prefer an outcome-based commercial model where you pay for resolved conversations.
• Your primary need is polished customer service delivered white-glove, with a vendor accountable for the result.
• You would rather have a managed team carry the operational load than build and run the agent in-house.

Choose ChatBotKit If

• You want to start today - a free, self-serve on-ramp - and build the agent yourself, no-code or with the API and SDKs.
• You want to own and export your agent and change it whenever you want, without waiting on a delivery team.
• You want to build more than customer service - support bots, voice systems, coding agents, avatars, and research agents.
• You want to bring any model and your own keys, so usage bills to your own provider accounts at your rates.
• You need to run in your own perimeter - your cloud account, a private data center, or fully air-gapped.
• You want transparent, self-serve pricing rather than a negotiated enterprise outcome contract.

Moving from Sierra to ChatBotKit

Bring your knowledge sources into a dataset, re-express what your Sierra agent does as a backstory and abilities - in the dashboard, the visual Blueprint Designer, or the SDK that fits your stack - reconnect the systems it needs through your own OAuth connections and MCP, and deploy it to the channels your users are on. Test it in the playground, watch it in the trace debugger, and ship when you are ready. Because you build and own the agent, there is no delivery team to route each change through - and if some processes should stay where they are, let the agent reach them over the API.

Summary

Sierra and ChatBotKit both put capable AI agents in front of your customers, but they optimize for opposite ways of working. Sierra is a done-for-you enterprise engagement - a partner that designs, builds, and runs a customer-experience agent with you, on an outcome-based model - which is a strong fit when you want a vendor accountable for the result and are ready for a managed, sales-led relationship. ChatBotKit is a self-serve platform you build on and own - start free, build no-code or with code, bring any model and your own keys, deploy everywhere, and run it in your own perimeter. If you want an agent delivered to you, Sierra is a compelling choice. If you would rather build, own, and grow agents on your own terms, ChatBotKit is made for that.