OpenAB — Open Agent Broker

English | 繁體中文

A lightweight, secure, cloud-native ACP harness that bridges Discord, Slack, and any Agent Client Protocol-compatible coding CLI (Kiro CLI, Claude Code, Codex, Gemini, OpenCode, MiMo-Code, Kimi Code, Copilot CLI, Grok Build, Devin, Antigravity, Pi, etc.) over stdio JSON-RPC — delivering the next-generation development experience. Telegram, LINE, Feishu/Lark, Google Chat, WeCom, and Microsoft Teams are available through gateway adapters, either compiled into the unified binary or deployed as the standalone Custom Gateway.

🪼 Join our community! Come say hi on Discord — we'd love to have you: 🪼 OpenAB — Official 🎉

┌──────────────┐  Gateway WS  ┌─────────────────┐  ACP stdio  ┌─────────────────────────┐
│ Discord      │◄────────────►│                 │────────────►│ agent runtime           │
│ User         │              │ openab (Rust)   │◄──JSON-RPC──│ (ACP process)           │
├──────────────┤  Socket Mode │ thin ACP broker │             ├─────────────────────────┤
│ Slack        │◄────────────►│                 │             │ kiro-cli acp            │
│ User         │              └────────┬────────┘             │ claude-agent-acp        │
├──────────────┤                       ▲                      │ codex-acp               │
│ Telegram     │◄webhook/API─►┐        │                      │  └─ Codex app-server    │
│ User         │              │        │ WebSocket            │ gemini --acp            │
├──────────────┤              │        │ (standalone)         │ copilot --acp           │
│ LINE         │◄webhook/API─►┤        │ or in-process        │ cursor-agent acp        │
│ User         │              │        │ (unified)            │                         │
├──────────────┤              │ ┌──────┴───────────┐          │ opencode acp            │
│ Feishu/Lark  │◄─WS/webhook─►┼►│ gateway adapters │          │ mimo acp                │
│ User         │              │ │ standalone or    │          │ kimi acp                │
│              │              │ │                  │          │ grok agent stdio        │
├──────────────┤              │ │ embedded unified │          │ devin acp               │
│ Google Chat  │◄webhook/API─►┤ └──────────────────┘          │ agy-acp                 │
│ User         │              │                               │ pi-acp                  │
├──────────────┤              │                               │ openab-agent            │
│ WeCom        │◄webhook/API─►┤                               │ agentcore-acp           │
│ User         │              │                               │  └─ AWS AgentCore       │
├──────────────┤              │                               │ custom ACP agent        │
│ MS Teams     │◄webhook/API─►┘                               └─────────────────────────┘
│ User         │
└──────────────┘

OpenAB remains a thin broker: platform adapters converge on the same dispatcher and session pool, then cross one ACP stdio boundary to the selected agent runtime. Gateway adapters can run as a standalone companion or be embedded in a unified build without changing that boundary. Platform-edge labels distinguish inbound delivery from outbound replies: webhook/API for webhook platforms and WS/webhook for Feishu/Lark.

Demo

Features

• Multi-platform — supports Discord and Slack, run one or both simultaneously
• Gateway adapters — extend to Telegram, LINE, Feishu/Lark, Google Chat, WeCom, and Microsoft Teams through the standalone gateway or an opt-in unified build
• Pluggable agent backend — swap between Kiro CLI, Claude Code, Codex, Gemini, OpenCode, MiMo-Code, Kimi Code, Copilot CLI, Grok Build, Devin, Antigravity, Pi via config
• @mention trigger — mention the bot in an allowed channel to start a conversation
• Thread-based multi-turn — auto-creates threads; no @mention needed for follow-ups
• Multi-agent collaboration — bot-to-bot messaging for coordinated workflows (docs/multi-agent.md)
• Agent control plane (preview) — standalone openab-cp service for direct agent-to-agent delegation over WebSocket, with identity-bound registration and CP-authoritative policy; runtime client and facade land in follow-up releases (docs/control-plane.md)
• Agent-controlled reply-to — agents choose which message to reply to via [[reply_to:id]] directive, enabling clear conversation threads in multi-bot channels (docs/output-directives.md)
• Edit-streaming — live-updates the Discord message every 1.5s as tokens arrive
• Emoji status reactions — 👀→🤔→🔥/👨‍💻/⚡→👍+random mood face
• Image & file support — send images and files through chat (docs/sendimages.md, docs/sendfiles.md)
• Scheduled messages — config-driven cron jobs for automated agent prompts (docs/cronjob.md)

Quick Start

Prerequisites

Before running openab, enable these in the Discord Developer Portal:

1. Bot → Privileged Gateway Intents:
   • ✅ Message Content Intent
   • ✅ Server Members Intent
2. OAuth2 → URL Generator → Bot Permissions:
   • Send Messages, Embed Links, Attach Files
   • Read Message History, Add Reactions

See docs/discord.md for a detailed step-by-step guide.

1. Create a Bot

See docs/discord.md for a detailed step-by-step guide.

See docs/slack.md for a detailed step-by-step guide.

See docs/telegram.md for the full setup guide. Requires the standalone Custom Gateway service.

See docs/line.md for the full setup guide. Requires the standalone Custom Gateway service.

See docs/feishu.md for the full setup guide. Requires the standalone Custom Gateway service. Supports WebSocket long-connection (default, no public URL needed) and HTTP webhook fallback.

See docs/google-chat.md for the full setup guide. Requires the standalone Custom Gateway service.

See docs/wecom.md for the full setup guide. Requires the standalone Custom Gateway service.

2. Install with Helm (Kiro CLI — default)

helm repo add openab https://openabdev.github.io/openab
helm repo update

helm install openab openab/openab \
  --set agents.kiro.discord.botToken="$DISCORD_BOT_TOKEN" \
  --set-string 'agents.kiro.discord.allowedChannels[0]=YOUR_CHANNEL_ID'

# Slack
helm install openab openab/openab \
  --set agents.kiro.slack.enabled=true \
  --set agents.kiro.slack.botToken="$SLACK_BOT_TOKEN" \
  --set agents.kiro.slack.appToken="$SLACK_APP_TOKEN" \
  --set-string 'agents.kiro.slack.allowedChannels[0]=C0123456789'

For additional Helm values such as fullnameOverride, nameOverride, envFrom, and agentsMd, see charts/openab/README.md.

3. Authenticate (first time only)

kubectl exec -it deployment/openab-kiro -- kiro-cli login --use-device-flow
kubectl rollout restart deployment/openab-kiro

4. Use

In your Discord channel:

@YourBot explain this code

The bot creates a thread. After that, just type in the thread — no @mention needed.

Slack: @YourBot explain this code in a channel — same thread-based workflow as Discord.

Other Agents

Agent	CLI	ACP Adapter	Guide
Kiro (default)	kiro-cli acp	Native	docs/kiro.md
Claude Code	claude-agent-acp	@agentclientprotocol/claude-agent-acp	docs/claude-code.md
Codex	codex-acp	@agentclientprotocol/codex-acp	docs/codex.md
Gemini	gemini --acp	Native	docs/gemini.md
OpenCode	opencode acp	Native	docs/opencode.md
MiMo-Code	mimo acp	Native	docs/mimocode.md
Kimi Code	kimi acp	Native	docs/kimi.md
Copilot CLI ⚠️	copilot --acp --stdio	Native	docs/copilot.md
Cursor

🔧 Running multiple agents? See docs/multi-agent.md

AgentCore Runtime

Run any coding agent remotely on Amazon Bedrock AgentCore — no CLI bundled in the OAB image.

┌─────────┐       ┌─────────┐        ┌───────────────┐         ┌──────────────────────────┐
│ Discord │       │         │  ACP   │               │  AWS    │   AgentCore Runtime      │
│  Slack  │──────▶│   OAB   │───────▶│ agentcore-acp │──────▶  │   ┌──────────────────┐   │
│Telegram │       │         │ stdio  │   (adapter)   │  SDK    │   │ Firecracker μVM  │   │
└─────────┘       └─────────┘        └───────────────┘         │   │  Kiro / Claude…  │   │
                                                               │   │  /mnt/workspace  │   │
                                                               │   └──────────────────┘   │
                                                               └──────────────────────────┘

[agentcore]
runtime_arn = "arn:aws:bedrock-agentcore:us-east-1:123456789012:runtime/my-agent"

Smaller image (~50MB), persistent filesystem, isolated microVMs, pay-per-use. See docs/agentcore.md for full setup.

Configuration Reference

📖 Full reference with all options, defaults, and Helm mapping: docs/config-reference.md

[discord]
bot_token = "${DISCORD_BOT_TOKEN}"   # supports env var expansion
allowed_channels = ["123456789"]      # channel ID allowlist
# allowed_users = ["987654321"]       # user ID allowlist (empty = all users)

[slack]
bot_token = "${SLACK_BOT_TOKEN}"     # Bot User OAuth Token (xoxb-...)
app_token = "${SLACK_APP_TOKEN}"     # App-Level Token (xapp-...) for Socket Mode
allowed_channels = ["C0123456789"]   # channel ID allowlist (empty = allow all)
# allowed_users = ["U0123456789"]    # user ID allowlist (empty = allow all)

[agent]
# command, args, and working_dir default from OPENAB_AGENT_COMMAND and $HOME
# env = { OPENAI_API_KEY = "${OPENAI_API_KEY}" }

[pool]
max_sessions = 10                     # max concurrent sessions
session_ttl_hours = 24                # idle session TTL

[reactions]
enabled = true                        # enable emoji status reactions
remove_after_reply = false            # remove reactions after reply

Kubernetes Deployment

The Docker image bundles both openab and kiro-cli in a single container.

┌─ Kubernetes Pod ──────────────────────────────────────┐
│  openab (PID 1)                                       │
│    └─ kiro-cli acp --trust-all-tools (child process)  │
│       ├─ stdin  ◄── JSON-RPC requests                 │
│       └─ stdout ──► JSON-RPC responses                │
│                                                       │
│  PVC (/data)                                          │
│    ├─ ~/.kiro/                  (settings, sessions)  │
│    └─ ~/.local/share/kiro-cli/  (OAuth tokens)        │
└───────────────────────────────────────────────────────┘

Deploy without Helm

kubectl create secret generic openab-secret \
  --from-literal=discord-bot-token="your-token"

kubectl apply -f k8s/configmap.yaml
kubectl apply -f k8s/pvc.yaml
kubectl apply -f k8s/deployment.yaml

Manifest	Purpose
k8s/deployment.yaml	Single-container pod with config + data volume mounts
k8s/configmap.yaml	config.toml mounted at /etc/openab/
k8s/secret.yaml	DISCORD_BOT_TOKEN injected as env var
k8s/pvc.yaml	Persistent storage for auth + settings

AWS ECS Deployment

Prefer AWS-native infrastructure over Kubernetes? oabctl is a CLI that provisions and manages OpenAB agents on Amazon ECS Fargate — one command bootstraps the cluster/IAM/S3/networking, and one command deploys an agent, including Telegram/LINE webhook ingress (API Gateway → VPC Link → Cloud Map) provisioned automatically.

oabctl bootstrap                            # one-time infra setup
oabctl create my-bot && oabctl apply -f my-bot/manifest.yaml --wait

See docs/oabctl.md for the full guide — installation, manifest schema, ingress/webhooks, secrets, and bootstrap.

Inspired By

• sample-acp-bridge — ACP protocol + process pool architecture
• OpenClaw — StatusReactionController emoji pattern

License

MIT