Ano · Claude Code team chat

Team chat for Claude Code

If your team uses Claude Code, the chat tool around it matters more than people admit. Claude Code is great solo: one terminal, one person, one running conversation. Ano makes it great as a team.

The rest of this page is a working explainer: what changes when chat is downstream of the agent loop instead of upstream of it, how the shell, coworkers, MCP, and the CLI fit together, and where the pattern starts to pay off for teams that aren't only engineers. Use the on-page navigation below to skip to any section.

Why team chat matters for Claude Code

Claude Code is a single-player surface by default. The conversation, the tool calls, the file edits, the output: all of it lives in one terminal, on one machine, in one person's working memory. The next teammate who needs the same answer reruns the prompt from scratch, or gets a screenshot pasted into Slack with the relevant lines missing.

Three problems show up the moment a second person needs the work.

• Context is private. The channel-level shared understanding of what's been tried, what failed, and which file is in flight, lives nowhere outside one person's session.
• Tools are duplicated. Each engineer wires up their own MCP servers, their own credentials, their own shell aliases. Two people on the same project end up with two different toolchains.
• Output is lossy. What lands in chat is the conclusion, not the call. Nobody else can see whether the agent ran stripe customers list or stripe customers retrieve, and which arguments.

The usual fix is a Claude Code Slack bot. It helps with the third problem (output lands in chat) but doesn't touch the first two. The bot owns its own tool registry, the channel still doesn't have the shell, and what lands in chat is whatever the bot chose to post, not the actual call. Ano is the other shape: chat as a surface for the agent loop, not a wrapper around it. Ano is the modern shape of ChatOps.

The shell, always alongside chat

The shell is not a thing you summon. It sits alongside the chat, in every channel, all the time. Move between channels and the shell moves with you, swapping in that channel's context and the workspace's tools. The Claude Code session knows which project this is, what was discussed in the last twenty messages, and which files have been linked. ⌘J focuses it from anywhere if you want a keyboard shortcut.

What that buys you in practice: no alt-tab, no copy-paste of the channel name into a separate Claude Code terminal, no manual "let me catch you up on what we tried." The shell inherits the room.

Output goes back to the channel by default. If you ran a deploy, the channel sees the deploy. If you opened a PR, the channel sees the link. The shell is not a separate world that you tour and report back from. It's an inline part of the conversation. See The shell in every channel for the longer write-up.

Coworkers: agents as workspace members

A coworker is a Claude Code agent with a name, an avatar, a tool registry, and a seat in the member list of every channel it's added to. Not a bot in a tray. A member. You @mention them, they read threads, they reply in threads.

The shape difference matters. A bot is a thing you trigger; a coworker is a thing you talk to. The bot pattern pushes you toward slash commands and rigid invocation. The coworker pattern lets the team's normal channel etiquette do the routing: @sales-bot becomes @maya, who knows HubSpot and Apollo, and who fits the way the team already addresses one another.

Each coworker has its own tool registry: a sales coworker that knows HubSpot and Apollo, an oncall coworker that knows PagerDuty and the deploy CLI, a support coworker that knows Intercom and Stripe. Small, narrowly-scoped ones outperform a single do-everything agent. For the longer explainer, see What is an AI coworker?

Tools: MCP servers and CLIs, wire once, available everywhere

Two protocols, one registry. The Model Context Protocol (MCP), originated by Anthropic, is the modern standard for plugging tools into an agent. The CLI is the old standard, still the most common shape your team's tools actually ship in: gh, stripe, hubspot, linear, your own internal scripts. Both work in Ano, and both go into the same shared workspace registry.

In a Claude Code Slack bot setup, each bot owns its own wiring. Engineering's bot has the GitHub plugin. Support's bot has the Intercom plugin. The two registries do not see each other. New hires get a fresh credentials hunt.

Ano puts the registry at the workspace level. Add an MCP server or a CLI once and the shell sees it, the coworkers see it, and the CLI sees it too (so cron and CI can call the same tools). One source of truth, one place to rotate credentials. The team's tool catalog stops being a per-person artifact and starts being a property of the workspace. New hires inherit it. Contractors get a scoped subset. When you rotate a Stripe key you rotate it in one place.

The CLI: drive Ano from any terminal

The chat client is one surface. The other surface is the terminal. @ano-chat/cli is the package; install it with npm or pnpm and you have an ano binary that talks to the workspace.

What that unlocks: post to a channel from a CI run, read messages in a cron job, trigger a coworker from a bash script, pipe a long-running command's output into a thread. The same auth as your client, the same MCP registry. The CLI is not a parallel API for power users; it's the same workspace seen from the terminal.

Concretely: ano messages send "shipping 1.42" --channel deploys, ano dm send "pull the Q3 pipeline" --to "Maya", ano messages read --channel sales. The same shell that ran your build can announce the build, and the same coworkers that answer in chat answer in scripts. Full reference on the developers page.

For sales, support, and ops (not just engineers)

The Claude Code team chat pattern reads as an engineering tool at first glance: shell, CLI, MCP, agents. The pattern travels further than that. Every team has CLIs and MCP servers now.

• Sales. HubSpot, Apollo, Gong, LinkedIn. A sales coworker pulls a record, drafts an outbound, posts the draft in thread for review.
• Support. Intercom, Stripe, the product database. A support coworker can look up the customer, the charge, and the last three tickets, then refund or escalate.
• Ops. Linear, Notion, the deploy tooling. An ops coworker can open a ticket, paste the deploy summary, and schedule the follow-up.

Same shape across functions: a channel, the shell beside it, a coworker, the team's tools wired into the workspace. For a longer walkthrough of the team workflow, see How to use Claude Code with your team.

Claude Code-native vs DIY at a glance

Why a purpose-built surface beats a Slack bot

The DIY Claude Code Slack bot is the obvious first move. It is also where most teams stall. The bot ships, three people use it, and the rough edges (no shell, no shared tools, no real audit trail) start pulling the workflow back into the terminal. Below is the short map of the alternatives we hear teams pick between.

DIY Slack bot

Cheapest to start, most expensive to maintain. Output lands in Slack but the shell, the MCP registry, and the auth all live elsewhere. Your platform team owns the rough edges.

Third-party Claude Slack app

Saves the maintenance bill. Still bot-shaped: per-app tool registry, sidebar UX, no inline shell. Tied to one chat surface.

Discord bot

Same shape as a Slack bot with worse threading. Useful for community-shaped teams; thin for actual work surfaces.

IDE extension only

Claude Code inside VS Code or Cursor. Great for one person. Does nothing for the next teammate who needs the same answer.

Terminal only

The default Claude Code experience. Strongest for the operator, invisible to everyone else.

Ano

Channels, threads, DMs, with a collaborative shell sitting alongside, a shared MCP and CLI registry, coworkers as members, and the @ano-chat CLI for scripting the workspace from any terminal. Built specifically for the Claude Code team chat shape. Free, open beta.

What "Claude Code-native" actually means

The phrase is starting to mean nothing because every chat tool with a Claude integration claims it. Here is the working definition. A product is Claude Code-native if these three are true.

• The chat product is downstream of the agent loop, not upstream. Bot integrations are upstream: you write the bot, the bot sends a message. Native chat is downstream: the agent is a participant, the chat is its surface.
• The shell is reachable from inside chat, not adjacent to it. A shell that sits alongside the channel is reachable. A "Send to Claude" button that opens a sidebar is adjacent.
• The tool registry is shared. Adding an MCP server or a CLI to the workspace means the shell, the coworkers, and any scripted CI flow all reach it. Per-bot registries don't count.

Tools that clear all three: Ano, built specifically for it. Tools that clear two: roughly none in production today.

How to try it

Open beta. Free for the whole company. The shortest possible onboarding:

1. Download Ano. Mac app from the homepage.
2. Create a workspace. One per team or per project. Invite teammates with a share link.
3. Connect Claude Code. Bring your own account. AI prompts go straight from your machine to Anthropic on your plan; Ano never sees them.
4. Add your MCP servers and CLIs. Wire the workspace registry once. GitHub, Linear, Stripe, HubSpot, your own scripts, anything that speaks MCP or runs in a shell.
5. Open a channel and use the shell beside it. The shell already carries that channel's context and the workspace's tools. Run the first real task there.

Ready to try Claude Code as a team sport? Download Ano free, see real setups on the examples page, or read the ChatOps overview for the broader pattern.