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:

-- Fast on-ramp / self-serve / managed harness (vs sales-led rollout) --

• path: content/features/cloud-agent-harness.md covers: Managed cloud harness - ship agents without operating infrastructure
• path: pages/landing/harness/index.jsx covers: Managed cloud harness positioning
• path: pages/landing/platform/index.jsx covers: Platform / composable building-blocks positioning; focused platform
• path: pages/landing/agents/index.jsx covers: Agent capabilities, build-vs-buy framing, fast to ship

-- No-code + standard developer surface (vs proprietary ABL/Agent Studio) --

• path: content/features/agentic-ai-blueprints.md covers: Blueprints - visual no-code composition of agents/datasets/skillsets
• path: content/features/agent-sdk.md covers: SDKs (Node/React/Next/Python/Go), agent SDK - standard tooling, no DSL
• 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
• 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

-- Agent capabilities & tools (many kinds of agent, not only service bots) --

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

-- 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/notion-integration.md covers: Notion sync
• path: content/features/memory-system.md covers: Persistent memory across sessions

-- Channels & native channel features --

• path: content/features/slack-integration.md covers: Slack native channel (attachments, voice/video input)
• path: content/features/whatsapp-integration.md covers: WhatsApp native channel
• 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 input
• 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
• path: content/features/email-integration.md covers: Email agents
• path: pages/landing/messaging/index.jsx covers: Multi-channel messaging / deploy-everywhere positioning

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

-- App platform, portals, multi-tenancy, white-label (resell) --

• path: content/features/app-platform.md covers: App Platform - Chat, Inbox, Connect, Task, Trace, Usage; Portals
• 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: pages/landing/whitelabel/index.jsx covers: White-label / resell positioning

-- Security, compliance, cost, observability (built-in governance) --

• 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 (cf. Kore.ai auditing/guardrails)
• 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); guardrails; 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

-- Deployment / perimeter (Kore.ai also offers on-prem/VPC - concede) --

• 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

-- Models & keys (both model-agnostic; ChatBotKit BYO keys/rates) --

• 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, own/self-licensed models
• path: content/features/oauth-secrets.md covers: Your own secrets, credentials, and OAuth connections

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

-- Kore.ai (external) - re-verify competitor claims on each review --

• url: https://www.kore.ai covers: Positioning - enterprise agentic-AI suite; "the only agent platform you can trust", "value with certainty"
• url: https://www.kore.ai/agent-platform covers: Agent Platform (Artemis); ABL proprietary agent language; Agent Studio; model-agnostic; cloud/private/on-prem/VPC/hybrid deployment; sales-led onboarding
• url: https://www.kore.ai/ai-for-service covers: AI for Service modules - AI Agents, Agent AI Assistance, Agentic Contact Center, QA, Proactive Outreach
• url: https://www.kore.ai/ai-for-service/contact-center covers: Agentic contact center depth - routing, live agent assist, QA scoring, outbound campaigns
• url: https://www.kore.ai/about-us covers: Enterprise leader positioning; Fortune-500 / regulated-industry track record; analyst recognition
• url: https://www.kore.ai/news/kore-ai-launches-agent-management-platform-to-bring-governance-and-control-to-enterprise-ai covers: Agent Management Platform (2026) - govern/monitor across frameworks/clouds/vendors; breadth of suite
• url: https://developer.kore.ai/docs/bots/bot-settings/plan-usage/usage-plans/ covers: Usage/consumption-metered plans; enterprise custom upgrade. Numbers intentionally NOT rendered on page date: Wed, Jul 8, 2026, 12:00 AM source: local

If you are looking at a Kore.ai alternative, you are building AI agents that do real work - answering customers, helping employees, running back-office processes - and you want a platform that gets them into production. ChatBotKit and Kore.ai both do that. Both let you ground agents in your own knowledge, give them tools and actions, connect a range of model providers, and wrap the result in security and governance.

The deeper difference is weight and reach. Kore.ai is a broad enterprise suite - AI for Service and AI for Work, a deep agentic contact center, enterprise search, verticalized apps for banking, healthcare, retail, IT, and HR, and a new proprietary agent language and studio underneath. It is powerful, and it is built to be bought through sales, implemented over months, and rolled out by IT across a large organization. ChatBotKit is the other shape: a focused agent platform with a self-serve on-ramp. You build no-code in a visual designer or through the API and SDKs, and deploy the same agent across every channel - with on-prem and air-gapped deployment available when you need it, not required to begin. Kore.ai optimizes for enterprise breadth; ChatBotKit optimizes for getting a capable agent live and out the door. This is an honest look at where each one fits.

What Kore.ai Does Well

Kore.ai is a serious enterprise platform with a long track record, and its strengths are real:

• Enterprise breadth - a wide suite spanning customer service and employee work, with pre-built agents and apps for banking, healthcare, retail, IT, HR, and recruiting, so a large organization can standardize on one vendor across many use cases.
• Deep contact-center and voice - an agentic contact center with advanced routing, real-time human-agent assistance, automated quality scoring across conversations, and outbound voice and digital campaigns.
• Heavy governance - full auditing of AI interactions and engine-enforced guardrails that the model cannot override, tuned for regulated, high-stakes deployments.
• Deployment flexibility - public cloud, private cloud, on-premise, VPC, and hybrid, integrated with the major cloud providers.
• Enterprise integrations - out-of-the-box connectivity to systems like Salesforce, ServiceNow, SAP, Zendesk, and Epic, and it is model-agnostic across major LLM providers.
• Track record and recognition - a Fortune-500 customer base and standing in analyst evaluations for conversational AI and agentic platforms.

If you are running a large, complex, contact-center-heavy program with professional-services support behind it, Kore.ai is built for that scale.

Where ChatBotKit Is Different

You can build a capable agent on either platform. The differences below matter once you would rather move fast and stay lean than adopt a full enterprise suite.

Live in Days, Not After a Multi-Quarter Program

This is the root distinction. Kore.ai is typically acquired through sales and stood up as an implementation project - a demo, a contract, a security review, and professional services, with deployments that buyers commonly measure in months and longer still for regulated banking and healthcare rollouts. ChatBotKit starts the other way around. It is self-serve from day one: create an agent, ground it in your data, connect a channel, and it is answering. You are building in the product on the first afternoon, not scheduling a kickoff. Enterprise deployment and controls are there for when the stakes rise - but reaching the working product is not gated behind a procurement cycle.

One Focused Platform, Not a Suite of Modules to License

Kore.ai is wide by design - separate modules for service and for work, a contact-center stack, enterprise search, an orchestration layer, an agent marketplace, and vertical apps, each a piece you select, license, and fit together. That breadth is the point for a big organization consolidating on one vendor, but it is a lot of surface to buy and integrate before an agent ships. ChatBotKit is one coherent platform that already includes what an agent needs - knowledge, tools, channels, automation, governance, and observability - so a small team gets a complete stack without assembling it from a catalogue. You adopt a platform, not a program.

Standard Tools, Not a Proprietary Agent Language

Kore.ai's platform centers on its own typed agent language and studio - genuinely capable, and genuinely another thing to learn, hire for, and standardize your team on, which is part of why reviewers note a steep learning curve. ChatBotKit meets your team where it already is. Build with no code in a visual Blueprint Designer, or with the tools you already use - SDKs for JavaScript, React, Next.js, Python, and Go, an OpenAI-compatible endpoint so your code is not bound to a proprietary interface, and MCP on both sides to consume and expose tools over an open standard. There is no bespoke DSL sitting between you and a working agent.

Everywhere Your Users Already Are

Kore.ai has broad channel reach, weighted toward the contact center and enterprise collaboration tools. ChatBotKit ships its own native channels out of the box - an embeddable web widget, WhatsApp, Slack, Telegram, Messenger, Instagram, Google Chat, Microsoft Teams, email, and SMS and phone-call voice via Twilio - plus realtime voice, lifelike avatars, and live meeting bots in Zoom, Google Meet, and Teams. Same agent configuration, every channel, a unified inbox. Each channel is more than a text relay: agents process file attachments, take voice and video input natively in places like Slack and the widget, join live meetings, answer as email agents, and handle inbound and outbound telephony. Kore.ai's contact-center depth is real; ChatBotKit's edge is native, self-serve reach across the messaging surfaces your customers already live in.

More Than Service and Employee Bots

Kore.ai is optimized for service and work - customer support, IT and HR assistance, and process automation shaped around the enterprise service desk. 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 run 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, and form-fillers. The agent reaches its tools through pre-built ability templates, custom API abilities, a secure code sandbox, agentic SQL, a headless browser, and web search - not only the actions that fit a service ticket.

Enterprise Controls Without the Enterprise-Only Door

Kore.ai leans hard on governance and trust, and it earns the concession: full auditing and enforced guardrails suit regulated, high-stakes work. The point is that this class of control is not exclusive to a heavyweight suite, and on ChatBotKit it does not require an enterprise engagement to unlock. You get PII redaction with reversible tokens, audit trails, SSO, granular access control, and enforced retention and usage policies; token-level usage and cost tracking with per-account limits; and performance analytics, event monitoring, and a millisecond-precision trace debugger to see exactly what an agent did and why. ChatBotKit does not train on your data and opts into zero data retention with the providers it calls, and you can bring your own model keys so usage bills to your accounts at your rates. And when data must stay inside your walls, deploy into your own cloud account (an AWS, Azure, or GCP VPC), a private data center, or a fully air-gapped network with self-hosted models - the same private-perimeter options Kore.ai offers, reached from a lighter starting point. Agility and enterprise-grade control are not a trade here; you get both.

Everything Your Agents Need, Built In

Everything you would reach for a Kore.ai module to do - grounding, tools, action, orchestration, governance - is here on one platform, without licensing it a piece at a time. This is what comes standard with ChatBotKit.

Tools and Real Actions

• A library of pre-built ability templates and custom API abilities, bundled into skillsets the agent can toggle on and off itself mid-conversation.
• A secure code sandbox that runs Python, JavaScript, and shell inside isolated, single-use environments with no path back into your systems.
• Agentic SQL for 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, sharpened with second-pass reranking and extended by JavaScript-aware website crawling and live Notion sync - with no vector database for you to run.
• Durable memory that carries a conversation across sessions - per contact, per bot, or shared - searchable by meaning.

Multi-Agent and Automation

• Native bot-to-bot abilities, visual Blueprints that wire agents, datasets, and skillsets into working systems, shared Spaces for common knowledge, and cron-scheduled autonomous Tasks driven by webhooks and triggers.
• A Community Hub where you publish and clone blueprints, skillsets, datasets, and widgets.

Governance, Cost, and Observability

• 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.
• Multi-tenant by design - isolated accounts and sub-accounts through the Partner API, with branded Portals on your own domains for teams and clients.

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, so integrations run on an open standard rather than one vendor's connectors.

ChatBotKit vs Kore.ai at a Glance

Pricing: A Gentle On-Ramp, Not a Procurement Cycle

The difference in shape shows up plainly on the way in.

Kore.ai's enterprise platform is sales-led - custom contracts, typically consumption-metered, with professional-services implementation layered on top. That can make sense for a large, committed program where the suite's breadth is the point, but it is a heavy entry: you commit and implement before agents are doing much. Kore.ai adjusts its packaging over time, so confirm the current terms directly.

ChatBotKit inverts that. Start with a free tier, move to self-serve plans that track your usage, and reach for full enterprise options - on-prem and air-gapped deployment, and multi-tenancy - only at the point you genuinely need them. The entire managed stack - models, knowledge, sandboxes, every channel, governance, and observability - already sits behind one platform, and your own model keys mean provider usage lands on your accounts at your rates. Both vendors revise pricing over time, so verify the current plans directly. Begin light, scale on your own schedule.

Choose Kore.ai If

• You are running a large enterprise program and want one broad suite spanning service, employee work, and back-office automation.
• Your core need is a deep agentic contact center with routing, live-agent assistance, quality scoring, and outbound campaigns.
• You want verticalized apps and prebuilt agents for banking, healthcare, retail, IT, or HR out of the box.
• You want a vendor with professional services and a Fortune-500, regulated-industry track record behind the rollout.

Choose ChatBotKit If

• You want agents live in days, self-serve, without a demo gate or an implementation project.
• You want one focused platform instead of licensing and integrating a suite of enterprise modules.
• You would rather build with a no-code designer and standard SDKs than adopt a proprietary agent language.
• You want to deploy across every channel - web, WhatsApp, Slack, email, and voice - from one agent.
• You want to build more than service bots - support agents, voice systems, coding agents, avatars, and research agents.
• You want enterprise controls and private deployment - governance, SSO, on-prem, air-gapped - without an enterprise-only entry.

Moving from Kore.ai to ChatBotKit

Bring your knowledge sources into a dataset, re-express what your Kore.ai 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, custom API abilities, and MCP, and deploy it to the channels your users are on. There is no proprietary language to port and no implementation program to schedule. If some processes belong in a broader enterprise system, leave them there and let the agent reach them over the API.

Summary

Kore.ai and ChatBotKit both put AI agents into production, but they are built at different weights. Kore.ai is a broad enterprise suite - deep contact center, verticalized apps, heavy governance, and vendor services - acquired through sales and rolled out over months, and a strong fit when that scale and breadth are exactly what you need. ChatBotKit is a focused agent platform you can start on today - build no-code or with code, deploy everywhere, keep enterprise controls and private deployment in reach - without the suite or the program around it. If your project is a large enterprise transformation, Kore.ai has the surface area. If you want to ship real agents quickly and grow into the enterprise on your own timeline, that is where ChatBotKit fits.