DEV Community: CometChat

Launching CometChat Campaigns on Product Hunt today!

CometChat — Wed, 03 Jun 2026 10:00:53 +0000

One dashboard to build, customize, and send omnichannel notifications to your users. Marketing offers, feature announcements, support alerts, operational broadcasts. Design your templates, pick your audience, and deliver across in-app, push, SMS, and email. A/B test variants, schedule sends, and track performance end to end. Marketers, ops, support, developers. Everyone on your team can run campaigns from day one.

https://www.producthunt.com/products/cometchat-campaigns?launch=cometchat-campaigns

It would be great if you could take a moment to go and upvote!!

Launching Chat Skills for AI Agents on Product Hunt today

CometChat — Wed, 27 May 2026 08:13:56 +0000

This helps you add fully functional chat to your React app using AI agent skills. Drop in a skill file and your agent handles the full integration: installation, environment setup, SSR-safe rendering, and the correct init and login flow. One file per framework. Works seamlessly with Cursor, Kiro, VS Code Copilot, Claude, and Codex. Go from zero to a working chat in minutes, built on CometChat's proven foundation and ready for real projects from day one.

https://www.producthunt.com/products/cometchat-skills?launch=calling-skills-for-ai-agents

It'll be great if you could check it out and upvote!

Launching Voice and Video Calling by CometChat on Product Hunt today!

CometChat — Wed, 20 May 2026 07:51:01 +0000

CometChat Calling gives you HD voice and video, built to ship fast and scale high. Recording, screen sharing, call logs, raise hand, and picture-in-picture out of the box. Integrate via SDKs, or drop a CometChat Skills file into your coding agent and let it handle the setup. Handles high-concurrency calls, with HIPAA, GDPR, SOC 2, and ISO 27001 compliance built in.

producthunt.com

Production Ready UI Kits by CometChat launching on Product Hunt today

CometChat — Wed, 13 May 2026 07:18:55 +0000

Build production-ready chat experiences faster with CometChat’s updated open-source UI Kits across Angular, Jetpack Compose, React, React Native, Vue, Flutter, Android, and iOS. Featuring redesigned Angular and Jetpack Compose UI Kits with modular components, native modern UI patterns, built-in messaging and calling, real-time updates, search, unread counts, and everything needed to launch polished chat experiences faster.

https://www.producthunt.com/products/production-ready-ui-kits-by-cometchat?launch=production-ready-ui-kits-by-cometchat

It'll be great if you could take a minute to go upvote us on Product Hunt:)

CometChat Unreal Engine SDK

CometChat — Fri, 08 May 2026 08:17:23 +0000

We're launching the CometChat Unreal Engine SDK, a native UE5 plugin that integrates real-time chat directly into multiplayer games and interactive experiences.

The SDK ships with full support for both Blueprint and C++, so you can wire up a working chat system whether you're prototyping visually or building a production title in code.

Supported platforms include:

Windows (Win64)
macOS
iOS
Android

Minimum requirements:

Unreal Engine 5.5.4 or 5.7.2
C++ development tools for your platform
A CometChat account with an App ID, Region, and Auth Key.

Why does this matter to me as a game developer?

Adding chat to a game is not as simple as dropping in a library.

Every game engine has different constraints around threading, UI rendering, and event systems. A real-time chat SDK needs to play nicely with all of them. For Unreal specifically, that means running all callbacks on the Game Thread so you can update UI safely, exposing async operations as Blueprint-friendly nodes with clear success and failure outputs, and fitting into the existing Subsystem architecture so the SDK lifecycle is automatically managed alongside your game instance.

Most solutions in this space hand you a REST API and leave the Unreal integration to you. The CometChat Unreal SDK is purpose-built for UE5, with a plugin architecture that handles all of that automatically.

Key features and capabilities

Blueprint and C++ support
The plugin exposes every SDK operation through both Blueprint async nodes and a native C++ API. You get the same capabilities either way.

In Blueprints, every operation has On Success and On Failure exec pins, making error handling explicit and visual. In C++, you access the same underlying subsystem directly.

UCometChatSubsystem
The SDK is built around a UGameInstanceSubsystem, which means it's created automatically when your game starts and lives for the full duration of the game instance. You don't manage its lifecycle manually. Access it from any Actor or Widget with a standard Get Subsystem call.

Latent async nodes
All network operations, including login, sending messages, fetching history, and group management, are exposed as latent async Blueprint actions. They don't block the game thread and surface results through clean success and failure output pins.

Real-time delegates
Incoming messages, presence updates, typing indicators, delivery receipts, and connection state changes all arrive via multicast delegates on the Subsystem. Every delegate fires on the Game Thread, so you can update your UI directly in the callback without any additional thread-switching.

What's included out of the box

Authentication Login with Auth Key, Login with Auth Token, Logout, session check.
Messaging Send and receive text messages (1:1 and group), message history with pagination.
Users Fetch user profiles, real-time presence.
Groups Create, join, leave groups, group messaging.
Real-time events Message received, presence changed, typing indicators, read receipts, connection state.

How does installation work?

The plugin ships with two installation paths.

Option 1: Precompiled binaries (no build required)

Copy the CometChatSdk/ plugin folder from the SDK repository into your project's Plugins/CometChat/ directory, download the precompiled binaries for your engine version, extract them into the same directory, enable the plugin in your .uproject file, and open your project in Unreal Editor. No compilation step needed.

Option 2: Build from source

Copy the plugin source into your project's Plugins/ directory, regenerate project files, and build.

Once installed, add CometChat as a module dependency in your game's .Build.cs file, then call Configure on the CometChatSubsystem with your App ID and Region before making any other SDK calls.

What's interesting about the tech behind this?

The plugin is structured into three distinct layers, and understanding them helps you use it effectively.

UCometChatSubsystem is the single owner of the SDK lifecycle. Because it's a UGameInstanceSubsystem, Unreal manages its creation and destruction automatically. You never instantiate it directly.

Latent async nodes are the Blueprint-facing surface of every SDK operation. They follow the standard Unreal async action pattern, which means they work correctly with Blueprint's execution graph and never block frame execution.

Real-time delegates are how the SDK pushes events to your game. Rather than polling or requiring you to set up listeners manually, you bind to the Subsystem's delegates before login and events arrive automatically. Because all delegates fire on the Game Thread, you can drive UI updates directly from them.

There's also a ready-to-use CometChatGroupChatBox widget included in the plugin if you want a working group chat UI without building one from scratch.

Reference links

SDK repository: https://github.com/cometchat/chat-sdk-unreal/tree/v1

Documentation overview: https://www.cometchat.com/docs/sdk/unreal/overview

Setup guide: https://www.cometchat.com/docs/sdk/unreal/setup

CometChat Skills

CometChat — Mon, 04 May 2026 08:09:11 +0000

CometChat Skills is a set of five agent skill files that guide any AI coding agent through a correct CometChat React UI Kit v6 integration, from install to a working chat UI, in under 15 minutes.

There is one skill per framework: React.js, Next.js, React Router, and Astro, plus a shared core. The skills work with Claude Code, Cursor, Kiro, VS Code Copilot, and Codex. Drop a .md file into your agent's context directory, and the agent knows exactly what to do.

This product focuses on eliminating the framework-specific debugging that slows down React integrations. Every React framework has different SSR constraints, env var conventions, and module loading patterns. CometChat Skills handles all of that automatically, so your AI coding agent generates the right integration code for your specific project.

What are we launching?

We're launching CometChat Skills, a set of production-ready agent skill files for integrating CometChat React UI Kit v6 into React applications.

The skills work with any AI coding agent that reads markdown context, including:

Claude Code
Cursor
Kiro
VS Code Copilot
Codex

Supported frameworks include:

React.js / Vite
Next.js (App Router + Pages Router)
React Router v6 and v7
Astro

Install the skills with one command, then open your project in your AI coding agent to run it. The agent detects your framework, shows three chat experience options, collects or infers your CometChat credentials, and scaffolds the integration with the correct SSR pattern, file layout, and TypeScript types.

Why does this matter to me as a developer?

Integrating CometChat into a React project is not the same across every framework.

Every React framework has different:

SSR constraints
Environment variable conventions
Module loading patterns

Most tools like Sendbird, Stream and PubNub all have static quickstart docs. None offer an agent-agnostic skill that detects existing project state, adapts to the detected framework, and generates idiomatic integration code inline in your existing project, across every major AI coding agent.

Key features and capabilities in CometChat Skills

Framework detection
The skill detects your project's router type, bundler, and framework version before generating any code.

This means the agent:

Chooses the right SSR prevention pattern for your framework.
Applies the correct environment variable convention.
Generates code that matches your existing project structure.
Generates code that matches your existing project structure.

Credential inference

Before prompting you for your CometChat credentials, the skill looks for them in your existing files or any existing CometChat UI Kit integration calls in your project.

Three chat experiences, ready to scaffold

Once the agent knows your framework and credentials, you choose the chat experience you want to build.

Pass an experience directly when you run the command:

Conversation list and message view. This lists all conversations and messages in a single view with the option to open specific chats when clicking on them. Best for apps where users switch between multiple conversations.
One-to-one chat.Private conversation windows connecting individual users. Best for customer support or matched-pair chat.
Tab-based chat. Tabs to indicate chats, calls, users and groups. Each tab shows the matching CometChat list; clicking a conversation opens messages on the right. Best for full-featured messenger-style apps.

Additionally, CometChat skills will ensure:

Minimal changes to your existing project, and
A verification checklist after integration

What's interesting about the tech behind this?

CometChat Skills is built around a modular skill file architecture.

There is one entry-point dispatcher skill and four framework-specific skills underneath it:

Because the skills ship as markdown files, they work with any AI coding agent that reads markdown context. Drop a .md file into your agent's context directory. That's it.

This makes the skills genuinely agent-agnostic. Claude Code, Cursor, Kiro, VS Code Copilot, and Codex all read the same files and follow the same instructions.

Reference links

GitHub repository: https://github.com/cometchat/cometchat-skills

Documentation for React: https://www.cometchat.com/docs/ui-kit/react/react-js-integration

Documentation for React.js: https://www.cometchat.com/docs/ui-kit/react/overview

Launching Compact Message Composer by CometChat on Product Hunt today!

CometChat — Wed, 29 Apr 2026 07:44:23 +0000

CometChat's Compact Message Composer, part of the CometChat UI Kits, brings rich text formatting to your chat app - bold, italic, strikethrough, underline, links, bullet points, blockquotes and more. Enabled with a single prop. Comes with a floating toolbar, keyboard shortcuts, and full control over how messages are sent. Drop it into any framework and ship a richer chat experience in minutes.

It'll be great if you could spare a minute to upvote on PH: https://www.producthunt.com/products/cometchat?launch=compact-message-composer-by-cometchat

Compact Message Composer: a single-line message input

CometChat — Mon, 20 Apr 2026 09:51:05 +0000

CometChat’s single line composer, is a compact, message input component for the CometChat React UI Kit v6. It supports rich text formatting, attachments, mentions, and voice recording, and is designed to drop into existing chat layouts without disruption.

This is a compact variant of the message composer for CometChat’s chat and messaging product. It shares a similar props API but provides a streamlined, single-line interface. Wire it alongside the CometChat message header and message list to build a standard chat view.

What are we launching?

We are launching a new component in the CometChat React UI Kit v6 that provides a compact, single-line message input with optional rich text formatting capabilities.

It supports:

Rich text formatting: bold, italic, underline, strikethrough, code, links, lists, and blockquotes.
Attachments
Message editing
Mentions
Link previews
Voice recording

The component is available via the React UI Kit and the JavaScript SDK.

Getting started is a single import from the React UI Kit.

Why does this matter to me as a developer?

The standard messaging composer is full-featured and multi-line. That works well for many layouts, but not all of them.

Some interfaces need a message input that:

Stays compact and single-line
Fits into tighter layouts without taking over the screen.
Still supports the full range of messaging features when needed.

CometChat’s single line composer fills that gap. You get the same feature set as the full composer, including rich text, attachments, mentions, and voice recording, in a component that stays out of the way until the user needs it.

Key features and capabilities

Rich text formatting
The formatting toolbar supports:

Bold, italic, underline, strikethrough.
Inline code and code blocks
Links
Bullet lists and ordered lists
Blockquotes

Every tool has a keyboard shortcut. The toolbar itself has three display modes:

Floating on selection: a toolbar appears when the user selects text. Desktop only.
Always visible: the toolbar sits above the input by default.
Hidden: Rich text is enabled but no toolbar is shown. Keyboard shortcuts still work.

On mobile, only the fixed toolbar is supported. The floating selection toolbar is automatically disabled for better touch experience.

Attachment options

The component includes attachment support out of the box. Individual attachment types can be hidden via props

Mentions

Mentions are enabled by default. You can:

Disable mentions entirely
Disable group-wide mentions like @all
Set a custom label for group mentions, for example @channel or @everyone
Control how the mentions list is fetched

Callback props

Three callback props let you hook into composer behavior:

onSendButtonClick fires when the send button is clicked, overriding the default send behavior
onTextChange fires as the user types
onError fires on internal errors such as network failures, auth issues, or SDK exceptions

Global UI events

The component emits three global events via CometChat messaging events:

ccMessageSent fires when a message is sent
ccMessageEdited fires when a message is edited
ccReplyToMessage fires when a user replies to a message

Each event carries a status of inProgress, success, or error. Use these to sync external UI with message state, for example updating a notification badge or triggering analytics.

What is interesting about the tech behind this?

Custom view slots

Four slots let you replace specific sections of the default UI:

Header view; replaces the area above the composer input
Auxiliary button view; replaces sticker and AI button area
Send button view; replaces send button
Attachment options; replaces default attachment options list

Each slot accepts a JSX element, so you can inject any component into that position without touching the rest of the layout.

Text formatters

The textFormatters prop accepts a list of CometChatTextFormatter instances. This lets you build custom formatting behavior, for example a shortcut expander that replaces !greeting with a full message string, and attach it to the composer without modifying the component itself.

Minimal footprint in existing layouts

The component patches into existing chat layouts by design. Passing a user or group prop is enough to wire it up. It does not require changes to your routing, auth, or app logic.

Reference links
Documentation: https://www.cometchat.com/docs/ui-kit/react/compact-message-composer

Full Message Composer: https://www.cometchat.com/docs/ui-kit/react/message-composer

Message List: https://www.cometchat.com/docs/ui-kit/react/message-list

Mentions Formatter: https://www.cometchat.com/docs/ui-kit/react/mentions-formatter-guide

CometChat Support Services: Built to support you at every stage

CometChat — Tue, 07 Apr 2026 07:59:34 +0000

When you add real-time communication to your product, be it chat, calls, or AI-driven conversations, reliability becomes critical. Your users expect conversations to work instantly and consistently.

That’s why support at CometChat is designed to go beyond troubleshooting. It combines immediate assistance, self-serve resources, proactive guidance, and enterprise-grade guarantees to help teams build, launch, and scale confidently.

Here’s a closer look at the support services available.

1. Always-On Assistance

When something breaks or a question blocks progress, you need help quickly. CometChat provides multiple ways for teams to get real-time assistance.

24/5 Live Chat Support for instant help with urgent questions
24/5 Email Support for technical queries and troubleshooting
Ticket Support for structured issue tracking
24/7 Emergency Ticket Support for critical incidents

These channels ensure developers and product teams can reach support when they need it, whether during development, testing, or production incidents.

2. Knowledge & Self-Serve Resources

Many teams prefer to move quickly without waiting for assistance. To support this, CometChat provides a comprehensive set of learning resources.

Documentation with detailed implementation instructions
Help Center for quick answers to common questions
Tutorials & Guides to walk through integrations step-by-step
Community Forum for peer discussions and shared solutions
Status Page to monitor system availability and incidents
Feature Request Page to submit product feedback and ideas

These resources help teams integrate features like in-app messaging, moderation workflows, and communication infrastructure without friction.

3. Dedicated Access

For teams operating at scale or building complex communication experiences, direct collaboration with experts can make a major difference.

CometChat offers several options for closer engagement:

Dedicated Slack channel for real-time collaboration with support engineers
Dedicated Customer Success Manager to guide product adoption and strategy
Dedicated Technical Support Engineer for deep technical troubleshooting
Annual Technical Health Check to review architecture, performance, and best practices

This level of access ensures teams always have an expert who understands their implementation and can help optimize it over time.

4. Implementation Guidance

Launching a real-time communication feature can involve architectural decisions, integration challenges, and product design considerations. CometChat helps teams navigate this process through hands-on guidance.

Support includes:

Launch call with an Implementation Manager to review setup and deployment
Dedicated Implementation Engineer for complex integrations
Dedicated Slack channel during implementation for quick coordination

This guidance helps teams avoid common mistakes and get their messaging or calling features live faster.

5. Reliability & Escalation Support

For organizations running mission-critical communication systems, additional escalation paths are available.

These include:

Uptime SLA guarantees (up to 99.999%)
24/7 emergency phone support
24/7 priority email support

These options ensure rapid response and stronger reliability commitments when communication features are central to the product experience.

6. Advanced Technical Support & Optimization

As products evolve, teams often need deeper assistance with scaling, customization, or infrastructure changes.

CometChat provides advanced technical support such as:

Migration assistance when moving from another provider or legacy system
Integration reviews to validate architecture and configuration
Weekly check-ins for ongoing guidance and optimization
UI Kit integration and bespoke customization support

This support ensures teams can fully leverage the platform while maintaining performance and scalability.

7. Live Monitoring & Troubleshooting

Some use cases such as live events, launches, or high-traffic community moments require active oversight.

To support these scenarios, CometChat offers:

Virtual event live monitoring and support
Real-time troubleshooting during critical events

Having engineers actively monitor systems during important moments reduces risk and ensures rapid issue resolution if anything unexpected occurs.

8. Support Prioritization & Response Guarantees

As your product grows, so does the need for faster, more predictable support. CometChat’s support tiers ensure your most critical issues are handled with the urgency they deserve with defined response times and priority-based escalation.

Support plans include:

Guaranteed ticket first response times
Priority Support
Highest Priority Support

These tiers ensure that as your product scales, your support experience scales with it with faster response times, quicker escalations, and greater attention to critical issues when it matters most.

Built to support you at every stage

Adding communication features to your product introduces new complexity from infrastructure and scaling to moderation and reliability.

CometChat’s support services are designed to help teams navigate this complexity with confidence, combining immediate assistance, expert guidance, and enterprise-level reliability.

Whether you’re launching your first in-app messaging experience or operating communication features at global scale, the right support ensures your conversations never stop.

CometChat Support Services: Built to support you at every stage

CometChat — Tue, 24 Mar 2026 10:27:08 +0000

When you add real-time communication to your product, be it chat, calls, or AI-driven conversations, reliability becomes critical. Your users expect conversations to work instantly and consistently.

Here’s a closer look at the support services available.

1. Always-On Assistance

When something breaks or a question blocks progress, you need help quickly. CometChat provides multiple ways for teams to get real-time assistance.

24/5 Live Chat Support for instant help with urgent questions
24/5 Email Support for technical queries and troubleshooting
Ticket Support for structured issue tracking
24/7 Emergency Ticket Support for critical incidents

These channels ensure developers and product teams can reach support when they need it, whether during development, testing, or production incidents.

2. Knowledge & Self-Serve Resources

Many teams prefer to move quickly without waiting for assistance. To support this, CometChat provides a comprehensive set of learning resources.

Documentation with detailed implementation instructions
Help Center for quick answers to common questions
Tutorials & Guides to walk through integrations step-by-step
Community Forum for peer discussions and shared solutions
Status Page to monitor system availability and incidents
Feature Request Page to submit product feedback and ideas

These resources help teams integrate features like in-app messaging, moderation workflows, and communication infrastructure without friction.

3. Dedicated Access

For teams operating at scale or building complex communication experiences, direct collaboration with experts can make a major difference.

CometChat offers several options for closer engagement:
Dedicated Slack channel for real-time collaboration with support engineers
Dedicated Customer Success Manager to guide product adoption and strategy
Dedicated Technical Support Engineer for deep technical troubleshooting
Annual Technical Health Check to review architecture, performance, and best practices

This level of access ensures teams always have an expert who understands their implementation and can help optimize it over time.

4. Implementation Guidance

Support includes:

Launch call with an Implementation Manager to review setup and deployment
Dedicated Implementation Engineer for complex integrations
Dedicated Slack channel during implementation for quick coordination

This guidance helps teams avoid common mistakes and get their messaging or calling features live faster.

5. Reliability & Escalation Support

For organizations running mission-critical communication systems, additional escalation paths are available.

These include:

Uptime SLA guarantees (up to 99.999%)
24/7 emergency phone support
24/7 priority email support

These options ensure rapid response and stronger reliability commitments when communication features are central to the product experience.

6. Advanced Technical Support & Optimization

As products evolve, teams often need deeper assistance with scaling, customization, or infrastructure changes.

CometChat provides advanced technical support such as:

Migration assistance when moving from another provider or legacy system
Integration reviews to validate architecture and configuration
Weekly check-ins for ongoing guidance and optimization
UI Kit integration and bespoke customization support

This support ensures teams can fully leverage the platform while maintaining performance and scalability.

7. Live Monitoring & Troubleshooting

Some use cases such as live events, launches, or high-traffic community moments require active oversight.

To support these scenarios, CometChat offers:

Virtual event live monitoring and support
Real-time troubleshooting during critical events

Having engineers actively monitor systems during important moments reduces risk and ensures rapid issue resolution if anything unexpected occurs.

8. Support Prioritization & Response Guarantees

Support plans include:

Guaranteed ticket first response times
Priority Support
Highest Priority Support

These tiers ensure that as your product scales, your support experience scales with it with faster response times, quicker escalations, and greater attention to critical issues when it matters most.

Built to support you at every stage
Adding communication features to your product introduces new complexity from infrastructure and scaling to moderation and reliability.

CometChat’s support services are designed to help teams navigate this complexity with confidence, combining immediate assistance, expert guidance, and enterprise-level reliability.

Whether you’re launching your first in-app messaging experience or operating communication features at global scale, the right support ensures your conversations never stop.

We raised $6.5M. Here's what we're building with it.

CometChat — Wed, 18 Mar 2026 07:32:32 +0000

CometChat started as communication infrastructure - the kind of thing that makes chat, voice, and video work reliably inside your product without you having to build it yourself.

That job still matters. But the question businesses are asking has changed.

It is no longer just "how do I add chat to my app?" It is "how do I make my business actually talk to customers - proactively, intelligently, at scale - without hiring an army to do it?"

That's exactly where we've been headed. And today, we are announcing $6.5M in strategic funding from our existing investors at Run Ventures to build an enterprise-grade platform customers can rely on.

What this round is for

The foundation is already built. This round is about moving faster on what we have already started.

Our AI platform lets businesses build and deploy conversational AI agents - without code, without specialized AI expertise, and without bolting something onto an existing helpdesk and hoping it holds. It is built on a decade of production-grade communication infrastructure, which means the hard parts - reliability, scale, channel coverage - are already solved.

What we are building on top of that foundation has three components:

Proactive outbound intelligence.
Agents that don't wait. They monitor conditions - a restock, a refund delay, an appointment coming up - and reach out before a customer has to.

Multi-agent orchestration.
A visual workflow builder where non-technical teams can coordinate specialized agents (billing, scheduling, recommendations) and define exactly how they hand off, escalate, and stay on-brand.

Customer intelligence layer.
Automatic extraction of preferences and context, so every interaction - across web, SMS, chat, and voice - gets smarter over time.

Where the real leverage is

The businesses where this matters most share a common trait: every customer interaction has a measurable consequence. A missed restock alert, a delayed refund response, an unanswered booking query - in high-transaction verticals, these aren't just experience gaps. They are revenue gaps.

Wellness and beauty. Home services. E-commerce. Hospitality and food service. Healthcare. Financial services. In these verticals, responsiveness and proactive outreach don't just improve experience - they compound into retention.

Our Co-Founder & CEO, Anuj Garg, puts it plainly: "The current fund raise is specifically done to accelerate our AI play. Our GTM in this vertical would be to target high-transaction verticals like wellness & beauty, home services, e-comm, hospitality & food service where the combination of inbound responsiveness and proactive outreach drives measurable retention and revenue outcomes. In the last 12 months, we have surpassed 2 billion messages sent through our platform, launched CometChat AI to transition from a communication infra provider to an AI agent platform. Our existing investors see the value in adding such key services to our offerings and hence decided to back us with growth capital to accelerate our growth trajectory."

Run Ventures has been with us since early on, and it's their conviction in this direction that shapes how we think about the road ahead. As Brandon Tidwell, Co-founder & GP, puts it: "We have witnessed how methodically Anuj and Anant have scaled the business to make CometChat an intelligent communication layer with several proven use cases. The company has been piloting its AI platform with encouraging early signs as enterprise customers have come onboard. This growth funding will help CometChat to further expedite its AI strategic play."

That early enterprise signal is exactly what this capital is for.

What the next 12-18 months look like

Three things, in plain language:

Move pilot customers into full production.
We have early enterprise deployments showing good signal - now we scale them.
Build the GTM infrastructure to support large deployments.
Sales, solutions engineering, customer success — the parts that make enterprise software actually work for customers.
Establish real depth in the verticals where AI-driven, proactive customer engagement has a measurable impact on the bottom line.

Total funding raised to date: $21.1M. A lot of messages sent. More to go.

If you are building in one of these spaces and want to see what this looks like in practice - we are here. And if what you need is reliable, scalable chat, voice, or video - we have been ready for that one for a while.

For press enquiries - shradha.ramprasad@cometchat.com

Official press release available on PR Newswire

Frontend Actions for AI Agent Builder

CometChat — Fri, 13 Mar 2026 08:30:31 +0000

We're excited to introduce Frontend Actions for CometChat's Agent Builder. This new capability transforms your AI agents from purely conversational interfaces into interactive drivers of your application's UI, enabling them to trigger client-side behaviors like opening modals, navigating to pages, showing notifications, and executing custom functions directly in response to user conversations.

With Frontend Actions, your agents can now do more than just talk - they can act. Instead of telling users where to go or what to do, agents can guide them there, opening the right dialog, navigating to the correct page, or triggering the appropriate workflow based on conversational context. All of this happens seamlessly through your existing UIKit components, with no additional infrastructure required.

Why does this matter to me, as a developer?

As you build AI-powered chat experiences, static text responses often fall short of creating truly helpful user journeys. Users frequently need more than information - they need action. Without a structured way to bridge conversation and UI, you're left manually building complex routing logic or asking users to navigate on their own after receiving guidance.

Frontend Actions helps you:

Enable agents to drive user workflows by triggering UI interactions directly from conversation context.

Eliminate the gap between agent recommendations and user actions with seamless handoffs to modals, forms, or other UI elements.

Maintain clean architecture by keeping action handlers in your client code while letting agents decide when to invoke them.

The result is more intuitive user experiences, reduced development overhead, and agents that feel like natural extensions of your application instead of bolted-on chatbots.

Key features and capabilities

Client-side behavior triggers

Define actions that agents can invoke to open modals, navigate pages, display notifications, pre-fill forms, or call any custom function in your application. Agents determine when to trigger these actions based on conversational context, turning passive responses into active guidance.

Flexible action configuration

Each Frontend Action requires:

A display name for dashboard clarity
A description that teaches the agent when to use it
A trigger function identifier your client app recognizes
Optional parameters to pass contextual data.

This configuration lives in the Agent Builder dashboard, keeping your action definitions centralized and version-controlled alongside other agent capabilities.

Dynamic personalization with Variables

Frontend Actions integrate seamlessly with CometChat's Variables system, enabling you to inject dynamic, user-specific data into action parameters. This means your actions can be personalized based on who's using them and the context of the conversation.

Variables come in two types:

Auth Variables (automatically provided):

@var-auth:sender.uid - unique identifier of the message sender
@var-auth:sender.name - display name of the message sender
@var-auth:sender.role - role of the message sender

Custom Variables (user-defined with three source types):
Constant - static values like API keys or company name

Message Metadata - extracts data from message.data.metadata (e.g., orderId, sessionType)

User Metadata - extracts data from sender's user metadata (e.g., subscription tier, department)

For example, when your agent opens a support form, you can pass @var-auth:sender.name to pre-fill the name field and @var-custom:subscriptionTier to automatically route them to the right support queue. When navigating to an order details page, inject @var-custom:orderId to deep-link directly to the relevant order.

Variables are managed in the Agent Builder's Variables section and can be referenced in both agent instructions and Frontend Action parameters using the @ syntax.

Per-agent enablement

Every Frontend Action can be toggled on or off for individual agents. Once enabled, agents can intelligently decide to use the action based on its description - no explicit instruction required. For more control, you can reference actions directly in agent instructions to provide nuanced guidance on when they should be triggered.

Real-time SDK integration

When an agent invokes a Frontend Action, your client application receives it as a tool call event through the SDK. Register action handlers with your UIKit component using the aiAssistantTools property, mapping trigger function identifiers to callback functions. UIKit automatically routes tool calls to the correct handler, passing along any parameters the agent provided.

Orphaned action detection

If a Frontend Action is deleted, renamed, or disabled after being referenced in agent instructions, the dashboard displays a warning indicator. This makes it easy to spot and fix broken references before they impact production experiences.

Interesting tech details

Under the hood, Frontend Actions leverage the same tool-calling infrastructure that powers API integrations, but instead of making external requests, they trigger client-side JavaScript callbacks. This design keeps your application logic where it belongs, in your codebase, while giving agents the intelligence to invoke it at the right moments.

The action invocation flow is event-driven. When an agent determines a Frontend Action should fire, it generates a tool call that propagates through the real-time SDK layer. Your registered handler receives the trigger function identifier and parameters, executes your custom logic, and the conversation continues seamlessly. There's no server round-trip required for these interactions, keeping response times fast and UX smooth.

Variables are resolved server-side before actions reach your client. Auth variables pull from the authenticated user context, Message Metadata variables extract values from message.data.metadata using path-based lookups, User Metadata variables query the sender's user object, and Constants return their configured static values. Your action handlers receive clean, ready-to-use data without additional resolution logic.

Reference links

CometChat Documentation

Frontend Actions gives you a structured, scalable way to connect agent intelligence with application behavior, so you can focus on building conversational experiences that truly help users get things done.