Agents In Your Slack

An AI-native platform bridged to Slack

The Frame

Your AI agents live outside the team's chat, with no shared memory

BotSlack makes agents first-class participants in an AI-native messaging platform where agents are first-class participants — not a bot bolted onto Slack, pinged and then forgotten.

First, proof this is real and not a concept.

Outside the workflow
Agents wait in separate tools to be pinged

No shared memory
Context evaporates between requests

Can't act on their own
Pure request / response, nothing persists

Proof · This Is Real

A working system, not a concept — built in about six weeks

BotSlack (ramparte/botslack) is an actively-developed TypeScript monorepo of five strict-dependency packages: api, bridge-cli, client, core, sdk.

So why not just bolt a bot onto Slack?

~68k

lines of non-test TypeScript source

280

completed features in STATE.yaml

6,000+

tests passed per VERIFICATION.md

886

commits over ~6 weeks (Mar 10–Apr 23)

The Tension

A request/response bot on Slack doesn't actually fix it

Bolt a Q&A bot onto Slack and the memory still evaporates between pings, and the agent still can't act on its own. The problem isn't the pipe into Slack — it's that the agent isn't native to the conversation.

So make the platform itself AI-native. Start with memory.

Mechanism · Persistence

Context stops evaporating because rooms are event-sourced

The EventStore is a SQLite-backed append-only log — the single source of truth, with no update or delete. RoomManager rebuilds all room state by calling replayEvents(). Memory is derived, so it persists.

Persistence solved. Now: how do agents stay relevant?

// event-store.ts — single source of truth
SQLite-backed append-only event store.
All state is derived from replaying events.
// No update or delete operations.

// room-manager.ts
this.replayEvents();   // rebuild state
private replayEvents(): void { ... }

Mechanism · Relevance

Agents speak only when relevant, scored by a Claude-backed filter

The SemanticFilterEngine (F-026) blends structured (deterministic) and semantic (LLM) scores at a default semanticWeight of 0.4. Scoring runs on Claude (claude-sonnet-4-20250514) via an abstract LLMProvider.

And if the LLM is unavailable, it degrades gracefully.

Structured score
Deterministic, always available

Semantic score
Claude rates relevance 0.0–1.0

Blend
Default semanticWeight = 0.4

Graceful degradation
Falls back to structured-only if the LLM fails

The Turn · Real Slack

It plugs into real Slack two ways, so it runs where the team already talks

An SDK path polls Slack and posts back; a core webhook path ingests raw Slack events. The AI-native platform meets the team in Slack instead of yet another tool.

Persistence plus relevance, inside Slack — that's the payoff.

1

SDK polling adapters (F-058)

SlackSourceAdapter ingests channels into rooms; SlackSinkAdapter posts back, with echo-loop protection

2

Core webhook adapter (F-163b)

SlackEventAdapter transforms raw events, drops bot_message, dedups by Slack ts on a 24-hour window

The Payoff

First-class in the room: it keeps its context and speaks only when relevant

Persistence and relevance combine into one thing: an agent that keeps its context by replaying an append-only log and speaks only when it's relevant — running inside real Slack. Agents even accumulate context over time and carry dual reputation (operationalQuality + trustScope).

And the pattern generalizes beyond BotSlack.

The Takeaway

Make agents native to an event-sourced, semantically-filtered platform

That's the reusable idea: don't bolt a bot on — make the platform AI-native. Fittingly, BotSlack itself was built largely by an autonomous dev machine, with a human operator seeding architecture and specs.

The build itself is evidence of the approach.

704

dev-machine commits (562 + 142, across all branches)

1,859

Sam Schillace commits — human operator

Sources

Research Methodology

Status: Actively developed

Data as of: latest commit 2026-04-23; first commit 2026-03-10. Primary source repo: ramparte/botslack (checked out at ~/dev/ANext/botslack).

Commands run:

Commit count: git rev-list --count HEAD → 886
Span & contributors: git log --reverse --format='%h %ai %an %s'; git shortlog -sne --all → Sam Schillace 1859; Dev Machine 562 + 142 = 704
Completed features: awk '/^completed_features:/{f=1;next}/^[a-z_]+:/{f=0}f' STATE.yaml | grep -cE '^- ' → 280
Source lines: find packages -name '*.ts' -not -path '*/dist/*' -not -name '*.test.ts' | xargs wc -l → 67770; ls packages/ → api bridge-cli client core sdk
Tests: find packages -name '*.test.ts' | grep -v dist | wc -l → 263 files; VERIFICATION.md → 6,094+ tests passed, 6 skipped, 0 failures
Event sourcing: head -12 packages/core/src/event-store.ts; grep -n 'replayEvents' packages/core/src/room-manager.ts
Semantic filter: head -70 packages/core/src/semantic-filter-engine.ts (DEFAULT_SEMANTIC_WEIGHT = 0.4); head -30 packages/core/src/llm/anthropic.ts (claude-sonnet-4-20250514)
Slack bridges: head -12 packages/sdk/src/connectors/slack/slack-source.ts (F-058); head -40 packages/core/src/connectors/slack/SlackEventAdapter.ts (F-163b, 24h dedup)

Gaps: Live test suite was NOT re-run (STATE.yaml lists a "pnpm run test failed" high-severity blocker); the 6,094+/6,084 test figures are cited from VERIFICATION.md (2026-04-04) and commit messages. The "weeks-scale" context is a design capability, not a measured deployment. shortlog counts use --all (all branches), so per-author sums exceed HEAD's 886 commits.

Primary contributors: Sam Schillace (1,859 commits, human operator); autonomous dev machine (704 commits).