One Agent, Every Channel

Your AI, everywhere you already message

The Problem

Your AI is trapped in one tab

You have a capable assistant with real skills and memory. But you must go to it, it forgets between sessions, and it only reacts when you open it.

LetsGo Gateway inverts all three — starting with where the agent lives.

Proof · Reach

One daemon already fans out to 18 channel adapters

The gateway registers 18 adapters — 5 built-in plus 13 entry-point plugins. Of those, 16 are real messaging platforms; canvas and webchat are web surfaces.

"Everywhere you already are" is countable, not aspirational.

18

registered channel adapters (5 built-in + 13 plugin)

16

true messaging platforms (+ canvas & webchat surfaces)

WhatsApp Telegram Discord Slack Signal Teams Matrix LINE

Setup · What this is

LetsGo Gateway is an Amplifier bundle, built essentially solo

Michael J. Jabbour authored all 65 commits (across two email identities). The active build was a 16-day sprint, with one later conformance fix.

A real project — now, how does one agent reach every channel?

65

total commits on HEAD

16

day active build window (Feb 15 – Mar 2 2026)

1

author: Michael J. Jabbour

15

Python modules (9 hooks + 6 tools)

Mechanism · One identity

Every channel routes through ONE SessionRouter into the same bundle

The router keys a session per sender+channel and spawns the same Amplifier bundle each time — so it's literally the same agent, same skills, wherever you reach it.

Same agent means it can also carry the same memory.

# daemon.py builds the router
SessionRouter(session_factory=self._create_session)

# router.py — one session per sender+channel
route_key = f"{channel}:{sender_id}"

# each session shells the same bundle
amplifier run --non-interactive --json

Mechanism · Memory

It stops forgetting: memories inject into context on every prompt

Memories persist in a shared SQLite + FTS5 store. On each prompt:submit, a <memory-context> block is injected within a 2000-token budget.

Same agent, durable memory — now let it act on its own.

Capture — score memorability (gate 0.30)
Store — SQLite + FTS5, consolidated at session end
Inject — <memory-context> on next prompt, max 2000 tokens

The Turn · Proactive

A scheduled heartbeat lets the agent act first, with no user present

A CronScheduler fires the HeartbeatEngine on a configurable schedule. Heartbeat sessions are full Amplifier sessions — all hooks and tools load — and responses route to channels.

An everywhere agent that also acts first — is that safe?

CronScheduler fires on a configurable schedule
HeartbeatEngine runs a full Amplifier session
No user interaction — output pushed to channel adapters

Payoff · The meta-rule

A proactive, everywhere agent still cannot cold-message anyone

"The AI can only reach someone who first reached out and was approved" is enforced in code in daemon.py send_to_channel() — with internal heartbeat agents the only exception — behind three independent defense layers.

That rule is what makes omnipresent + self-acting safe, not terrifying.

1Daemon blocked-sender patterns → DROP (all channels)
2Per-channel adapter filtering (DM-only) → DROP
3Outbound approved-sender + blocked-recipient → HARD BLOCK

The Pattern

Everywhere, remembering, proactive — opt-in only

Meet people where they already are, remember across sessions, and let the AI act first — but only ever toward people who reached you first and were approved.

One agent, every channel: reach inverted, safety kept.

Sources

Research Methodology

Feature status: Active

Primary source: michaeljabbour/amplifier-bundle-letsgo (verified at /tmp/letsgo-src; remote matches required repo). Every metric re-derived from command output.
Channels: cat gateway/letsgo_gateway/channels/registry.py + ls -d channels/*/ | wc -l → 5 built-in + 13 plugin = 18 adapters; ls -d channels/*/ | grep -vE 'canvas|webchat' | wc -l → 16 messaging.
Meta-rule: grep -n 'def send' gateway/letsgo_gateway/daemon.py + sed -n '414,449p' daemon.py → enforced in send_to_channel().
Defense in depth: sed -n '/### Defense in Depth/,/Each layer is independent/p' README.md → 3 independent layers.
Router: sed -n '13,55p' gateway/letsgo_gateway/router.py → route_key {channel}:{sender_id}, one bundle per session.
Memory: grep -n 'memory-context|inject|max_injection_tokens|prompt:submit' modules/hooks-memory-inject/.../__init__.py → 2000-token injection.
Heartbeat: cat context/heartbeat/heartbeat-awareness.md → CronScheduler fires HeartbeatEngine, full Amplifier sessions.
History: git rev-list --count HEAD (65) · git shortlog -sne HEAD (1 author) · git log --format='%ad' --date=short | sort | uniq -c (16-day window).
Modules: ls -d modules/hooks-*/ | wc -l (9) + ls -d modules/tool-*/ | wc -l (6) = 15.

Gaps / caveats: The Amplifier bridge currently shells out to the amplifier CLI (subprocess, not a native in-process API). "Same memory" is accurate at the persistence layer; a single live conversation across different channels is not claimed. README prose ("13 platforms", "14 modules", "22 skills") lags the filesystem, which is treated as ground truth. Data as of this repo state; one Jul 9 2026 fix falls outside the 16-day active window.

Primary contributor: Michael J. Jabbour (all 65 commits, two email identities, same person).