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:

-- Agile / self-serve on-ramp positioning (vs IT-led contact-center rollout) --

• path: pages/landing/free/index.jsx covers: Free / self-serve on-ramp - start without a sales-led program
• path: pages/landing/platform/index.jsx covers: Platform / composable building-blocks positioning
• path: pages/landing/agents/index.jsx covers: Agent-first capabilities, build-vs-buy framing
• path: pages/landing/harness/index.jsx covers: Managed cloud harness positioning
• path: content/features/cloud-agent-harness.md covers: Managed cloud harness - no infrastructure/rollout to run

-- No-code + code (vs AI Agent Studio + professional services) --

• 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
• path: content/features/api.md covers: REST API - same agents available in code
• 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

-- Agent controllability vs deterministic intent flows --

• path: content/features/trace-debugging.md covers: Millisecond-precision trace debugger - auditability
• path: content/features/task-automation.md covers: Scheduled autonomous Tasks (cron) - deterministic paths when wanted
• path: content/features/multi-agent-orchestration.md covers: Multi-agent orchestration on the platform

-- Agent capabilities & tools (open category, not CRM/CC-shaped) --

• path: content/features/abilities-catalogue.md covers: Pre-built ability templates + custom abilities
• path: content/features/skillset.md covers: Skillsets - grouped abilities, install/uninstall mid-conversation
• 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/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 (reach external systems)

-- Knowledge / RAG / memory (vs Cognigy Knowledge AI) --

• 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 (vs CCaaS/omnichannel connectors) --

• 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/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: content/features/languages.md covers: Multi-lingual support (cf. Cognigy real-time translation)
• path: pages/landing/messaging/index.jsx covers: Multi-channel messaging / deploy-everywhere positioning

-- Voice, telephony, avatars, meetings (concede Cognigy's voice depth) --

• path: content/features/realtime-voice.md covers: Realtime low-latency voice conversations with full agent stack
• path: content/features/twilio-integration.md covers: Telephony - SMS and phone-call voice via Twilio, your own numbers
• 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

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

• path: content/features/partner-api.md covers: Partner API, parent-child sub-accounts, account isolation, reselling
• path: content/features/portals.md covers: Portals - white-labeled custom-domain app deployment
• path: content/features/app-platform.md covers: App Platform - Chat, Inbox, Connect, Task, Trace, Usage; Portals
• 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/community-hub.md covers: Community Hub - share/clone blueprints, skillsets, datasets, widgets
• path: content/features/spaces.md covers: Shared Spaces for persistent knowledge
• path: content/features/bot-to-bot-communication.md covers: Native bot-to-bot abilities
• path: content/features/webhooks.md covers: Webhooks and triggers for automation
• path: pages/landing/whitelabel/index.jsx covers: White-label / resell positioning

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

-- Deployment / perimeter (on-prem parity with Cognigy) --

• 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

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

• 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/performance-analytics.md covers: Performance analytics + token-level usage/cost tracking
• path: content/features/event-monitoring-and-analytics.md covers: Event monitoring and analytics (cf. Cognigy Insights)

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

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

• url: https://www.cognigy.com covers: Cognigy positioning - enterprise conversational/agentic AI for contact centers; NiCE Cognigy branding
• url: https://www.cognigy.com/platform/cognigy-ai covers: Cognigy.AI - AI Agent Studio, Knowledge AI, Agentic AI, NLU; deterministic + agentic blend
• url: https://www.cognigy.com/platform/cognigy-voice-gateway covers: Voice Gateway - turnkey CCaaS/CPaaS voice connectivity (voice depth to concede)
• url: https://www.cognigy.com/platform/agentic-ai covers: Agentic AI - autonomous AI workforce for enterprise contact centers
• url: https://www.cognigy.com/news/nice-closes-acquisition-of-cognigy covers: NiCE closed acquisition of Cognigy in 2025 - now part of NiCE CXone. Verify name/packaging on each review
• url: https://aws.amazon.com/marketplace/pp/prodview-6c25zypcl2fro covers: NiCE Cognigy - AI agents for enterprise contact centers; on-prem/air-gapped, CCaaS integrations (Genesys/Avaya/Amazon Connect/8x8)
• url: https://rasa.com/blog/cognigy-alternatives covers: Comparison/lead-gen targets seen for Cognigy - Kore.ai, Voiceflow, Rasa, Microsoft Copilot Studio, Dialogflow, Genesys date: Wed, Jul 8, 2026, 12:00 AM source: local

If you are weighing a Cognigy alternative, you are building AI agents that talk to your customers, reach your systems, and do real work - and you want a platform that gets you there. ChatBotKit and Cognigy both build that. Each grounds agents in your knowledge, hands them tools, connects multiple model providers, and can carry a conversation over voice as well as chat.

The deeper difference is what each product is built around. Cognigy - now part of NiCE after a 2025 acquisition - is an enterprise contact-center suite. Its center of gravity is the call operation: deep voice and telephony through its Voice Gateway, agent assist for human staff, tight integration into your CCaaS fabric, and a rollout that is usually led by IT and professional services. That depth is genuinely strong if the contact center is your world. ChatBotKit is built the other way - as an agile agent platform. You build fast, no-code or in code, ground the agent in your data, and deploy the same configuration across every channel, with a self-serve on-ramp and multi-tenant deployment in the box. Cognigy is contact-center-first; ChatBotKit is agent-first. This is an honest look at where each one fits.

What Cognigy Does Well

Cognigy is a serious enterprise platform, and for large customer-experience organizations its strengths are real:

• Deep voice and telephony - the Voice Gateway provides turnkey connectivity into CCaaS and CPaaS infrastructure, so virtual voice agents plug into existing call routing without a rip-and-replace.
• Contact-center integration - prebuilt connectors into Genesys, Avaya, Amazon Connect, NiCE CXone, and other platforms, so agents drop into a routed operation rather than sitting beside it.
• Agent assist - Agent Copilot delivers real-time coaching, knowledge, and suggestions to human agents while they work, not only self-service automation.
• Determinism plus agentic AI - Cognigy blends structured, intent-based flows with newer agentic behavior, which suits regulated, high-volume CX where predictability matters.
• Enterprise CX maturity - Knowledge AI for grounded answers, real-time translation, omnichannel connectors, and analytics, proven across large global brands and now backed by NiCE.
• Secure deployment - SaaS, dedicated, and on-premise or air-gapped options for finance, healthcare, and public-sector requirements.

If the contact center is the center of your operation and you are ready for an enterprise CX program, Cognigy meets you where your call traffic already lives, and that depth is hard to match from outside.

Where ChatBotKit Is Different

You can stand up a capable customer-facing agent on either platform. The differences below matter once you would rather move fast than run a contact-center program.

Agent-First, Not Contact-Center-First

This is the root distinction. Cognigy is architected around the call operation - the voice channel, the agent desk, the CCaaS routing fabric - and an agent is something you configure inside that world. ChatBotKit is architected around the agent. You give it a goal, knowledge, and tools; it decides which tools to call and in what order, looping until the work is done; and the channels it serves are an output of that agent, not the frame you build within. Nothing about ChatBotKit assumes a contact center underneath. That is exactly why Cognigy is so strong when the call center is the project, and why ChatBotKit fits better when the agent is.

Cognigy leans on intent-based flows partly because a fixed path is easy to reason about, and it now mixes those flows with agentic behavior. ChatBotKit reaches the same predictability from the agent side: guardrails, structured tools, enforced retention and usage policies, PII redaction, and a millisecond-precision trace debugger that shows exactly what an agent did and why. When you genuinely want a fixed, repeatable path, Blueprints and scheduled Tasks give you one on the same platform. You are not choosing between a rigid flow and an unpredictable agent - you get an agent that handles the cases nobody scripted, with the auditability regulated work needs.

A Self-Serve On-Ramp, Not an Enterprise Program

Standing up Cognigy tends to look like a project: scoping, CCaaS integration, professional services, and IT sign-off before anything goes live. ChatBotKit is self-serve from the first minute. Sign up, build an agent in the dashboard or the visual Blueprint Designer, and put it in front of real users the same day - no integration engagement to schedule, no platform to provision. You can begin on a single channel with a small team and grow into enterprise deployment, multi-tenancy, and your own perimeter later, without re-platforming. The on-ramp is a slope, not a wall.

Build No-Code, or Drop Into Code

Cognigy's AI Agent Studio is a capable visual builder. ChatBotKit gives you the same no-code path - a dashboard and the Blueprint Designer for wiring agents, datasets, skillsets, and abilities into a working system - so a non-developer can build without touching code. The difference is that the identical agents are available through a full API and SDKs (Node, React, Next, Python, Go), an OpenAI-compatible endpoint, and a Terraform provider. A developer can extend, script, or version-control anything without waiting on a services team. One platform serves both the builder and the engineer.

Every Channel from One Agent

Cognigy reaches its channels largely through omnichannel and CCaaS connectors - powerful for a routed contact center, but it assumes that fabric is in place. A ChatBotKit agent goes wherever your users already are, natively: 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, one unified inbox. And each channel is more than a text relay: agents process attachments, take voice and video input, join live meetings, answer as email agents, and speak multiple languages with built-in multi-lingual support. You do not need a contact-center platform underneath to be everywhere your customers are.

More Than Contact-Center Agents

Cognigy's sweet spot is customer service inside the contact center, and that concentration is a real strength there. ChatBotKit refuses to fix the definition of agent that narrowly. From a single configuration - one body of knowledge, one set of abilities - you can stand up 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, form-fillers, and internal copilots. The agent reaches its tools through pre-built ability templates, custom API abilities, secure code sandboxes, agentic SQL over sources like HubSpot and Postgres, a headless browser, web search, and both sides of MCP - well beyond the actions that fit a service workflow.

Ready-to-Use Apps and Portals, Not Only a Builder

Cognigy centers on a flow studio and the contact-center tooling wrapped around it. ChatBotKit pairs its builder with a shelf of finished applications people use daily - Chat for multi-agent conversations, Inbox to work every conversation across channels and bots in one place, Connect for managed third-party integrations, and Task for scheduled autonomous runs - with Trace and Usage on hand for debugging and spend. Bundle any of them into a Portal, a branded and sign-in-gated site on your own domain, and give it to a team, a client, or the entire company. You end up shipping usable software to the people who need it rather than assembling the app shell, authentication, and admin by hand.

Your Models and Keys, in Your Perimeter When You Need It

You stay in control of the model layer. ChatBotKit spans a wide range of model providers, lets you swap the model behind any agent without rebuilding it, and lets you bring your own model API keys so usage bills to your provider accounts at your rates - with your own secrets and OAuth connections to the systems your agents reach. On deployment, ChatBotKit meets Cognigy's bar rather than beating it: both offer on-premise and air-gapped options for regulated industries. Beyond the managed cloud, ChatBotKit runs in your own cloud account (AWS, Azure, or GCP VPC), a private data center, or a fully air-gapped network with self-hosted models on your GPUs, plus EU data residency on the managed cloud. The distinction is not whether you can run it privately - it is that you reach that option when you need it, not as the cost of getting started.

Everything Your Agents Need, Built In

Grounding, tools, action, governance, voice - whatever you would configure in Cognigy for an agent, ChatBotKit ships the equivalent, on a platform you can open and use today. Here is what is included as standard.

Actions and Tool Use

• An agent draws on pre-built ability templates and your custom API abilities, bundled into skillsets it turns on or off itself as a conversation unfolds.
• Sandboxed code execution lets it run Python, JavaScript, and shell inside disposable, isolated environments that cannot touch your infrastructure.
• With agentic SQL it answers plain-language questions over sources like HubSpot, Supabase/PostgreSQL, and CSV, Excel, or JSON files.
• Rounding it out: a headless browser, web search, vision, image and video generation, and audio and video transcription.

Grounding and Memory

• Build semantic datasets from documents, spreadsheets, and JavaScript-aware website crawling, tighten retrieval with second-pass reranking, keep them current with Notion sync - and never operate a vector database yourself.
• Give agents durable memory that persists across sessions, scoped per contact, per bot, or shared, and searchable by meaning.

Orchestration and Scheduling

• Compose systems with native bot-to-bot hand-offs, visual Blueprints that wire agents, datasets, and skillsets together, shared Spaces for common knowledge, and cron-driven Tasks fired by webhooks and triggers.
• Publish and clone blueprints, skillsets, datasets, and widgets through the Community Hub.

Compliance, Spend, and Tracing

• Every plan carries PII redaction with reversible tokens, audit trails, SSO, granular access control, and enforced retention and usage policies.
• See what agents cost and do: performance analytics, token-level usage and cost tracking, event monitoring, and a millisecond-precision trace debugger.
• Multi-tenant sub-accounts via the Partner API, with branded Portals on your own domain - isolate each team or client and govern them from one place.

MCP, in Both Directions

• Call any MCP server from within an agent, and expose your own skillsets as MCP tools that outside clients - Claude Desktop, IDEs, your own apps - can consume, so your integrations ride open standards rather than proprietary connectors.

ChatBotKit vs Cognigy at a Glance

Pricing: Self-Serve First, Not Sales-Led-Only

The build-fast-versus-roll-out difference shows up on the invoice too.

Cognigy is sold as an enterprise contact-center platform - typically through a sales-led motion, with annual commitments and professional services around the deployment. That can be exactly right when you are automating a large call operation and want a vendor to stand it up with you. It is a heavier way to begin if your need is simply to ship a few capable agents, since the platform is scoped and priced for the contact center as a whole.

ChatBotKit inverts that. You can begin for free and let the plan grow with your usage, reaching for enterprise terms - on-prem or air-gapped deployment, multi-tenancy - only at the point you truly need them, with no CX program to license underneath. The full managed stack comes with it - models, knowledge, sandboxes, every channel, governance, and observability - and because you can bring your own model keys, provider usage lands on your accounts at your rates. Both vendors adjust prices over time, so confirm the current plans directly. The point is that starting costs nothing and scaling never forces a reset.

Choose Cognigy If

• The contact center is the project - you are automating and augmenting a large enterprise call operation end to end.
• You need deep voice and telephony and turnkey integration into a CCaaS platform like Genesys, Avaya, or Amazon Connect.
• You want agent assist - real-time coaching and knowledge delivered to human agents while they work.
• You are ready for an enterprise CX program and value the backing of a mature vendor now inside NiCE.

Choose ChatBotKit If

• You want to ship agents fast - self-serve, live the same day, no contact-center rollout to schedule.
• You want to build no-code in a visual designer, then drop into the API and SDKs when you need to.
• You want to deploy across every channel - web, WhatsApp, Slack, email, and voice - from one agent configuration.
• You want to build more than service agents - coding agents, voice systems, avatars, and research agents.
• You want one platform that grows from a first agent to an enterprise, on-prem, or air-gapped deployment without re-architecting.

Moving from Cognigy to ChatBotKit

Start by loading your knowledge sources into a dataset. Then translate the behavior of your Cognigy flow into a backstory and a set of abilities - working in the dashboard, the visual Blueprint Designer, or whichever SDK suits your stack - hook the agent back into the systems it needs through your own OAuth connections and MCP, and publish it to the channels your users are on. Nothing here waits on a CCaaS integration slot or a professional-services engagement. You also do not have to tear out your contact center on day one: keep the routing you depend on, let a ChatBotKit agent reach it over the API, and lift over the agents you most want to ship fast and keep portable first.

Summary

Cognigy and ChatBotKit both build AI agents that talk to your customers, but they optimize for opposite things. Cognigy - now part of NiCE - is a contact-center suite: deep voice and telephony, agent assist, CCaaS integration, and an enterprise rollout, which makes it a powerful choice when the call operation is the whole project. ChatBotKit is an agile agent platform: build fast no-code or in code, ground agents in your own data, deploy across every channel, run it managed or in your own perimeter - built for teams that want to move quickly rather than run a program. If the contact center is your world, Cognigy is a strong fit. If you want to build and ship agents on your own terms, ChatBotKit is built for exactly that.