Issue Station
Sign In
Tools hereToolbox

hermes - 💡(How to fix) Fix Feature Request: /smalltalk — Side Conversations for Async Subagent Sessions

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…

Code Example

[User] Working on main task: "Implement JWT auth in this Express app..."

[User] /smalltalk "What were the security concerns with JWT in localStorage again?"

[Hermes] 📎 Side talk #1 queued (est. 15s)
        "Security concerns with JWT localStorage"
        [Running...]

[Main task continues uninterrupted]

[Hermes - side notification] 📎 Side talk #1 ready
                           [View] [Merge] [Dismiss]

[User] /smalltalk merge 1
[Hermes] [Integrates concise answer into main context as collapsed note]

---

📎 Side Talk #2 (ready) — "Check zod union syntax"
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
│ Zod unions: z.union([z.string(), z.number()])
│ or z.string().or(z.number())
│
│ [Merge to Context] [Dismiss] [Keep for Later]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

---

┌─────────────────────────────────────────────────────────┐
│                    Main Hermes Session                  │
│  ┌─────────────────────────────────────────────────┐   │
│  │           User Conversation Thread              │   │
│  │  [Task: Implement auth]                         │   │
│  │       ↓                                         │   │
│  │  /smalltalk "check zod syntax"                  │   │
│  │       ↓                                         │   │
│  │  [Continues main task...]                       │   │
│  └─────────────────────────────────────────────────┘   │
│                          │                              │
│                          ▼                              │
│  ┌─────────────────────────────────────────────────┐   │
│  │         Side Talk Manager (Async Queue)         │   │
│  │  • Queue new side talks                         │   │
│  │  • Track completion state                       │   │
│  │  • Handle merge/dismiss actions                 │   │
│  └─────────────────────────────────────────────────┘   │
│                          │                              │
│              ┌───────────┼───────────┐                  │
│              ▼           ▼           ▼                  │
│  ┌──────────────┐ ┌──────────────┐ ┌──────────────┐    │
│  │ Subagent #1  │ │ Subagent #2  │ │ Subagent #3  │    │
│  │ (delegate)   │ │ (delegate)   │ │ (delegate)   │    │
│  │ Light model  │ │ Light model  │ │ Light model  │    │
│  └──────────────┘ └──────────────┘ └──────────────┘    │
└─────────────────────────────────────────────────────────┘

---

QUEUED → RUNNING → COMPLETED → {MERGED, DISMISSED}
   │         │
   └─────────┴──► FAILED (retry or notify)

---

/smalltalk "Research OAuth2 flows"
/smalltalk reply 1 "Focus on PKCE specifically"

---

/smalltalk --model gemini-flash "Quick lookup"
/smalltalk --model claude-sonnet "Complex analysis"
RAW_BUFFERClick to expand / collapse

Feature Proposal: /smalltalk — Side Conversations for Hermes Agent

Author: Apostol Apostolov
Status: Draft
Related: Inspired by pi-jarvis browser extension

1. Problem Statement

When working on complex multi-step tasks with Hermes, users often need quick answers to tangential questions without:

  • Losing context in the main conversation thread
  • Waiting for a blocking response that derails flow
  • Creating messy branching in the chat history

Current friction:

  • Interrupting a coding session to ask "what's the syntax for X again?"
  • Waiting for research that could happen in parallel
  • Context pollution from side queries mixing with main task

2. Proposed Solution: /smalltalk (or /sidetalk)

A parallel subagent session mechanism that:

  1. Spawns isolated side conversations that run asynchronously
  2. Queues results for deferred integration
  3. Never blocks the main session's flow
  4. Allows multiple concurrent side talks

2.1 Core UX Flow

[User] Working on main task: "Implement JWT auth in this Express app..."

[User] /smalltalk "What were the security concerns with JWT in localStorage again?"

[Hermes] 📎 Side talk #1 queued (est. 15s)
        "Security concerns with JWT localStorage"
        [Running...]

[Main task continues uninterrupted]

[Hermes - side notification] 📎 Side talk #1 ready
                           [View] [Merge] [Dismiss]

[User] /smalltalk merge 1
[Hermes] [Integrates concise answer into main context as collapsed note]

2.2 Command Interface

CommandDescription
/smalltalk <query>Spawn new side conversation
/smalltalk listShow active/completed side talks
/smalltalk view <n>View specific side talk result
/smalltalk merge <n>Fold result into main context
/smalltalk dismiss <n>Discard side talk
/smalltalk clearDismiss all completed

2.3 Visual Metaphor (Text Platforms)

Since Telegram/Discord are text-based, side talks appear as collapsible attachments:

📎 Side Talk #2 (ready) — "Check zod union syntax"
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
│ Zod unions: z.union([z.string(), z.number()])
│ or z.string().or(z.number())
│
│ [Merge to Context] [Dismiss] [Keep for Later]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

3. Technical Implementation

3.1 Architecture

┌─────────────────────────────────────────────────────────┐
│                    Main Hermes Session                  │
│  ┌─────────────────────────────────────────────────┐   │
│  │           User Conversation Thread              │   │
│  │  [Task: Implement auth]                         │   │
│  │       ↓                                         │   │
│  │  /smalltalk "check zod syntax"                  │   │
│  │       ↓                                         │   │
│  │  [Continues main task...]                       │   │
│  └─────────────────────────────────────────────────┘   │
│                          │                              │
│                          ▼                              │
│  ┌─────────────────────────────────────────────────┐   │
│  │         Side Talk Manager (Async Queue)         │   │
│  │  • Queue new side talks                         │   │
│  │  • Track completion state                       │   │
│  │  • Handle merge/dismiss actions                 │   │
│  └─────────────────────────────────────────────────┘   │
│                          │                              │
│              ┌───────────┼───────────┐                  │
│              ▼           ▼           ▼                  │
│  ┌──────────────┐ ┌──────────────┐ ┌──────────────┐    │
│  │ Subagent #1  │ │ Subagent #2  │ │ Subagent #3  │    │
│  │ (delegate)   │ │ (delegate)   │ │ (delegate)   │    │
│  │ Light model  │ │ Light model  │ │ Light model  │    │
│  └──────────────┘ └──────────────┘ └──────────────┘    │
└─────────────────────────────────────────────────────────┘

3.2 Implementation Details

Side Talk State Machine:

QUEUED → RUNNING → COMPLETED → {MERGED, DISMISSED}
   │         │
   └─────────┴──► FAILED (retry or notify)

Context Isolation Options:

  1. Clean slate — side talk gets query only, no main context
  2. Selective import — user can tag context lines to include
  3. Full context — side talk sees entire main thread (risk: pollution)

Recommendation: Start with Option 1 (clean slate) for predictability.

3.3 Integration Points

ComponentChange
delegate_taskAlready supports parallel subagents — extend for lightweight queries
Session stateAdd side_talks: Dict[id, SideTalk] to session context
Message renderingNew attachment type for collapsible side talk results
Command parserAdd /smalltalk command namespace

4. Advanced Features (Future)

4.1 Automatic Context Merge

When main task completes or hits a natural breakpoint, prompt:

"3 side talks completed during this session. Merge relevant ones?"

4.2 Side Talk Chaining

/smalltalk "Research OAuth2 flows"
/smalltalk reply 1 "Focus on PKCE specifically"

4.3 Persistent Side Talks

Side talks survive session restart (stored in ~/.hermes/smalltalk/)

4.4 Model Selection

/smalltalk --model gemini-flash "Quick lookup"
/smalltalk --model claude-sonnet "Complex analysis"

Default to cheaper/faster models for side talks.

5. Open Questions

  1. Result delivery timing: Should completed side talks notify immediately or wait for main task idle?
  2. Context pollution: How to prevent side talk results from confusing the main thread before merge?
  3. Platform differences: How does this map to Discord vs CLI vs future GUI?
  4. Quota/cost: Should side talks count against user's main quota separately?
  5. Naming: /smalltalk, /sidetalk, /aside, /parallel?

6. Minimal Viable Implementation

Phase 1 (MVP):

  • /smalltalk <query> command
  • delegate_task integration with lightweight model
  • "Side talk ready" notification with [Merge] [Dismiss] buttons
  • Simple list/clear commands

Phase 2:

  • Multiple concurrent side talks
  • Reply/chain functionality
  • Persistent storage
  • Model selection flags

Phase 3:

  • Smart merge suggestions
  • Side talk history/search
  • Auto-merge on session end option

7. Similar Prior Art

  • pi-jarvis — Browser extension for Pi AI, visual overlay approach
  • Claude Code /ask — Can ask questions without changing files
  • Cursor /chat — Side panel conversations in IDE
  • GitHub Copilot Chat — Separate chat panel for tangential queries

Hermes differentiation: Native async subagents, not just UI separation.

Request for Comments:

  • @maintainers: Feasible with current delegate_task architecture?
  • @community: Which UX pattern feels right for your workflow?
  • Priority: P2 (nice-to-have) or P1 (workflow blocker)?

extent analysis

TL;DR

Implement the /smalltalk feature by integrating a parallel subagent session mechanism that allows users to spawn isolated side conversations without blocking the main session's flow.

Guidance

  1. Define the Side Talk State Machine: Implement the state machine with states such as QUEUED, RUNNING, COMPLETED, MERGED, and DISMISSED to manage the lifecycle of side talks.
  2. Choose a Context Isolation Option: Select one of the three context isolation options (clean slate, selective import, or full context) to determine how much context is shared between the main task and side talks.
  3. Extend the delegate_task Component: Modify the delegate_task component to support lightweight queries for side talks, enabling parallel subagents.
  4. Design the Command Interface: Develop the command interface for /smalltalk with subcommands like list, view, merge, dismiss, and clear to manage side talks.

Example

# Example Side Talk State Machine Implementation
states = {
    'QUEUED': 1,
    'RUNNING': 2,
    'COMPLETED': 3,
    'MERGED': 4,
    'DISMISSED': 5
}

# Example Context Isolation Option: Clean Slate
def get_side_talk_context(main_context):
    return {}  # Return an empty context for the side talk

Notes

The implementation details may vary based on the specific requirements and the existing architecture of the Hermes system. It's essential to consider factors like performance, scalability, and user experience when designing the /smalltalk feature.

Recommendation

Apply the workaround by implementing the /smalltalk feature in phases, starting with the minimal viable implementation (MVP) and iteratively adding more functionality based on user feedback and testing results. This approach allows for a more manageable and flexible development process.

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…
#memory management#API rate limit#retriever error#indexing error#inference speed

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: /smalltalk — Side Conversations for Async Subagent Sessions