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

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

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)?