Skip to content

Commit b7defc3

Browse files
allen108108allen108108
committed
Replace default posts with introducing-openab article
1 parent 244ea62 commit b7defc3

6 files changed

Lines changed: 190 additions & 293 deletions

File tree

‎src/content/blog/first-post.md‎

Lines changed: 0 additions & 16 deletions
This file was deleted.

‎src/content/blog/introducing-openab.md‎

Lines changed: 190 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,190 @@
1+
---
2+
title: 'Introducing OpenAB: Your AI Coding Agent, Now in Your Team Chat'
3+
description: 'OpenAB is the chat-native runtime layer for ACP coding agents. An open-source broker that connects any ACP-compatible coding CLI to Discord, Slack, and other chat platforms.'
4+
pubDate: 'May 19 2026'
5+
---
6+
7+
*Your IDE is powerful. Your chat is where decisions happen. OpenAB connects the two.*
8+
9+
---
10+
11+
## The problem
12+
13+
AI coding agents are transforming how software gets built. Claude Code can refactor a module. Kiro CLI can scaffold an entire feature. Codex can fix a bug from a one-line description.
14+
15+
But there's a gap: these agents live in terminals. Your team lives in Discord and Slack.
16+
17+
When a junior developer hits a wall at 2 AM, they don't open a terminal — they post in the team channel. When a PM wants to understand why a deploy failed, they ask in the ops thread. When a code review needs a second opinion, the conversation happens in chat.
18+
19+
Today, bridging that gap means copy-pasting between tools, losing context, and breaking flow. The agent can't see the conversation history. The team can't see what the agent did. Nobody wins.
20+
21+
## What OpenAB does
22+
23+
**OpenAB is the chat-native runtime layer for ACP coding agents.** It's an open-source broker that connects any [Agent Client Protocol (ACP)](https://github.com/agentclientprotocol/agent-client-protocol)-compatible coding CLI to Discord, Slack, and other chat platforms.
24+
25+
ACP is a standard that lets AI coding tools communicate over a simple message protocol — think of it as a universal plug between chat apps and coding agents.
26+
27+
```
28+
┌──────────────┐ ┌──────────────┐ ┌──────────────────┐
29+
│ Discord │◄────────────►│ │────────────►│ coding CLI │
30+
│ Slack │ │ openab │◄───────────│ (acp mode) │
31+
│ Telegram │◄──webhook───►│ (Rust) │ │ │
32+
│ LINE │ │ │ │ kiro / claude / │
33+
│ Feishu │ └──────────────┘ │ codex / gemini / │
34+
│ Google Chat│ │ copilot / hermes │
35+
└──────────────┘ └──────────────────┘
36+
```
37+
38+
You `@mention` the bot in a channel. OpenAB spawns a thread, starts the agent, and streams responses back — live-edited every 1.5 seconds as tokens arrive. Follow-up messages in the thread go straight to the agent. No @mention needed.
39+
40+
The agent gets the full thread context. The team sees progress and output in real time. Context stays intact.
41+
42+
## Why this matters
43+
44+
### Your team already uses chat
45+
46+
Developers, PMs, designers — everyone's in Discord or Slack. Putting the agent where the team already is means:
47+
48+
- **Zero onboarding friction.** No new tool to install. Type a message, get code.
49+
- **Shared context.** The whole team sees what the agent did and why. No more "what did you ask it?"
50+
- **Async-friendly.** Start a task before lunch. Come back to a completed PR in the thread.
51+
52+
### One config, any agent
53+
54+
OpenAB doesn't lock you into a single AI provider. Swap the backend by changing one line in `config.toml`:
55+
56+
```toml
57+
[agent]
58+
command = "kiro-cli" # or "claude-agent-acp", "codex-acp", "gemini --acp"
59+
args = ["acp", "--trust-all-tools"]
60+
```
61+
62+
Supported agents today:
63+
64+
| Agent | Command | Status |
65+
|-------|---------|--------|
66+
| Kiro CLI | `kiro-cli acp` | ✅ Verified |
67+
| Claude Code | `claude-agent-acp` | ✅ Verified |
68+
| Codex | `codex-acp` | ✅ Verified |
69+
| Gemini | `gemini --acp` | ✅ Verified |
70+
| Copilot CLI | `copilot --acp --stdio` | ✅ Verified |
71+
| Hermes | `hermes-acp` | ✅ Verified |
72+
| Grok Build | `grok agent stdio` | 🧪 Community |
73+
| OpenCode | `opencode acp` | 🧪 Community |
74+
| Cursor | `cursor-agent acp` | 🧪 Community |
75+
76+
> *Status reflects integration testing as of publication. Community-contributed adapters may require additional setup.*
77+
78+
### Multi-agent collaboration
79+
80+
Teams can run multiple agents in the same server. With the right configuration, they can coordinate work through threads:
81+
82+
```
83+
@JARVIS implement the login feature
84+
└─ JARVIS writes code, @mentions FRIDAY for review
85+
└─ FRIDAY reviews, flags an issue
86+
└─ JARVIS fixes, marks ready for merge
87+
```
88+
89+
Bot-to-bot messaging is built in. Each agent runs in its own process with its own session. The specifics depend on your agent and gateway setup — we'll cover multi-agent patterns in a dedicated post.
90+
91+
## Architecture
92+
93+
OpenAB is written in Rust. A small, self-contained binary with no language runtime dependency.
94+
95+
Key design decisions:
96+
97+
- **Session pool** — one CLI process per thread, auto-managed lifecycle. Configurable max sessions and TTL.
98+
- **Edit-streaming** — the Discord message updates live as tokens arrive, not after the full response completes.
99+
- **Emoji status** — 👀 (seen) → 🤔 (thinking) → 🔥 (coding) → 👍 (done). Your team knows what the agent is doing at a glance.
100+
- **Thread isolation** — each conversation is a separate thread with its own agent session. No cross-contamination.
101+
102+
```
103+
┌─ Kubernetes Pod ──────────────────────────────────────┐
104+
│ openab (PID 1) │
105+
│ └─ kiro-cli acp (child process) │
106+
│ ├─ stdin ◄── JSON-RPC requests │
107+
│ └─ stdout ──► JSON-RPC responses │
108+
│ │
109+
│ PVC (/data) │
110+
│ ├─ ~/.kiro/ (settings, sessions) │
111+
│ └─ ~/.local/share/kiro-cli/ (OAuth tokens) │
112+
└───────────────────────────────────────────────────────┘
113+
```
114+
115+
## Getting started
116+
117+
### Prerequisites
118+
119+
1. A Discord bot token (or Slack bot + app token)
120+
2. The coding CLI of your choice installed
121+
3. Docker (for local dev) or a Kubernetes cluster (for production)
122+
123+
### Run locally with Docker (2 minutes)
124+
125+
```bash
126+
docker run -e DISCORD_BOT_TOKEN=your-token \
127+
-v $(pwd)/config.toml:/etc/openab/config.toml \
128+
ghcr.io/openabdev/openab:latest
129+
```
130+
131+
### Deploy with Helm (production)
132+
133+
```bash
134+
helm repo add openab https://openabdev.github.io/openab
135+
helm repo update
136+
137+
helm install openab openab/openab \
138+
--set agents.kiro.discord.botToken="$DISCORD_BOT_TOKEN" \
139+
--set-string 'agents.kiro.discord.allowedChannels[0]=YOUR_CHANNEL_ID'
140+
```
141+
142+
### Authenticate the agent (first time only)
143+
144+
```bash
145+
kubectl exec -it deployment/openab-kiro -- kiro-cli login --use-device-flow
146+
kubectl rollout restart deployment/openab-kiro
147+
```
148+
149+
### Use it
150+
151+
In your Discord channel:
152+
153+
```
154+
@YourBot explain the auth middleware in src/auth.rs
155+
```
156+
157+
The bot creates a thread and starts streaming the response. That's it.
158+
159+
## Beyond the basics
160+
161+
OpenAB ships with more than just chat-to-agent bridging. Scheduled messages let you set up cron-driven prompts (daily standups, weekly PR digests) without an external scheduler. Voice messages are auto-transcribed so you can talk to your agent. Screenshots and files sent in chat are passed directly to the agent. And a custom gateway service extends support to Telegram, LINE, Feishu, and Google Chat.
162+
163+
Each of these deserves its own deep-dive — we'll cover them in future posts.
164+
165+
## The stack
166+
167+
- **Language:** Rust
168+
- **Protocol:** Agent Client Protocol (ACP)
169+
- **Platforms:** Discord (Gateway WS), Slack (Socket Mode), Telegram/LINE/Feishu/Google Chat (Custom Gateway)
170+
- **Deployment:** Helm chart, raw K8s manifests, or Docker
171+
- **License:** MIT
172+
173+
## What's next
174+
175+
- Improved context management for long-running sessions
176+
- First-class MCP (Model Context Protocol) server integration per agent
177+
- Web dashboard for session monitoring
178+
- More platform gateways
179+
180+
## Get involved
181+
182+
OpenAB is 100% open-source under the MIT license. No CLA required.
183+
184+
- **GitHub:** [github.com/openabdev/openab](https://github.com/openabdev/openab)
185+
- **Discord:** [Join the community](https://discord.gg/DmbhfDZjQS)
186+
- **Contributing:** [CONTRIBUTING.md](https://github.com/openabdev/openab/blob/main/CONTRIBUTING.md)
187+
188+
We're especially looking for feedback from teams already running AI agents in their workflow. What's missing? What would make this indispensable instead of just interesting?
189+
190+
Come build with us.

0 commit comments

Comments
 (0)