Issue Station
Sign In
Tools hereToolbox

hermes - 💡(How to fix) Fix Feature Request: training_wheels — observation-only mode for messaging platforms [1 participants]

Official PRs (…)
ON THIS PAGE

Recommended Tools

×6

Utilities matched from this issue’s tags and category — try them while you read without losing context.

GitHub issue graph ai analysis

Paste a GitHub issue URL. We fetch that issue, discover linked issues from bodies/comments/timeline, collect linked pull requests, and produce a structured English report.

The report is written in English Markdown for sharing and archival.

Helpful · Quick feedback

Loading…
GitHub stats
NousResearch/hermes-agent#13694•Fetched 2026-04-22 08:04:40
View on GitHub
Comments
0
Participants
1
Timeline
0
Reactions
0
Author
dcopparidcoppari
Participants
dcopparidcoppari

Root Cause

  • Safety first: Lets operators validate agent behavior on sensitive channels (WhatsApp) before going live.
  • No context pollution: Unauthorized contacts are never processed — protects agent memory.
  • Zero tight coupling: The callback injection pattern means any platform can forward to any other without adapter-level dependencies.
  • Extensible: Works with any platform that has a fromMe concept (WhatsApp, Signal, Telegram, etc.)

Code Example

whatsapp:
  enabled: true
  training_wheels: true          # observe-only, no replies
  unauthorized_dm_behavior: ignore

---

💬 [IN] Juan Pérez:
Hola, necesito verificar mi factura

🤖 **Richard:**
Hola Juan! Tu factura actual es de $12.500...
RAW_BUFFERClick to expand / collapse

Problem

When deploying Hermes Agent as a gateway on messaging platforms (WhatsApp, Telegram, Signal, etc.), there are scenarios where you want to observe conversations without having the agent respond on that channel.

Common use cases:

  • Training/supervision mode: Watch how the agent would respond to WhatsApp messages before letting it reply live.
  • Cross-channel monitoring: Consume messages from one platform (e.g. WhatsApp) and forward the agent's response to another (e.g. Telegram) for review.
  • Safe onboarding: Gradually introduce the agent to new channels without risk of unwanted auto-replies.

Currently there is no built-in mechanism to "consume" messages without responding.

Proposed Solution

Add a training_wheels boolean flag per platform in config.yaml:

whatsapp:
  enabled: true
  training_wheels: true          # observe-only, no replies
  unauthorized_dm_behavior: ignore

Behavior

AspectNormal Modetraining_wheels Mode
Inbound messages from authorized usersAgent processes + repliesAgent processes, reply suppressed
Inbound messages from unauthorized usersPer unauthorized_dm_behaviorAlways ignored (no context pollution)
Outbound fromMe messagesNot forwarded to agentForwarded as [OBSERVATION] — agent sees context but knows it's monitoring
Response deliverySent back to source platformOptional callback to forward elsewhere (e.g. Telegram)

Design

  1. training_wheels as a standalone boolean — NOT a value of unauthorized_dm_behavior. This guarantees:

    • Unknown contacts are strictly ignored (no spam/context corruption)
    • Authorized conversations are fully visible to the agent

  2. from_me field on MessageEvent — Outbound messages (fromMe: true) bypass the user whitelist but are tagged so the LLM knows it's observing, not responding.

  3. _observation_forwarder callback — A pluggable async callback(source_event, response_text) injected into the adapter. When training_wheels is active, the normal adapter.send() is suppressed and the forwarder is invoked instead. This keeps platform adapters loosely coupled.

  4. Streaming disabled — Real-time streaming is forcibly turned off to prevent partial sends to the source platform.

Files Changed (reference implementation)

FileChange
gateway/config.py_normalize_unauthorized_dm_behavior — accept only pair/ignore. training_wheels as separate platform flag.
gateway/run.py_is_training_wheels(), streaming disabled, fromMe auth bypass, observation prefix, _make_observation_forwarder()
gateway/platforms/base.pyMessageEvent.from_me: bool, _observation_forwarder field, send suppression + forwarder invocation in _process_message_background
gateway/platforms/whatsapp.py_build_message_event extracts fromMe from bridge payload
WhatsApp bridge (external)WHATSAPP_TRAINING_WHEELS=1 captures all outbound messages with fromMe flag

Example Forwarder (Telegram monitoring)

The runner creates a forwarder that delivers observations to a Telegram home channel:

💬 [IN] Juan Pérez:
Hola, necesito verificar mi factura

🤖 **Richard:**
Hola Juan! Tu factura actual es de $12.500...

Outbound messages are tagged [OUT] so the supervisor sees the full conversation context.

Why This Matters

  • Safety first: Lets operators validate agent behavior on sensitive channels (WhatsApp) before going live.
  • No context pollution: Unauthorized contacts are never processed — protects agent memory.
  • Zero tight coupling: The callback injection pattern means any platform can forward to any other without adapter-level dependencies.
  • Extensible: Works with any platform that has a fromMe concept (WhatsApp, Signal, Telegram, etc.)

Open Questions

  1. Should training_wheels support a per-platform forward_to config key instead of a callback? (e.g. training_wheels_forward: telegram)
  2. Should there be a rate limit on forwarded observations to avoid flooding the monitoring channel?
  3. Is there interest in a "partial" mode where the agent responds only to explicit commands (slash commands) while training_wheels is active?

I have a working local implementation (config normalization, event suppression, callback injection, Telegram forwarder, test suite). Happy to open a PR if this aligns with the project direction.

extent analysis

TL;DR

Implementing a training_wheels flag in the Hermes Agent configuration allows for observe-only mode on messaging platforms, enabling training, supervision, and safe onboarding without auto-replies.

Guidance

  • Add a training_wheels boolean flag per platform in config.yaml to enable observe-only mode.
  • Implement the training_wheels mode behavior, including suppressing replies to inbound messages from authorized users and ignoring messages from unauthorized users.
  • Use a pluggable async callback to forward observations to another platform, such as Telegram, when training_wheels is active.
  • Consider adding a rate limit on forwarded observations to prevent flooding the monitoring channel.

Example

# Example forwarder that delivers observations to a Telegram home channel
async def observation_forwarder(source_event, response_text):
    # Send the observation to the Telegram home channel
    telegram_client.send_message(response_text)

Notes

The proposed solution requires changes to the Hermes Agent configuration and implementation, including adding the training_wheels flag, modifying the message processing behavior, and implementing the callback injection pattern.

Recommendation

Apply the proposed solution with the training_wheels flag and callback injection pattern to enable observe-only mode on messaging platforms, allowing for safer and more controlled agent deployment.

Vote matrix · Quick signals

Works
Did the solution work? Tap to confirm.
Easy Fix
Was it a quick fix?
Time Saver
Did it save you time?
Blocking
Was it severely blocking?
Common Issue
Are others likely hitting this too?
Flaky / Intermittent
Is it intermittent?
Verified / Reproducible
Can you reproduce it reliably?
Loading…
#network issue#logging issue#authentication issue#prompt issue#agent setup

Still need to ship something?

×6

Another batch ranked right after the header list — different links, same matching logic.

Back to top recommendations

TRENDING

hermes - 💡(How to fix) Fix Feature Request: training_wheels — observation-only mode for messaging platforms [1 participants]