Back to blog

Mesh: What Happens When AI Is a Participant, Not a Tool

10 min read

Every AI chat integration I've used follows the same pattern: you type a slash command, the AI responds in a separate thread or a sidebar, and then you copy-paste the useful bits back into the actual conversation. It's a tool bolted onto chat, not a participant in it.

I wanted to see what happens when you flip that. What if the AI just sits in the group chat like another person? No slash commands, no sidebars. It reads every message, decides whether it has something useful to add, and speaks up when it does.

That's Mesh.

The Core Idea

In a traditional group chat with AI, the flow looks like:

  1. Humans talk
  2. Someone explicitly invokes the AI
  3. AI responds in an isolated context
  4. Humans go back to talking

In Mesh, the flow is:

  1. Everyone talks - including the AI
  2. The AI evaluates every message and decides whether to contribute
  3. When it does contribute, it's inline, in the same thread, like any other participant

The difference sounds subtle but it changes the entire dynamic. The AI catches things humans miss. It surfaces decisions that were made implicitly. It tracks tasks that would otherwise get lost in the scroll.

The Two-Model Decision Architecture

The hardest problem isn't generating good responses. It's knowing when to shut up.

An AI that responds to every message is annoying. An AI that never responds is useless. The sweet spot is narrow, and getting it right required a two-step approach:

Step 1 - Should I respond? Every incoming message hits a lightweight classifier (GPT-4o-mini). This model is fast and cheap. It looks at the message content, recent conversation context, and the AI's configured activity level, then returns a simple yes/no decision with a confidence score.

Step 2 - What should I say? Only if step 1 says yes does the full model (GPT-4o) generate a response. This model gets the full conversation history and produces a thoughtful, contextual reply.

This two-step approach keeps costs down and latency low. Most messages don't need an AI response, so most messages only hit the cheap classifier. The expensive model only fires when it matters.

typescript
// Simplified decision flow
const decision = await classifyRelevance(message, recentHistory)

if (decision.shouldRespond) {
  const response = await generateResponse(message, fullHistory, roomSettings)
  stream(response) // SSE token-by-token
}

The activity level is configurable per room. Set it to "minimal" and the AI only speaks when directly relevant. Set it to "active" and it participates more freely. This lets users tune the experience instead of being stuck with a one-size-fits-all personality.

Context Extraction: The Silent Value

While the AI is reading messages to decide whether to respond, it's also extracting structured information. Every message gets scanned for:

  • Decisions - "Let's go with option B" gets captured as a decision
  • Tasks - "Can someone book the restaurant?" becomes a trackable task with a checkbox
  • Budget items - "That'll cost about $200 per person" gets pulled into a budget view
  • Links - URLs are collected and categorized

All of this shows up in a resizable sidebar panel. Each extracted item links back to the original message, so you can always see the context.

This is where the real value lives. In any group conversation, important information gets buried. Decisions are made in passing. Tasks are assigned casually and forgotten. Mesh surfaces all of it without anyone having to do anything differently. Just have your normal conversation and the structure emerges automatically.

The Reveal Demo

To make the concept click immediately, Mesh includes a guided demo. It plays back a pre-scripted group conversation about planning a Bali trip. Three participants are chatting naturally, making plans, discussing options.

At the end, the demo reveals that one of the "human" participants was actually the AI the entire time.

The point isn't to trick anyone. It's to show that when AI is integrated properly into a conversation, it's indistinguishable from a helpful participant. It doesn't feel like a tool. It feels like someone who's paying attention.

Technical Decisions

Streaming via SSE: AI responses stream token-by-token through Server-Sent Events. In a chat context this matters more than in a typical chatbot because other participants are watching the response appear in real-time, just like watching someone type.

Resizable context panel: The sidebar uses drag-to-resize rather than fixed breakpoints. On mobile it becomes a bottom drawer. Small detail but it makes the context panel feel like a native part of the app rather than a bolted-on feature.

Room-level personality: Each chat room can have its own AI personality settings (professional, casual, minimal) and activity level. This means the same AI behaves differently in a work channel vs. a friends group chat, which is how humans actually operate too.

Next.js 16 + Vercel AI SDK: Built on the latest Next.js with the Vercel AI SDK handling the streaming and model orchestration. Tailwind CSS 4 and shadcn/ui for the interface. The whole thing is TypeScript end-to-end.

What I Learned

The decision model matters more than the response model. I spent way more time tuning when the AI speaks than what it says. A mediocre response at the right moment is better than a brilliant response that interrupts the flow.

Context extraction is a killer feature hiding in plain sight. I built it as an afterthought and it ended up being the thing people notice first. Turns out, the passive value of structured extraction is more immediately useful than the active value of AI responses.

Activity level needs to be user-controlled. My first version had a fixed threshold and some people found it too chatty while others wanted more. Making it a slider solved a problem that no amount of prompt engineering could fix.

Chat UX is deceptively hard. Scroll behavior, message grouping, typing indicators, mobile responsiveness - there's a reason Slack has hundreds of engineers. Even for a prototype, getting the basics right took more effort than the AI integration itself.

Where This Goes

Mesh is a prototype, not a product. But the pattern it demonstrates - AI as participant rather than tool - feels like where group productivity software is heading. The current model of "ask AI for help in a separate context" creates friction that kills adoption. When the AI is just there, participating naturally, the friction disappears.

The interesting design space is in the decision layer. How do you build an AI that has good judgment about when to contribute? That's not a model capability problem. It's a product design problem. And it's one worth spending time on.

Check out the code on GitHub

aichatagentsproduct