SintBot

Self-hosted daemon · Lark & Slack · Claude Code & Codex

Say it in the group. Any model, one memory. On your own machine.

Bind a chat group to a project and anyone on the team can hand it work: SintBot reads and changes code, does design and reports back, on your own machine. ChatGPT, Claude, GLM, DeepSeek, Kimi or a model you host — switch in the group per task; one long-term memory per project, kept for you, stored locally.

See how it works Free plugin

What it is

One daemon. Your project, in the group.

SintBot runs on your machine and joins the groups your team already uses; each group is bound to one project, so the agent works inside that directory and keeps its context.

  1. Group-project AI

    sintbot is the daemon: one project per group, each turn handed to Claude Code or Codex headless, progress in the group, permissions per group. cc-bot is the free plugin for your own Claude Code session.

    See it on Lark and Slack →

01 · Platforms

Lark and Slack, both supported.

A group can be a Lark group or a Slack channel — each one picks, and one daemon serves both. Everything else is the same: one project per group, just talk to it, no public IP, progress you can stop, the same permissions and console.

Lark

In a Lark group

  • Streaming card

    The card updates while the work runs — how long, what it is doing now, a line per finished step; the answer and its buttons land in the same card, the steps folded away.

  • Whiteboard loop

    Draw arrows or leave notes on the board, press “edit per annotation”, and the revised image returns to the same card.

  • Nine group actions

    Send files, images and messages, read history, reply, edit, recall, download group files, react — and a reaction or card button can trigger it.

  • WebSocket long connection

    The daemon dials out; nothing dials in. No public IP, no webhook.

Slack

In a Slack channel

  • Progress in the thread

    A receipt first, throttled progress messages in the thread, the final answer as its own message, then a done mark.

  • Native “Working…” status

    Slack’s own agent status, on the free plan too; stop, skip and status buttons in the thread, plus an App Home page.

  • Commands that survive Slack

    When Slack has taken the slash, use a ! prefix or one catch-all command. The console’s Slack card runs a preflight, lists channels and binds a group.

  • Socket Mode, proxy-friendly

    Outbound only, no public IP; on a restricted network it tunnels through an http proxy.

Shared core

  • one group, one project
  • just talk to it
  • no public IP
  • progress visible, stoppable
  • same permissions & redaction
  • one console
Discord — planned

02 · How it works

From one sentence to delivery.

The daemon on your machine checks the group’s permissions, hands the turn to Claude Code or Codex inside the project directory, and streams progress back — on whatever model you chose for that group.

progress + result back to the group Group Lark Slack just talk to it one group · one project Daemon · your machine message loop one group · one project permissions · redaction long connection · no public IP code and keys never leave Agent runner Claude Code Codex headless, in the project dir long turns · stoppable Model Claude · GPT GLM · DeepSeek MiniMax · Kimi any Anthropic-compatible endpoint your subscription or key console · local page project directory · fenced design toolchain style file · check · images · preview
Left to right: group → daemon → runner → model. Dotted: progress and results return; the console, the fenced project directory and the design toolchain hang off the daemon.

03 · Models

Same agent. Any brain.

Claude Code against any Anthropic-compatible endpoint — GLM, DeepSeek, Kimi, MiniMax, or an open-source model you host yourself — or Codex through the machine’s own ChatGPT login. The daemon treats them all alike: switching only changes what the next turn starts with, and the project’s memory stays.

  1. 01

    Switch in the group

    /model lists, /model plus a name switches — anyone in the group can. A switch opens a fresh conversation; the memory files carry over.

    • /model
    • fresh conversation
    • anyone in the group
  2. 02

    Configured per group

    Each group has its own model and runner; provider settings stack, so chat can go to a fast model and heavy turns to a slow one.

    • per group
    • fast / slow split
    • your keys
  3. 03

    Memory outlives the model

    The project’s CLAUDE.md, AGENTS.md and memory directory are handed to whichever agent starts. Text-only models work too: images become placeholder text.

    • CLAUDE.md
    • AGENTS.md
    • text-only safe

04 · Design system

A design system the bot actually follows.

Sixteen built-in styles, a style file that lives in the project, and a check that runs before anything is handed over.

Sixteen built-in design styles rendered as miniature interface cards
The 16 built-in styles, rendered by the daemon itself. The same preview cards appear in the console and in the group.

  1. A style file the agent must read

    DESIGN.md in the project root — tokens, prose, do/don’t, image prompt — read before any image or page. Keep one per surface; share company rules via a user-level directory.

    • 16 built-in + 9 alternates
    • extract from a reference image or URL
    • lucide · tabler · phosphor · pixelart

  2. Checked before it is handed over

    Colours, radii, fonts, icon parameters, Chinese fallback and whether the font really renders on mac and Windows — pasted into the delivery note. A layout audit then measures overlaps, clipping, tap targets, contrast and tiny text at three widths.

    • style check
    • layout audit
    • font availability

  3. Images without a key

    Images borrow the machine’s Codex subscription — no API key, no group lock, and a progress message that updates itself while it paints. Edit on the original, repaint a masked region, transparent background; the style file rides along.

    • edit in place
    • masked repaint
    • transparent

  4. Preview in the group

    A finished prototype is served on your local network on a port fixed per group; it survives across turns, stops after 30 idle minutes and can be stopped from the console.

    • LAN preview
    • fixed port per group
    • auto-stop

The whiteboard loop

Lark only

The first time it shows an image, the daemon creates a whiteboard and pins it as a group tab. Draw arrows, drop notes, comment; press “edit per annotation” and the result returns to the same card. Every version and mark is kept — the board becomes the design’s history. It holds design work only: things to look through go out as a searchable page, a choice as a numbered contact sheet.

05 · Scenarios

Six groups, six jobs.

The same daemon, bound to different projects: ask in the group, watch it work, take the result.

  1. #bugs

    Paste the error; a PR comes back.

    A 500 trace lands in the engineering group.

    SintBot reads the trace, finds the cause in the project directory, fixes it, opens the PR and posts the diff in the thread.

    Why it wins: error, fix, PR — one thread, nobody at a terminal.

  2. #design

    One sentence, one homepage.

    A designer asks for a first version of the landing page.

    It reads the style file — or first offers three candidates, say tech-dark, precision-instrument and Swiss grid — builds the page and posts the check result with it.

    Why it wins: the rules are in the repo, and the bot proves it followed them.

  3. #standup

    A standup that files itself at 09:30.

    Someone types one sentence to schedule it.

    At 09:30 the task fires like an incoming message: SintBot collects 24 hours of commits and posts the summary.

    Why it wins: happens whether or not humans show up.

  4. #ship-room

    Swap the brain mid-project.

    Someone types /model and a name.

    Same project, same memory files — the next turn runs on GLM instead of Claude. Cost is your call, per group.

    Why it wins: one agent, many brains, no reconfiguration.

  5. #deploys

    Read-only here, full access there.

    Two groups are bound to the same project.

    The read-only group can look, not touch; only the full-access group changes code and deploys. Secrets are masked before anything leaves.

    Why it wins: permissions live on the group, not in someone’s head.

  6. #review

    Review the prototype without leaving the group.

    The page is done; the team wants to click through it.

    SintBot serves it on the local network and posts the link; /issue files feedback with the last turn’s technical fingerprint attached.

    Why it wins: feedback lands with context, not screenshots.

06 · Governance

Read-only until you say otherwise.

Three layers, all set per group and never globally — a group you have not configured can read and nothing else.

  1. ①

    Execution mode

    Read-only or full access. Unset means read-only.

  2. ②

    Tool allow / deny list

    Three presets — read-only, developer, full trust — or your own list.

  3. ③

    Directory fence

    The agent works only inside the project directory bound to that group, and groups can only be bound inside your projects root — symlinks included.

  1. 01

    Redacted on the way out

    Thirteen patterns are masked before a message reaches the group — bearer tokens, JWTs, API-key prefixes, AWS, GitHub, PEM, key-value secrets, emails, phones. Secrets always; PII per group.

    • 13 patterns
    • secrets always
    • PII per group
  2. 02

    Eight commands, in the group

    /status reports elapsed time, steps, latest activity, queue and session; /hud shows quota. The group is warned when the Claude 5-hour window passes 90% or the Codex 7-day window passes 95%.

    • /help
    • /model
    • /new
    • /stop
    • /skip
    • /status
    • /issue
    • /hud
  3. 03

    Quiet when it should be

    Pause a group and nothing runs, scheduled tasks included. Small talk gets no reply; a recalled message stops its turn. /issue files feedback with the last turn’s fingerprint attached.

    • pause a group
    • recall stops the turn
    • feedback book

Browser takeover

Lark only

When a job in its browser hits a login, a verification code, a slider or a QR code, it posts a card: a screenshot of that page, why it needs you, one button. Tap it and work the page yourself from your phone or desk — tap, drag, type, pinch to zoom; the login stays on its side and it carries on. The link opens once, lasts 10 minutes by default and reaches only that page, and the card flips to in use, ended or expired. Nobody pastes a password or a code into the group.

07 · Console

One local page for every group.

The daemon serves its own console — a single page with no dependencies, on this machine only until you open it: to the LAN behind a password, or on your own HTTPS domain, where only the admins you listed sign in with Lark.

SintBot
  • Overview
  • Groups · Projects
  • Models · Library
  • Settings
  • storefront Lark Claude
  • ship-room Slack GLM
  • design-review Lark Codex · GPT
  • + new group
storefront ~/work/storefront
Permissions
full access · developer preset
Model
Claude Claude Code
Style file
DESIGN.md tech dark
Preview
on · :4610
Last turn
signup 500 → PR #482 · 6m 12s
Stop New session Interject
Live activity 10:42 · reading src/auth/hash.js 10:43 · running tests · 118 passed
  • Groups and projects

    Create or dissolve a group, bind its project directory, link the repo, pause it; Lark and Slack cards with a preflight.

  • Models and permissions

    Per group: model, execution mode, permission preset, PII switch, MCP plugins. Quota used, with Claude and Codex login checks.

  • Design library

    The style library as a preview grid, a form for a new style file, ingest from a project, the icon library.

  • Operations

    Live activity stream, scheduled tasks, running previews, feedback book, version history; per group stop, new session, interject. In English or Chinese.

08 · Reliability

Built to run for weeks.

A daemon nobody watches has to look after itself: turns cannot hang, queues cannot pile up, restarts lose nothing.

  1. 01

    Never hangs

    A 30-minute cap per turn, two turns at once across groups, “received” after 25 silent seconds, a hard release at 20; sessions compact at 400k tokens and a watchdog reconnects.

    • 30-min cap
    • watchdog
    • auto-compaction
  2. 02

    One queue per group, merged

    One lock and one queue per group; messages that arrive mid-turn are merged into the next turn. /stop clears the queue, /skip only the current turn.

    • one lock per group
    • merge on dequeue
  3. 03

    Restarts redo, not forget

    A turn cut short by a release or restart is redone automatically within two hours. Runs as a service: launchd on macOS, NSSM or Task Scheduler on Windows.

    • redo within 2h
    • launchd
    • NSSM
  4. 04

    Scheduled in one sentence

    Cron, aliases like daily, or plain “every day at 09:00”. A task can wake the agent like a message, post a fixed reminder, or run once.

    • cron
    • natural language
    • one-off
  5. 05

    Says what is going on

    After an upgrade it posts the new abilities to each group. If the model is overloaded it says so plainly, keeps what it had written and carries on when you say “continue”; a compacted session is announced, with the quota left when the model reports one.

    • upgrade broadcast
    • plain-language errors
    • compaction notice
  6. 06

    Small footprint, smart egress

    Node 18.17+ with two runtime dependencies; you install Claude Code and Codex. Official Claude goes through your proxy, domestic endpoints connect direct.

    • Node ≥ 18.17
    • 2 runtime deps
    • auto proxy split

09 · Free plugin

cc-bot — the free way to run it.

cc-bot is an MIT Claude Code plugin: it lives inside your interactive session, follows that session’s model and brings Slack and Lark adapters — no daemon, no console.

Claude Code plugin · v0.1.48 MIT Slack · Lark github.com/WaterTian/cc-bot

Four steps to a chat-driven repo.

/cc-bot:setup runs the whole flow inside Claude Code — idempotent, version-aware, auto-detects what it can.

  1. 01

    Install the cc-bot plugin

    # inside Claude Code
/plugin marketplace add WaterTian/cc-bot
/plugin install cc-bot@cc-bot

    Then run /cc-bot:setup in any project. When asked "which IM?", pick Slack.

  2. 02

    Create the Slack app from the manifest

    Open api.slack.com/apps → Create New App → From a manifest. Paste the YAML below.

    Show the manifest 
    # templates/slack-manifest.yaml — bot scopes & Socket Mode
display_information:
  name: cc-bot
  description: Claude Code-powered group project assistant
  background_color: "#1f3a2a"

features:
  bot_user:
    display_name: cc-bot
    always_online: true

oauth_config:
  scopes:
    bot:
      - app_mentions:read   # listen for @cc-bot
      - channels:history    # read public channels
      - channels:read
      - chat:write          # post messages
      - files:read          # download images
      - files:write
      - groups:history      # private channels
      - groups:read
      - users:read

settings:
  event_subscriptions:
    bot_events:
      - message.channels
      - message.groups
      - app_mention
  interactivity:
    is_enabled: false
  org_deploy_enabled: false
  socket_mode_enabled: true  # no public webhook needed
  token_rotation_enabled: false

  3. 03

    Generate the two tokens

    In the new app's Basic Information page:

    • App-Level Token — name it cc-bot-socket, scope connections:write. Copy the xapp-1-… value.
    • Install to Workspace → Allow. Copy the Bot User OAuth Token (xoxb-…).

    Paste both when /cc-bot:setup prompts. cc-bot verifies via auth.test and writes them into .cc-bot/profiles/active.json.

  4. 04

    Invite cc-bot to a channel

    Paste the channel ID. In Slack, run /invite @cc-bot — bot sends a probe. Then bring it online:

    /cc-bot:start

    An "online" message lands in your channel. From here, talk to it like a teammate.

Slash commands

  • /cc-bot:setup — interactive Slack / Lark onboarding
  • /cc-bot:start — bring the bot online
  • /cc-bot:stop — take it offline
  • /cc-bot:new-profile <name> — clone the profile template
  • /cc-bot:switch <name> — swap active profile
  • /cc-bot:doctor — health check & diagnostics

Pricing

Two ways to run it.

cc-bot is free and MIT. A Pro subscription supports development and gets you the sintbot daemon, provided as is.

  1. Free

    $0/ forever

    A Claude Code plugin — lives inside your session.

    • Installs into Claude Code as a plugin — it runs in an interactive session and uses whatever model that session runs
    • Full cc-bot core — Slack + Lark adapters, multi-session scheduling, permission matrix, HUD
    • MIT licensed, self-hosted on your own machine
    • Community support via GitHub Issues
    Get cc-bot

  2. Pro

    $19.90/ month

    Support development and get the sintbot package to self-host.

    • sintbot — the daemon: Lark and Slack, Claude Code and Codex with a swappable model per group, per-group permissions and redaction, the design toolchain, the local console, and scheduled tasks. See what it does.
    • Everything in Free
    • Provided as is — no support response times, onboarding or update commitments
    Subscribe to Pro

sintbot is not a public download — after checkout, write to support@sintbot.com from your order address and we send you the current package. It is provided as is: the subscription does not include support response times, onboarding, updates or new features. It ships as readable source under a source-available license: run and modify it on up to three devices you own, keep what you received, but don't redistribute or resell it (terms). Prices in USD. Payments and taxes are handled by Creem as Merchant of Record. Cancel anytime from the Creem customer portal.

FAQ

Asked often, answered plainly.

What is SintBot?
A self-hosted daemon that binds a chat group — Lark or Slack — to a project on your own machine. Anyone in the group can hand it work; it runs Claude Code or Codex inside that project and posts progress and results back to the group.
How is it different from cc-bot?
cc-bot is a free, MIT-licensed Claude Code plugin: it lives inside your interactive session and uses that session's model. SintBot is a standalone daemon — nobody needs to keep a terminal open, each group has its own project, model and permissions, it drives both Claude Code and Codex, and it comes with a local console.
Which models can it use?
Claude through your local Claude Code login, GPT through your Codex subscription login, and GLM, DeepSeek, MiniMax or Kimi with your own keys — or any endpoint that speaks the Anthropic API, including an open-source model you host yourself. Each group picks its own, and anyone in the group can switch with /model.
Does switching models lose the project's memory?
No. A switch starts a fresh conversation, but the project's CLAUDE.md, AGENTS.md and memory directory are handed to whichever agent runs next, so conventions and long-term notes carry over. Long sessions are compacted automatically.
Where do my code and data live?
On your machine: project directories, sessions, memory and logs stay there. The daemon talks only to the services you configure — your chat platform and your model endpoints — and nothing is sent to us. Secrets are masked before any message reaches the group.
Do I need a server or a public IP?
No. It runs on a Mac or Windows machine you keep on, and it only dials out: a WebSocket long connection for Lark, Socket Mode for Slack. The console stays on that machine unless you choose to open it up.
What can the agent do by default?
Read only. Permissions are set per group, never globally: an unconfigured group can read and nothing else. You can grant full access or a tool preset, and the agent is always fenced to the project directory bound to that group.
How do I get SintBot?
It is not a public download. A Pro subscription supports development; after checkout, write to support@sintbot.com from your order address to receive the current package. It is provided as is, as readable source under a source-available license. Want something free first? cc-bot installs into Claude Code in two commands.

Put the project in the group.

See the daemon at work in a Lark or Slack group, or start free: cc-bot installs into Claude Code in two commands.

See how it works Free plugin on GitHub