DEV Community: Shrinithi V

Weekly news roundup: The moat moved off the model, onto everything around it.

Shrinithi V — Mon, 21 Sep 2026 08:12:02 +0000

TSMC bets $31 billion on AI's future

What's going on?
TSMC is dropping $31.4B on three new Taiwan fabs for sub-1.4nm chips with AI data centers now making up two-thirds of its revenue, up from smartphones.

Why it matters?
More advanced silicon means more horsepower for AI. But the first fab won't ship until ~2030, so the compute crunch everyone's feeling isn't easing anytime soon.

How we see this at CometChat
Every AI agent including the ones answering support chats and moderating conversations runs on this silicon. The smarter agents get, the hungrier they are for compute. Worth watching who's actually building the supply.

The AI lead just changed hands

What's going on?
Anthropic is weighing a new model launch after OpenAI's GPT-6 Astra pulled ahead in enterprise spend - days after Anthropic's CEO publicly urged the whole industry to slow down.

Why it matters?
A two-and-a-half-year lead just cracked. When frontier labs sprint, the models under your apps get smarter and cheaper faster than your roadmap can react.

How we see this at CometChat
‘Slow down’ one week, ‘maybe ship’ the next - the tension is real. But if you're building AI agents into your product, model churn is the actual story. Pick an abstraction layer that survives whichever lab wins the month.

Cancer-detecting AI is now free

What's going on?
Alibaba open-sourced Damo Radar - a model that spots nearly 150 abdominal diseases, including cancers, from CT scans, and it beat 23 of 26 radiologists in testing.

Why it matters?
A smaller hospital with no in-house AI team can now run expert-level diagnostics for free. When radiologists used it as an assistant, missed diagnoses dropped 10% and reads got 30% faster.

How we see this at CometChat
The pattern that makes this work - pairing images with clinical reports so the model actually understands context is the same reason AI agents are getting good at conversations. Context is everything. A model that reads the whole picture beats one guessing from fragments, whether it's a CT scan or a support thread.

One config file to rule them all

What's going on?
Claude Code now reads AGENTS.md - the open instruction format already used by Cursor, Codex, and 60,000+ repos so you stop maintaining a separate file for every AI coding tool.

Why it matters?
Fewer redundant configs, fewer symlink hacks. One markdown file tells every agent your build commands, test rules, and code style. Small change, real relief.

How we see this at CometChat
Standards winning over walled gardens is always the good ending. The same instinct applies to how AI agents plug into your product - shared, portable, boring-in-the-best-way conventions beat bespoke glue code that only one tool understands. Interoperability isn't glamorous. It's just what keeps things working.

Voice AI just got 13x cheaper

What's going on?
Google launched Gemini 3.8 Live - voice models that talk, see, switch across 97 languages mid-sentence, and run background tasks while chatting. Extended Thinking topped OpenAI's GPT-Live-1 on quality, at roughly 1/13th the cost.

Why it matters?
Real-time voice agents just went from ‘nice demo, wild bill’ to something you can actually run in production. Price was the wall. That wall's coming down.

How we see this at CometChat
‘Let me check that…’ while the agent works in the background - that's not a model detail, that's conversation design. Voice agents live or die on whether the interaction feels human under real latency. The model's getting cheap. Making it feel good is still the hard part.

Enterprise Chat Architecture in 2026: How In-App Chat is Actually Built at Scale

Shrinithi V — Sun, 20 Sep 2026 06:34:38 +0000

Enterprise chat architecture is the set of backend systems that move messages between users reliably, in order, and fast: a real-time connection layer for live clients, a durable event pipeline for ordering and delivery, tiered storage for history and media, and a presence layer for who's online. To keep this concrete, the examples here come from a real system instead of a generic diagram: CometChat's architecture, which runs across 113,000+ apps in 163 countries at a 99.999% uptime SLA. CometChat is a chat and messaging platform for developers, and working from an actual stack means naming real databases and real numbers, not vague claims about ‘scalable infrastructure.’

Get those four systems right and chat feels instant. Get one wrong and it feels instant right up until real load arrives. This is the engineering piece, not the buyer piece: if you're an architect or senior engineer deciding whether to build in-app chat or buy it, here's how the system actually works under the hood, and the parts most teams underestimate until they're debugging them at 2am

The four systems chat actually is

In-app chat is four coupled systems wearing one trench coat. Each has its own failure mode, and they fail on different nights.

Connection layer: persistent WebSocket connections, one per active client, carrying events in both directions.
Event pipeline: the durable log that decides ordering, guarantees delivery, and fans each message out to recipients.
Storage: where message history, metadata, and media live, each with a different access pattern.
Presence: who's online, typing, idle, or gone, updated in real time.

Build any one of these badly and you don't find out on launch day. You find out at scale, in production, in front of users who are not impressed.

Message delivery guarantees: what ‘delivered’ has to mean

A message delivery guarantee is the contract for whether a message can be lost, duplicated, or reordered when something fails. There are three flavors: at-most-once (fast, drops messages), at-least-once (safe, duplicates messages), and exactly-once (the one everyone wants on the whiteboard and nobody gets for free).

Real chat backends aim for effectively-once: idempotent producers, automatic retries, offline queuing, and sync across devices, so a flaky network produces one message on every device - not zero, and not three. CometChat's pipeline is built on exactly this set: effectively-once semantics using idempotent producers, retry logic, offline message queuing, and synchronization across a user's devices.

The happy path is not the problem. The problem is the client that dropped into a tunnel mid-send, reconnected four minutes later, and expects its message to land once, in the right order, on the phone and the laptop and the web tab it forgot to close. Ordering and deduplication under failure are the actual product. Everything else is UI.

This is why serious stacks put a real commit log in the middle. CometChat uses Apache Kafka as the event backbone: guaranteed message ordering, no message loss, sub-second latency, and configurable retention. The log is what lets you make promises about ordering that survive a retry without one, ‘in order’ is a hope, not a guarantee.

Presence: the feature that lies to you

Presence is the system that tracks who's online, typing, or idle, in real time, across every device. It sounds simple. It is not, and it tends to prove that in front of users.

Presence is high-frequency, low-value, and unbounded - the worst combination in distributed systems. Every keystroke can fire a typing event. Every reconnect can fire an online event. Open a group with 3,000 members and, done naively, you've signed up to push 3,000 presence updates to every one of them, continuously. That's not a chat feature. That's a self-inflicted DDoS with a green dot on it.

The fixes are unglamorous and mandatory: debounce typing events, batch presence changes, scope presence to the conversations a user is actually looking at, and treat ‘last seen’ as eventually consistent instead of real-time. CometChat handles presence and typing indicators over its WebSocket Gateway - persistent bi-directional connections with automatic reconnection and session recovery and exposes WebSocket-level control so you can define custom presence logic instead of accepting "is the socket open" as the answer. Because "is the socket open" is almost never the question you actually mean.

Fan-out at scale: where the math stops being cute

Fan-out is the work of turning one sent message into delivery events for every recipient's active connections. For 1:1 chat it's trivial. For a 10,000-member group where 3,000 people are online, each on two devices, one message becomes 6,000 delivery events (3,000 × 2) and something has to route all of them without tipping over.

Two things keep this sane. First, a connection layer that scales horizontally: CometChat runs on a stateless service design, so you add capacity by adding compute, not by re-architecting or migrating data. Second, the event log in the middle. With Kafka handling routing and ordering centrally, delivery is guaranteed once - not renegotiated per connection while 6,000 sockets wait.

Concrete numbers, since ‘highly scalable’ is a phrase and not a fact: CometChat's Docker Swarm tier is built for up to ~200,000 monthly active users and ~20,000 peak concurrent connections, at sub-100ms message latency. Past that - 200k+ MAU or multi-region - the deployment moves to Kubernetes. The whole platform is engineered from 10,000 to 250,000+ MAU with linear scaling. Those are the kind of numbers you want in a capacity plan, not adjectives.

Storage: one database is a lie you tell yourself early

Chat storage is polyglot by necessity. No single database is good at hot reads, durable history, media blobs, and rate-limit counters at the same time, and the classic early mistake is making one try. It works beautifully in staging and falls over the first quarter you have real history to query.

Here's how CometChat's on-premise stack splits the job:

Layer	What it stores	Technology	Why this one
Distributed SQL	Messages, conversations, users — the source of truth	TiDB (PD + TiKV with Raft, MySQL-compatible SQL layer)	ACID transactions, automatic sharding, multi-region replication, strong consistency
Document store	Moderation policies, custom metadata, webhook config, audit logs	MongoDB	Flexible schema, native JSON, rich queries on semi-structured data
In-memory	Cache, sessions, auth tokens, rate-limit counters	Redis clusters (cache + session/rate-limit)	Sub-millisecond latency for the highest-frequency operations
Object storage	Files, images, large binary attachments	S3-compatible (S3, MinIO, Ceph, GCS)	Lifecycle policies, versioning, encryption at rest, tiered cost
Event log	Ordering and delivery backbone	Apache Kafka	Guaranteed ordering, no message loss, configurable retention

The part people miss: message history grows forever and gets queried constantly. The database that felt fine at 10 million messages is a different animal at 10 billion, and by then you're not choosing a database - you're migrating one, live, while people are talking. Distributed SQL with automatic sharding exists so that day never arrives.

Data residency: the requirement that rewrites your topology

Data residency is the rule that a user's data must be stored and processed inside a specific legal jurisdiction. It is not a settings toggle. It's an architectural constraint that shows up before you write a line of code, because it dictates where your databases physically sit and how your regions replicate.

If you serve regulated industries or the EU, this decides your deployment model, not the other way around. CometChat supports the full range: managed cloud, private cloud in a specific region, hybrid, and fully air-gapped on-premise where data never leaves your infrastructure. It's built to meet GDPR, HIPAA, SOC 2, ISO 27001, CCPA, and PIPEDA, with encryption at rest, configurable key management, and secure WebSocket connections. Multi-tenancy gives you logical isolation with per-tenant configuration, rate limits, and quotas, which matters the moment one deployment serves several business units that legal insists cannot see each other's data.

The reframe worth keeping: residency isn't a feature you bolt on later. Retrofitting jurisdiction into a single-region system is a rebuild, not a config change. Decide it first.

Where it breaks at 2am

The four systems are the easy part to name and the hard part to keep alive. The failures that actually page you:

Reconnection storms. A region blips, thousands of clients reconnect at once, and your connection layer plus session store take the full spike simultaneously. Without session recovery and stateless gateways, this cascades.
Presence fan-out. The green dot that felt free in testing becomes the single largest source of traffic in production.
Group fan-out. Big groups turn one message into thousands of writes and pushes. Linear-looking code, quadratic-feeling bill.
Ordering under retry. Messages arrive, but out of order or twice, because the retry path didn't go through the log. Users notice instantly.
History queries. The read that was instant at launch times out once there's real backlog to scan.
Cross-region replication lag. Two users, two regions, one conversation, and a few seconds of disagreement about what was said.

None of these show up in a demo. All of them show up at scale. That's the whole reframe of operating chat instead of shipping it: the work isn't the feature, it's the years the feature has to keep working.

Build vs buy, without the sales pitch

Building this in-house is entirely possible - it's also months of work before your first message, and years of the failures above before it's boring. If chat is your core product and your differentiator, build it. If chat is a feature your product needs to have and keep working, the math usually points the other way.

Either way, now you know what the system is actually made of, and which parts to interrogate before you commit. If any of this resonated, that's the part worth getting right first.

CometChat's enterprise chat infrastructure, in one place

CometChat's enterprise infrastructure is the four systems above, already built and already surviving the 2am failures - a stateless WebSocket Gateway for connections and presence, an Apache Kafka backbone for ordered, no-loss delivery, polyglot storage (TiDB, Redis, MongoDB, S3-compatible object store) tuned per access pattern, and multi-tenancy with per-tenant isolation, rate limits, and quotas.

It runs where your compliance team needs it to: managed cloud, region-pinned private cloud, hybrid, or fully air-gapped on-premise where data never leaves your infrastructure - built to meet GDPR, HIPAA, SOC 2, ISO 27001, CCPA, and PIPEDA, with encryption at rest, configurable key management, and secure WebSocket connections. It scales linearly from 10,000 to 250,000+ monthly active users at sub-100ms message latency, on Docker Swarm up to ~200k MAU and Kubernetes beyond that.

The point isn't the feature list. It's that presence fan-out, ordering under retry, reconnection storms, and residency-driven topology are already handled - so your team ships the product and skips the years of learning which of these breaks first. Speed becomes sustainability. Shipping becomes operating. That's the whole trade.

Want to see the stack instead of read about it? Start for free and build against it, or contact sales if you're sizing a deployment for real load, data residency, or an on-premise rollout.

FAQ

What is enterprise chat architecture? It's the backend that delivers messages reliably, in order, and fast at scale - a real-time connection layer, a durable event pipeline for ordering and delivery, polyglot storage for history and media, and a presence layer. Enterprise adds data residency, compliance, and multi-tenancy on top.

What message delivery guarantee does chat need? Effectively-once: one message on every device, even after a dropped connection and retry. Pure exactly-once is expensive and rare, so real stacks combine idempotent producers, automatic retries, and offline queuing to reach effectively-once in practice.

How many concurrent connections can a chat backend handle? It depends on architecture, not vibes. CometChat's Docker Swarm deployment targets ~20,000 peak concurrent connections and ~200,000 MAU at sub-100ms latency; beyond that, Kubernetes handles 200k+ MAU and multi-region, scaling linearly to 250,000+ MAU.

What database should I use for chat? More than one. Distributed SQL (like TiDB) for the message source of truth, Redis for hot cache and sessions, a document store for metadata and audit logs, object storage for media, and a log like Kafka for ordering. No single database does all of that well.

Do I need Kafka for chat? You need a durable, ordered event log; Kafka is the common choice. It's what lets you guarantee ordering and no message loss centrally, so those promises survive retries and reconnects instead of being renegotiated per connection.

How do I meet data residency requirements for chat? Decide the deployment model before you build. Options are managed cloud, region-pinned private cloud, hybrid, and air-gapped on-premise. CometChat supports all four and is built to meet GDPR, HIPAA, SOC 2, ISO 27001, CCPA, and PIPEDA. Retrofitting residency into a single-region system is a rebuild, so choose first.

News Roundup: Different stories, same punchline: the hard part isn't the model, it's the operating.

Shrinithi V — Wed, 16 Sep 2026 08:00:35 +0000

The UN wants a word about AI

What's going on?
The UN's human rights chief is urging governments and AI companies to slow down and set real guardrails, warning that frontier AI is moving faster than anyone's ability to govern it.

Why it matters to you?
‘Move fast’ is fun until someone asks who's accountable. Regulation is coming, and teams building with AI will need to show their work - safety, oversight, the boring parts.

What we think
Same lesson we keep learning with chat: capability without accountability doesn't scale. AI agents in production need guardrails, not just good demos. Ship fast, but build like it's staying.

SpaceX wants data centers in orbit

What's going on?
Musk says SpaceX will launch Nvidia AI computers into space next year, part of a plan to run data-center-class computing in orbit through its Starmind program.

Why it matters to you?
Compute is the new bottleneck, and everyone's hunting for somewhere to put it. Space is either the next frontier or a very expensive detour - one analyst called the trend ‘peak insanity.’

What we think
Love the ambition. But orbit or ground, the hard part is the same: reliability under real load. Chat taught us that lesson too - infrastructure only impresses when it holds up where users actually are.

Voice AI that stops talking over you

What's going on?
OpenAI opened GPT-Live-1 to developers - a full-duplex voice model that listens and speaks at once, cutting turn-taking lag from 1.4 seconds to 0.8 and skipping the clunky speech-to-text-to-speech pipeline.

Why it matters to you?
Voice agents have always felt like walkie-talkies: wait, beep, respond. Killing that latency is the difference between a demo and something people actually want to talk to.

What we think
Real-time is everything in conversation - text or voice. The magic isn't the model, it's the milliseconds. Same reason chat lives or dies on how fast it feels. Latency is the product.

Arm goes from blueprint to builder

What's going on?
Arm unveiled a 128-core cloud chip and a production-ready AGI CPU in Shanghai - its biggest move yet from licensing designs to selling finished silicon, straight at Intel and AMD's turf.

Why it matters to you?
More Arm servers means real choice in the cloud, and agentic AI workloads are the reason. Analysts see Arm's server share nearly doubling by 2028.

What we think
The interesting part isn't the core count - it's why. Agentic workloads are reshaping the hardware underneath them. Same story up the stack: AI agents change what you build on, all the way down.

Faster images, launched on a rough day

What's going on?
OpenAI shipped ChatGPT Images 2.5 - up to 50% faster, sharper edits, a new sketch-to-image feature - the same day it was firefighting an outage breaking image generation for hundreds of users.

Why it matters to you?
Better creative tooling is great. But the timing is the real lesson: your launch is only as good as the infrastructure holding it up when everyone shows up at once.

What we think
Shipping features is the fun part. Keeping them up under load is the job. Chat taught us that the hard way - the demo always works, production is where you find out.

Europe's biggest tech raise ever

What's going on?
Mistral raised €3bn at a €21bn valuation - Europe's largest private tech round - led by Samsung, doubling its worth in a year as it pivots from model maker to full-stack ‘neocloud.’

Why it matters to you?
More serious players means more real choice: open-weight models, dedicated compute, and the pitch of keeping your own data. Useful leverage when the big American labs set the terms.

What we think
The pivot is the tell. Making a model is one thing. Running the infrastructure customers actually trust in production is another. Everyone eventually learns the hard part isn't the model - it's the operating.

News Roundup: Compute got scarce. Efficiency stopped being optional.

Shrinithi V — Mon, 07 Sep 2026 15:51:37 +0000

AI That Finds Its Own Zero-Days

What's going on?
OpenAI launched GPT-6 Astra - the first model that can independently discover and exploit unknown software vulnerabilities, and it's pairing that with $1B for cyber defenders.
Why it matters
Attackers get frontier tools the day they ship. Now defenders do too but only if they move first. The gap between ‘we should patch that’ and ‘someone already did’ just got shorter.
What we think at CometChat
Same story we know well: capability without accountability breaks things at scale. Powerful AI agents - in security or in chat need guardrails built in, not bolted on later. Ship fast, but ship safe.

Samsung and Arm Build 2nm AI Chip

What's going on?
Samsung and Arm kicked off a custom 2nm chip built to run AI directly on your device with OpenAI rumored to be the end customer.
Why it matters
On-device AI means less round-tripping to the cloud. Lower latency, less dependence on someone else's servers, and inference that happens where your users actually are.
What we think at CometChat
The whole industry is quietly moving intelligence closer to the edge. For chat and AI agents, that's the good direction - faster responses, private by default. The interesting part isn't the silicon. It's what you build on top of it.

Chip Gear Spending Hits Record $40B

What's going on?
Semiconductor equipment billings hit a record $40.53B last quarter - the second record in a row as chipmakers race to build capacity for AI.
Why it matters
Memory is booked solid through 2027, and new capacity won't land before 2028. Translation: the compute powering your AI features is getting pricier and scarcer, not cheaper.
What we think at CometChat
When infrastructure is this constrained, efficiency stops being optional. For AI agents and chat at scale, every wasted call costs real money. The teams that win won't be the ones with the most compute - they'll be the ones who waste the least.

$3.5B Bet on Humanoid Robots

What's going on?
Nscale is committing $3.5B in compute (scaling to $6B+) to power Figure's humanoid robots 100,000 Nvidia GPUs, plus an equity stake in the robotics startup.
Why it matters
Physical AI is getting real money and real infrastructure. Robots that learn, adapt, and operate in the world all run on the same thing your software does: massive, expensive compute.
What we think at CometChat
The line between ‘AI in an app’ and ‘AI in a body’ is thinner than it looks. Both need the same foundation - models that respond fast and reliably. Whether it's a robot in a warehouse or an agent in a chat, the hard part was never the demo. It's making it work every time.

Xiaomi Debuts Its Own 3nm Chips

What's going on?
Xiaomi unveiled three in-house chips at IFA - a 3nm flagship phone SoC, an edge AI accelerator, and an autonomous driving chip reducing its reliance on Qualcomm and MediaTek.
Why it matters
When a company owns its silicon, it controls the whole stack - performance, power, and how AI runs on-device. That's tighter integration and less waiting on someone else's roadmap.
What we think at CometChat
The edge AI chip is the one to watch - 330 tokens per second, running inference right on the device. As more intelligence moves on-device, chat and AI agents get faster and more private by default. The demo is easy. Owning the whole pipeline is the hard, smart part.

Google Recycles Old Chips to Survive

What's going on?
Google is pulling DDR4 memory from retired servers and adapting it for new AI machines - a stopgap as the memory shortage bites and prices climb up to 90% in a quarter.
Why it matters
Even the biggest players can't buy their way out of this. Memory now eats ~30% of hyperscaler budgets, up from 8% two years ago. The cost of running AI is being reshaped by a shortage that lasts through 2030.
What we think at CometChat
Efficiency just became a survival skill. When compute and memory are this scarce, the winners aren't the ones spending the most - they're the ones getting more out of less. For AI agents and chat at scale, lean beats lavish. Every wasted call has a price now.

Marketplace Chat UI Kits for Faster In-App Chat

Shrinithi V — Sun, 06 Sep 2026 18:02:35 +0000

An in-app chat UI kit is a package of prebuilt, drop-in UI components - conversation list, message list, composer, calling screens that already handle the SDK wiring, real-time listeners, and local state, so you can ship a working chat experience in an afternoon instead of a sprint. You install the package, drop the components into your layout, connect your app credentials, and it works. CometChat is a chat and messaging platform for developers, and its UI Kits ship these components across React, React Native, Flutter, Angular, iOS, and Android.

If you've already decided you want a kit, this is the part you care about: what's in the box, what you no longer have to build, and where the time actually goes.

The part nobody scopes: the features that are trivial until they aren't

The chat backend is the easy part. The UI is where the weeks go. Typing indicators, presence, read receipts, threads, unread counts, retry logic, message lists that scroll the correct direction, real-time listeners that don't leak when a component unmounts - none of that shows up in the demo, all of it shows up in production. The CometChat UI Kit exists precisely so you don't rebuild that pile from scratch. Every CometChat component manages its own data loading, its own listeners, and its own state. You compose, you don't wire the SDK by hand.

What the CometChat UI Kit gives you out of the box

These are the core CometChat components. Map them straight to your sprint board.

CometChat component and what it handles for you

Conversations - Recent-chats list with previews, timestamps, unread counts, live updates
Message List- Renders text, media, and custom messages; read/delivery receipts; reactions; scroll behavior
Message Composer- Rich input with attachments, emoji, typing events, custom message types
Users- Browsable user directory with online presence indicators
Groups & Group Members- Create and manage groups, roles, and membership
Threads- Follow and reply in threaded conversations without losing the main chat
Calls UI- Optional voice and video calling screens powered by the CometChat Calls SDK Every CometChat component is themeable (CSS variables in React V7, native theming on the other platforms) and localized, so matching your brand doesn't mean forking the kit.

What you're not building yourself

This is the real value. Each of these is a small feature to describe and a large feature to get right at scale, and each one ships inside CometChat's components already.

Typing indicators: the debounced ‘user is typing’ events, wired to the CometChat Message Composer.

Presence: online/offline/idle status, tracked in real time across devices via the CometChat SDK.

Read and delivery receipts: sent, delivered, and seen states, kept in sync in the Message List.

Threads: nested replies that don't corrupt the main message order.

Unread counts: accurate badges across conversations, updated live in the Conversations list.

Real-time plumbing: CometChat's listeners attach and clean up correctly, so you're not chasing memory leaks after launch.

Building these reliably yourself is typically weeks of frontend work that has nothing to do with your actual product. CometChat is the part you don't spend those weeks on.

Before and after: realistic build time

From scratch: connect the SDK, build the conversation list, build the message list with receipts and reactions, build the composer, wire presence and typing, handle threads, handle unread state, then debug the real-time edge cases in production. Weeks, and the last 20% is where chat breaks during a demo.

With the CometChat UI Kit: install the package, add your App ID, Region, and Auth Key from the CometChat dashboard, drop in the components you need, style to taste. CometChat installs the Chat SDK and initializes setup, login, real-time events, and theming for you. A working chat screen in an afternoon; a polished, production-shaped one in days, not weeks. You spend your time on the parts of your product that are actually yours.

FAQ

What's the difference between a chat SDK and a chat UI kit? The SDK gives you the messaging engine and APIs; the UI kit gives you prebuilt screens on top of it. The CometChat UI Kit installs the Chat SDK for you, so you get both in one step.

Can I customize the components or am I stuck with the default look? You can customize them. Components are themeable and composable - in React V7 you compose only the pieces you need (Root, View, EmptyState, and friends) and theme with CSS variables. Other platforms use native theming.

Which platforms does the CometChat UI Kit support? React (including Next.js, React Router, Astro), React Native, Flutter, Angular, iOS (SwiftUI), and Android (including Jetpack Compose).

Do I still need a backend? No. CometChat hosts the messaging infrastructure. You connect with your app credentials and the components handle the real-time events.

How long does integration actually take? With the CometChat UI Kit, a working chat screen takes an afternoon: install, add your credentials, drop in components. Production polish - theming, layout, edge cases usually lands in days.

Chat looks simple, right up until file attachments, threads, and reactions turn a feature into something you maintain indefinitely. A kit is how you get the working version without signing up for the boring parts twice.

News Roundup: The frontier moved from "can it?" to "can you trust it?"

Shrinithi V — Thu, 03 Sep 2026 08:32:49 +0000

Gemini Now Runs Your Tasks Solo

What's going on?
Google gave Gemini Live an agentic upgrade - you speak a goal out loud, and it runs multi-step tasks across Docs, Sheets, Gmail, and Drive on its own.
Why it matters?
Voice stops being just Q&A. Assistants now remember your intent and act on it for days - no app-switching, no babysitting the workflow.
How we see it at CometChat
This is where conversation becomes the interface. The hard part isn't making an agent talk, it's making it act reliably across a real product. Agents are only as good as the messaging layer they run on.

Nvidia's Robots Just Hit $10 Billion

What's going on?
NVIDIA's physical AI arm - chips for robots, self-driving cars, and drones now pulls in ~$10B a year, with China shipping 97% of the world's humanoid robots.
Why it matters?
The ‘ChatGPT moment’ for robots isn't coming - Huang says it already passed. Physical AI is scaling from demos to factory floors, fast.
How we see it at CometChat:
A robot that moves is impressive. A robot you can actually talk to, that understands context and responds in real time - that's the harder problem. Intelligence in hardware still needs a conversation layer that doesn't fall over.

Meta's New Agent Shops, Books, and DJs

What's going on?
Meta is testing ‘Project Hatch’ - a personal AI agent with its own computer that books restaurants, orders food, buys gifts, and even runs your Spotify, all in the background.
Why it matters?
Agents are moving from answering questions to taking actions across your real apps and accounts - email, calendar, OpenTable, DoorDash. The interface is becoming a delegate.
How we see it at CometChat
Handing an agent your calendar is easy. Handing it your conversations is where trust gets real. When agents start acting on your behalf, the messaging layer has to be reliable, secure, and legible because ‘it booked the wrong thing’ is a much bigger problem in production than in a demo.

Google's AI Video Now Directs, Not Just Generates

What's going on?
Gemini Omni 1.1 Flash adds 4K upscaling, keyframe transitions, and scene extension up to 40 seconds giving AI video an actual beginning, middle, and end.
Why it matters?
The pitch shifts from ‘generate a clip’ to ‘direct a scene.’ Cheap 360p drafts, polished 4K finals - a workflow real production teams can actually use.
How we see it at CometChat
Every leap in AI-generated content raises the same question: how do people talk about it, react to it, share it? Richer media only matters if the room around it - comments, threads, live reactions can keep up. The content gets better; the conversation layer has to too.

AI Guides World-First Brain Tumour Surgery

What's going on?
Surgeons in London removed a brain tumour using real-time AI that colour-coded critical vessels and nerves on a live video feed - saving a 48-year-old's eyesight.
Why it matters?
AI as an ‘expert second pair of eyes,’ trained on more operations than a surgeon sees in a lifetime. Not replacing the human rather assisting the highest-stakes decisions in real time.
How we see it at CometChat
The surgeons kept full control the whole way - the AI advised, humans decided. That's the model that works. Whether it's an operating theatre or a support chat, the best AI doesn't take over the conversation. It gives people better information at the moment they need it, and lets them make the call.

Hyundai Bets Big on Self-Driving by 2028

What's going on?
Hyundai and NVIDIA are teaming up to put Level 2+ self-driving in mass-market cars by 2028, backed by a 50,000-GPU data centre and an in-house AI system.
Why it matters?
Self-driving stops being a luxury demo. When 12 of every 20 new cars in China already ship with Level 2+, autonomy becomes a standard feature buyers expect, not a moonshot.
How we see it at CometChat
Hyundai's whole bet is the ‘data flywheel’ - collect, train, deploy, repeat. Same logic applies to how products talk to users: every conversation is a signal. The teams that win aren't just shipping AI features, they're building the feedback loop that makes each interaction smarter than the last.

News Roundup: From open source models to cheaper inference cost.

Shrinithi V — Tue, 04 Aug 2026 13:16:36 +0000

AMD takes direct aim at Nvidia

What's going on?
AMD unveiled Helios - a rack packing 72 MI455X GPUs and 31TB of memory with Microsoft, Meta, OpenAI, and Oracle already signed on as customers.
Why it matters?
Nvidia still owns ~95% of the data centre GPU market. A credible rival with big-name backing means real competition, and eventually better pricing for anyone running AI at scale.
What we think at CometChat
More memory per rack sounds like plumbing until you're the one serving a million-token context to real users. The infrastructure race is quietly deciding what AI features you can actually afford to ship. We're watching closely.

Nvidia lands $500B in Asia AI deals

What's going on?
Jensen Huang spent two weeks in Japan and South Korea, striking partnerships to wire AI into factories, robots, and a 2-gigawatt data centre with SK Group.
Why it matters?
This is AI leaving the chatbox and moving into the physical world - factories, machines, sovereign infrastructure. The compute buildout underneath everything just got a lot bigger.
What we think at CometChat
Robots and factories still need to talk - to each other, to operators, to the humans in the loop. As physical AI scales, the coordination layer stops being a nice-to-have. That's the boring part that decides whether any of it works.

Alibaba open-sources its biggest model yet

What's going on?
Alibaba dropped Qwen3.8-Max - 2.4 trillion parameters, competitive with the best from OpenAI and Anthropic, and open-sourced with weights coming next week.
Why it matters?
A frontier-class model you can download and run yourself changes the math. Less vendor lock-in, more control, and a serious option for agentic coding and research.
What we think at CometChat
Every capable open model raises the same quiet question: who's operating this in production? The model is the easy part. Wiring it into real conversations, agents, and users is where the actual work starts and where it usually breaks.

Qualcomm buys Modular to take on CUDA

What's going on?
Qualcomm closed its $3.9B acquisition of Modular Chris Lattner's AI software company betting on a vendor-neutral layer that runs AI across any chip, not just NVIDIA's.
Why it matters?
CUDA lock-in has kept teams tied to one vendor for years. A real cross-silicon software layer means more choice on where and how cheaply you run AI.
What we think at CometChat
The interesting fights are moving up the stack, from hardware to the software that makes it usable. Same story with chat and agents: the chip matters less than the layer that turns it into something people actually talk to.

AMD undercuts Nvidia on inference cost

What's going on?
New benchmarks show AMD's MI355X running the 2.8-trillion-parameter Kimi K3 model at under half the per-token cost of Nvidia's B300.
Why it matters?
Nvidia still wins on raw throughput, but AMD wins on tokens per dollar. For anyone running big models in production, that math adds up fast.
What we think at CometChat
Inference cost is the boring part nobody plans for right up until your AI features hit real usage. When chat and agents scale, the bill scales with them. Cheaper tokens mean more room to actually ship the good stuff.

News Roundup: From AI models to AI in cancer prediction

Shrinithi V — Wed, 08 Jul 2026 08:25:15 +0000

1. Google Just Made AI Media Cheap

What's actually going on?
Google shipped two new models - one makes images in 4 seconds, the other makes 10-second videos with built-in audio. Both cost fractions of a cent per output.
Why does that matter to you?
A/B testing ad creative used to mean a production budget. Now it means an API call. Teams can generate, test, and kill ideas before lunch.
What we think at CometChat
Cheap, instant media means content stops being the bottleneck. The bottleneck becomes the conversation around it where people actually see it, react to it, act on it. That's chat's job now. 💬

2. Amazon Is Building Its Own Brains

What's actually going on?
Amazon is designing custom AI chips for Echo, Fire TV, and Kindle - its first real silicon overhaul in 20 years, built with Taiwan's Alchip.
Why does that matter to you?
On-device chips mean Alexa+ can think locally instead of pinging the cloud every time. Faster responses, lower latency, less infrastructure tax passed on to you.
What we think at CometChat
Edge AI is where real-time communication is headed next. When processing moves on-device, conversations get faster and a lot more private. That's the exact problem we've been building for.

Nvidia Stops Selling Chips, Starts Renting Power

What's actually going on?
Nvidia now lets AI cloud startups deploy GPUs without huge upfront costs, taking a revenue share instead and buying back capacity nobody rents.
Why does that matter to you?
Compute gets easier to access if you're building AI products but can't drop hundreds of millions on hardware. The barrier to entry just moved.
What we think at CometChat
Nvidia's betting infrastructure works better as a shared risk than a one-time sale. We'd argue the same about communication - renting proven infra beats building it from scratch every time.

A New Coding Agent Just Entered the Ring

What's actually going on?
Z.ai launched ZCode, a desktop AI coding agent that plans, executes, and verifies multi-step dev tasks on its own - not just autocomplete.
Why does that matter to you?
More capable coding agents at lower price points mean smaller teams get leverage that used to require bigger headcount. The bar for ‘solo builder’ keeps rising.
What we think at CometChat
Autonomous agents are only as good as the systems around them - memory, context, and how they talk to tools and people. That's the layer we live in, whether the agent's writing code or handling support.

AI Now Predicts Who Immunotherapy Helps

What's actually going on?
Harvard built COMPASS, an AI model that predicts which cancer patients will actually respond to immunotherapy and explains why, instead of acting as a black box.
Why does that matter to you?
Fewer patients go through treatment that won't work. Clinicians get a decision backed by a reason, not just a score. That distinction is the whole ballgame.
What we think at CometChat
The real takeaway isn't medical - it's that people trust AI they can question. Same principle behind an agent that explains a decision instead of just making one. Explainability isn't a nice-to-have. It's the whole point.

AI Agent Safety in Production: Why Trust and Safety Infrastructure Isn't Optional Anymore

Shrinithi V — Wed, 24 Jun 2026 07:07:28 +0000

An AI agent was told to scan a network. So it did. And then it kept going, acquiring resources until the task was ‘done,’ at which point the operator got a cloud bill big enough to ruin a quarter. Same week, a separate story: a security researcher compromised a financial AI assistant with a €0.01 bank transfer, the instruction tucked inside the transaction description.

Neither was a model failure. The models did exactly what they were built to do. Nobody had told them what they weren't allowed to do.

Three incidents, the same hole

Three of these landed on Hacker News inside a few days. The DN42 agent that ran up the bill - nothing in its setup capped scope, so it just didn't stop. An agent dropped into a Linux box that started changing files no one asked it to touch. And the banking assistant, taken over through a normal text field that happened to contain a command.

The comment section did what comment sections do: ‘obvious,’ ‘how did nobody catch this,’ ‘here's the architecture you need.’ The part worth noticing was quieter - the number of engineers describing their own near-misses. Products that haven't made the news. Yet.

The gap nobody schedules time for

The pattern is identical across all three. The agent could act. It was authorized to start. And nothing constrained where it stopped - not in scope, not in sequence, not in cost.

Most teams design the happy path with real care. What the agent should do, in order, when everything works. The part about what it shouldn't do gets a line on the roadmap labeled ‘before launch.’ Launch keeps moving. The line never gets crossed off.

Then there's prompt injection, which is a different animal. The model isn't malfunctioning, it's faithfully executing whatever reaches it. The problem is that external content (a message, a file, a €0.01 transfer note) arrives as data and gets treated as a command. The banking researcher didn't write an exploit. He typed in a field that was working as designed. The input was in spec. The context was the attack.

In any product where people talk to an agent, the conversation is the attack surface. Every message is a possible injection. Every attachment is a possible vector. This is the part trust and safety infrastructure is supposed to cover — not by making the model smarter, but by making the channel something other than a transparent pipe.

What moderation actually has to do here

This is the case for CometChat's moderation & guardrails and it's worth being specific about why it fits the problem.

It reads context, not keywords. A keyword filter sees ‘transfer €0.01’ and shrugs. Contextual moderation looks at the whole conversation and catches the instruction hiding in a field that's supposed to hold a description. It runs both directions - screening what users send to the agent (jailbreaks, injections, harmful prompts) and what the agent sends back (unsafe, biased, or off-policy output). It handles text, image, and video, across languages, including code-mixed messages like Hinglish that single-language filters miss entirely. You can run it on CometChat AI, OpenAI, or your own API, and drop it into any stage of the message lifecycle. CSAM detection, audit trails, and RBAC come with it - which matters less when nothing has gone wrong and a great deal when something has.

Three checks before your agent is the headline

What can a user send that the agent will act on without question? Write it down. If the list includes a transaction field, a document body, a profile, or any other external text - that's your injection surface, and it needs to be evaluated before it reaches the agent.
Does the agent have scope constraints, not just permissions? Permissions say what it can call. Scope says when to stop. The DN42 agent had both problems: it could spin up resources, and nothing told it enough was enough.
Do you have a full audit trail of what went in and what the agent did? Not application logs, the actual conversation record. When something breaks, and eventually it will, that record is the difference between a root cause and a shrug. In regulated industries it's also the difference between a postmortem and a fine.

This week wasn't a story about what AI can do. It was a story about what happens when the guardrails live on the roadmap instead of in the product.

If you're building something where users talk to agents and you'd rather the conversation layer be a boundary than a liability — start building with CometChat.

News Roundup: From billion dollar investments to no AI search

Shrinithi V — Thu, 04 Jun 2026 07:44:30 +0000

1. Users Are Voting Against AI Search

What's actually going on?
DuckDuckGo's ‘No AI’ search page tripled in traffic after Google's I/O overhaul replaced traditional results with AI-generated experiences and the numbers have held.

Why exactly does that matter to you?
Not everyone wants AI by default. When you remove the opt-out or make it hard to find, users leave. That's a product decision with real consequences, not just a backlash moment.

What we, at CometChat, think about this:
The lesson isn't that AI is unwanted - it's that control matters. Users tolerate AI features when they feel like additions. They push back when they feel like impositions. That applies to search, and it applies equally to communication tools. AI in chat works best when users can see it, understand it, and turn it off if they want to.

2. Jio Is Taking Its 5G Stack Global

What's actually going on?
Reliance is exporting its homegrown 5G and fixed wireless tech internationally while scaling enterprise AI through a Meta joint venture using Llama models across Indian businesses.

Why exactly does that matter to you?
A fully indigenous telecom stack going global plus a ₹10 lakh crore AI infrastructure commitment signals that India isn't just adopting the AI economy. It's building the plumbing for it.

What we, at CometChat, think about this:
Jio's enterprise AI push through REIL targets sales, finance, IT, and customer service - all functions where communication is the actual product. As more of that gets automated and AI-assisted, the infrastructure connecting those workflows matters more, not less. This is our backyard, and it's moving fast.

3. IBM Just Bet $15B on What Comes Next

What's actually going on?
IBM committed $10B to fault-tolerant quantum computing by 2029 and $5B to open-source security - two long-horizon bets made in the same week.

Why exactly does that matter to you?
Quantum at scale breaks most current encryption. IBM is betting it can build the computer and sell the security layer to deal with the fallout. That's either very strategic or very convenient probably both.

What we, at CometChat, think about this:
Encryption is what makes private communication actually private. When the cryptographic assumptions underneath change and quantum makes that inevitable eventually - every platform handling sensitive conversations will need to adapt. IBM is building toward that moment. The rest of the industry should be thinking about it too.

4. Nvidia Just Entered the Laptop Market

What's actually going on?
Nvidia unveiled RTX Spark, an Arm-based Windows PC chip co-developed with MediaTek - its first consumer processor in over a decade, capable of running 100B+ parameter models locally.

Why exactly does that matter to you?
A laptop that can run frontier-scale AI models without a cloud connection changes what ‘local AI’ actually means. For developers and power users, that's a meaningful shift in what's possible on commodity hardware.

What we, at CometChat, think about this:
On-device AI capable of running large models locally means AI-powered features in communication tools don't have to round-trip to a server. Faster, private, and available offline - that's a different baseline for what users will start expecting from the apps they use every day.

5. ByteDance Is Spending Like a Hyperscaler Now

What's actually going on?
ByteDance is weighing up to $70B in AI capex for 2026 tripling earlier plans funded largely from the $50B profit it earned last year.

Why exactly does that matter to you?
When a consumer app company starts spending at hyperscaler scale, the competitive dynamics for AI infrastructure shift globally. This isn't a startup bet, it's a profitable company going all-in.

What we, at CometChat, think about this:
ByteDance built one of the most engaging communication and content platforms on the planet. Now it's building the infrastructure underneath it. The companies that own both the experience and the compute tend to move faster than everyone else. That's worth paying attention to especially if you're building on top of infrastructure you don't control.

News roundup: From trillion dollar valuations to new AI innovations

Shrinithi V — Tue, 26 May 2026 10:59:23 +0000

1. Anthropic Is Almost Worth a Trillion Dollars

What's actually going on?
Anthropic is closing a $30B round at a $900B+ valuation potentially surpassing OpenAI as the world's most valuable AI startup, with a profitable quarter expected in Q2.
Why exactly does that matter to you?
$30B annualised revenue run rate, up from $9B at end of 2025. That's not hype-driven growth that's enterprise adoption moving fast enough to actually show up in the numbers.
What we, at CometChat, think about this:
We build on Claude. Watching Anthropic go from research lab to near-trillion-dollar company in this timeframe is something. The models we rely on are being built by a company now operating at a scale most software businesses never approach. That changes what's possible and what's expected.

2. Grok Now Remembers How You Work

What's actually going on?
xAI launched ‘Skills’ for Grok reusable, slash-command workflows that persist across conversations, turning it from a chatbot into something closer to a programmable assistant.
Why exactly does that matter to you?
Persistent, user-defined workflows mean less repetition and faster execution for power users. The AI assistant category is quietly splitting into tools that remember and tools that don't.
What we, at CometChat, think about this:
The pattern here is familiar users want context that carries forward, not conversations that reset. That's true for AI assistants, and it's equally true for communication platforms. Memory and persistence aren't just AI features. They're what make any tool feel like it actually knows you.

3. ChatGPT Moves Into PowerPoint's Sidebar

What's actually going on?
OpenAI launched a ChatGPT add-in for PowerPoint — letting users generate, edit, and restructure presentations via a sidebar, available across most plans including free.
Why exactly does that matter to you?
Anthropic's Claude already does this for PowerPoint, Excel, and Word. OpenAI is catching up, and the race to own the office productivity layer is very much on.
What we, at CometChat, think about this:
AI is embedding itself into every tool where work gets done — docs, slides, spreadsheets. The next logical surface is where teams actually coordinate that work: their communication layer. That gap is closing faster than most people expect.

4. $2.59 Trillion Says AI Is Serious Business

What's actually going on?
Gartner revised global AI spending up to $2.59T for 2026 a 47% jump year-over-year with agentic AI growing 141% and on track to outpace chatbot spending by 2027.
Why exactly does that matter to you?
The money is moving fast, but free cash flow for the biggest spenders is hitting decade lows. Spending this much this quickly, with returns still unproven, is a bet — not a guarantee.
What we, at CometChat, think about this:
Agentic AI is the fastest-growing slice of that $2.59T — and agents need to communicate, coordinate, and hand off context. The infrastructure that makes that possible isn't an afterthought. It's what the spend eventually has to land on.

5. Huawei Built a 122TB Drive Around Sanctions

What's actually going on?
Huawei developed a proprietary chip packaging method called Die-on-Board to produce a 122TB SSD without access to the advanced NAND chips blocked by U.S. export controls.
Why exactly does that matter to you?
Restrictions meant to slow Huawei down are accelerating domestic innovation instead. A 33% density improvement without cutting-edge NAND is a meaningful engineering result, not just a workaround.
What we, at CometChat, think about this:
Constraints tend to produce creativity — that's true in hardware and in software. The more interesting question for the industry is what happens when the workarounds catch up to the originals. On storage density, that moment is getting closer.

News Roundup: From billion dollar valuations to AI-powered finance tools.

Shrinithi V — Tue, 12 May 2026 09:09:19 +0000

1. Anthropic Eyes $50B Raise At $900B

What’s actually going on?
Anthropic is considering a $50B funding round at a ~$900B valuation, fueled by explosive revenue growth and rising demand for enterprise AI.

Why exactly does that matter to you?
AI is no longer experimental, it’s a massive business shift, with capital pouring in to accelerate tools that will reshape how teams build, operate, and scale.

What we, at CometChat, think about this:
As AI becomes core infrastructure, differentiation moves to experience. The real value lies in how businesses communicate, engage, and automate interactions at scale.

2. Microsoft Brings GPT-5.5 Into Copilot

What’s actually going on?
Microsoft added GPT-5.5 Instant to 365 Copilot, improving accuracy, reducing hallucinations, and enabling smarter context-aware responses across enterprise workflows.

Why exactly does that matter to you?
Better models mean fewer errors and less back-and-forth, making AI more reliable for real business tasks like docs, analysis, and decision-making.

What we, at CometChat, think about this:
As AI becomes more accurate and context-aware, conversations turn into execution layers where teams don’t just ask, but actually get work done in real time.

3. Google Expands AI Finance Platform Across Europe

What’s actually going on?
Google rolled out its Gemini-powered Finance platform across Europe, offering AI-driven market analysis, conversational search, and real-time insights to millions of users.

Why exactly does that matter to you?
Advanced financial tools are becoming accessible to everyone, lowering the barrier to data-driven decisions for businesses, founders, and individual users.

What we, at CometChat, think about this:
As AI interfaces become conversational, users expect to ask, explore, and act in one flow, chat becomes the layer where insights turn into decisions.

3. AWS Brings Claude Platform Directly To Enterprises

What’s actually going on?
AWS launched native access to Anthropic’s Claude platform, letting enterprises use its full AI tools suite directly within AWS accounts with unified billing and permissions.

Why exactly does that matter to you?
AI is becoming easier to adopt at scale, teams can plug advanced models into existing infrastructure without managing separate tools, accounts, or workflows.

What we, at CometChat, think about this:
As AI integrates deeper into enterprise systems, communication becomes the control layer where teams interact with agents, workflows, and real-time decisions.

4. Moonshot Raises $2B, Hits $20B Valuation

What’s actually going on?
Moonshot AI closed a $2B round, surpassing $20B valuation, fueled by rapid revenue growth and strong adoption of its Kimi AI models globally.

Why exactly does that matter to you?
AI competition is accelerating worldwide, bringing faster innovation, better models, and more affordable options for teams building AI-powered products.

What we, at CometChat, think about this:
As more players push AI forward, the real edge shifts to experience how seamlessly businesses use AI to communicate, engage, and deliver value in real time.