OpenTag: a self-hosted Slack and Teams triage bot you fork and ship

An agent in the thread, where the work already is

OpenTag, from CopilotKit, is a self-hosted knowledge-work agent for Slack and Microsoft Teams, and the README's demo table shows the shape of the job: a spreadsheet goes in and a native Slack chart comes back; a Linear write pauses behind an approval button; a research question returns a table with the sources it actually used. Underneath, it is a Python LangGraph agent connected to tools, wired to chat platforms through the Channels SDK.

The positioning is starter application, and the README is blunt about the intent: the SDK documentation shows you the pieces, and OpenTag is those pieces assembled into something you would actually deploy, built to be taken rather than read. Slack and Teams are supported today, with Discord, Telegram and WhatsApp listed as coming soon. For engineering teams that want an on-call triage or knowledge agent inside the tool where work happens, this is the fast path that does not end at a demo.

Starter app, production shape

The README's own table splits the offer into clone, customize and ship. Cloning yields a working agent: managed Channel, Node runtime, Python LangGraph agent, connected tools and native Slack UI. Customization is deliberately shallow, with the agent, persona, tools and UI each isolated to one file or one directory, and the Channel lifecycle untouched when you point it at a different agent.

Shipping has two documented targets: a two-service Railway deployment in .railway/railway.ts, and an AWS path running one private ECS Fargate task with Secrets Manager and CloudWatch-to-Datadog log forwarding. Release images publish to ghcr.io as opentag-agent and opentag-runtime. The phrase production shape, not demo shape appears with receipts: pinned SDK versions, graceful shutdown, and a live Slack harness included in the repository.

Quick start: the managed Channel first

Prerequisites are explicit: Node.js 22 or newer, pnpm, Python 3.12, uv, a CopilotKit account, an OpenAI API key, and a Slack workspace you can install into. Dependencies first:

pnpm install

Then the Channel, which the README insists comes before touching Slack, because the Channel generates the Slack app manifest with the right Request URL, and creating the Slack app first means creating the wrong one. The assisted route:

npx --yes copilotkit@latest channels setup

That installs a channels-setup skill and copies a one-line prompt for your coding agent. Two design notes are stated in the README: the skill fetches its workflow from CopilotKit's guide at run time so it cannot go stale against the CLI, and it hands every secret back to you rather than asking you to paste one into chat. One caveat is documented as well: it installs to every coding agent it detects, with no way to narrow the list, so read what it writes before committing.

Environment and the run loop

Configuration starts from the template:

cp .env.example .env

The values the README lists:

OPENAI_API_KEY=sk-...
AGENT_URL=http://localhost:8123/
INTELLIGENCE_API_KEY=cpk-...
INTELLIGENCE_CHANNEL_NAME=open-tag
# Optional: assign OpenTag Threads to an existing Learning Container.
INTELLIGENCE_LEARNING_CONTAINER_ID=support-quality
# Optional: use another user-facing identity, such as Kite.
AGENT_DISPLAY_NAME=OpenTag

Both the Node runtime and the Python agent read this one root file, and two Intelligence endpoint variables are deliberately left unset because app/env.ts defaults them in code. The stack runs with pnpm dev, whose predev hook syncs the locked Python environment and installs Playwright's Chromium, then starts the agent with reload and the runtime in watch mode, with the runtime waiting for its Intelligence connection before accepting traffic. Tavily, GitHub, PostHog, Linear and Notion are optional research and integration sources.

The invite, and the three-check proof

The README's deployment wisdom peaks in a short section about the most expensive failure available: a Channel that installs cleanly and answers nothing, because it looks finished. The proof is three checks sent from a real human account. Mention the bot and expect a useful reply. Follow up in the same thread without mentioning it and expect an answer, because a mention subscribes the thread. Then send an unmentioned message in a fresh conversation and expect silence, because a reply there means the trigger rules are wrong.

Failure has a procedure. A channels status command reports declaration, source, server, adapter, environment and lifecycle diagnostics in JSON, with two warnings that are expected for this project rather than faults. If that is not enough, running the runtime at debug level exposes the Channel lifecycle breadcrumbs, including the single highest-value diagnostic line, the message that the channel requires setup.

Approval gates and the customization surfaces

The demos show the agent's boundaries as much as its abilities. Linear and Notion writes pause for human approval, with the button resuming the LangGraph run, which is the correct default posture for an agent that can create issues in your tracker. Research answers arrive with their cited links attached, and CSV uploads return native Slack charts rather than walls of numbers.

Customization follows the one-file rule: swap the LangGraph agent, change the persona, add tools, or replace the generative UI without touching the Channel lifecycle, and the managed Channel runner can be replaced entirely with one you build on the open-source SDK if you would rather own the durable-data concerns, delivery, state and concurrency, yourself. That is the architectural fork in the road: the managed runner is a CopilotKit Intelligence service with a free plan, and the alternative is operating that layer on your own infrastructure.

Limits, honestly placed

The constraints are the trade of the design. Platform coverage is Slack and Teams today, with the other three channels promised, not shipped. The managed path puts a CopilotKit service in the middle of message delivery, which the README discloses clearly and prices openly, but teams with strict data-residency rules will land on the self-run Channels SDK path and inherit its operational work. The agent's default brain is an OpenAI key, and the optional integrations, Tavily, Linear, Notion, GitHub, each carry their own accounts and credentials.

Project state is healthy: MIT licensed, three releases, and the last push on 2026-09-08. The repository also carries an AGENTS.md, an e2e directory, a changelog and deployment documentation for both targets, which matches the production-shape claim. What it does not claim is a finished product: it claims a starting point that already runs, and the documentation is organized to get you from clone to a proven, answering bot in one sitting.

Editorial conclusion

OpenTag fits engineering teams that want a working AI triage and knowledge agent inside Slack or Teams this week, are comfortable forking a LangGraph starter, and accept either the managed CopilotKit Channel or the work of running the open SDK themselves. Skip it if you need Discord or WhatsApp today, if a managed service in the message path is a dealbreaker and you cannot run the SDK, or if you want a no-code bot builder. Verify it the README's own way: complete the quick start, run the three checks, mention, follow-up, silence, and confirm every one behaves before inviting it anywhere that matters.

Frequently asked questions

Official sources

1. CopilotKit/OpenTag on GitHub
2. Issues
3. License: MIT
4. README
5. Releases