hermes - 💡(How to fix) Fix [Feature]: Agent Activity API & Emotional State Exposure [1 participants]

Problem or Use Case

Here's a draft for you to review first:

Feature Request: Agent Activity API & Emotional State Exposure

Hey all — been using Hermes heavily across Telegram, Discord, and Home Assistant, and one thing I keep running into: there's no structured way to know what Hermes is doing in real-time.

The problem: Hermes runs quietly in the background — gateway sessions, cron jobs, subagents — but there's no external API to query "what's the agent doing right now?" You can check logs after the fact, but there's nothing pollable for live status.

What I'd love to see:

A lightweight activity endpoint (or file/socket) that exposes:

{
  "state": "thinking" | "tool_calling" | "responding" | "idle" | "error",
  "current_tool": "web_search",
  "session": "telegram:apt",
  "uptime": 86400,
  "last_activity": "2026-04-21T12:34:56Z",
  "active_sessions": 3,
  "expression": "curious"
}

Why this matters — beyond just status:

The real unlock here is making Hermes feel alive. Right now it's a black box that occasionally replies. If we had structured state exposure, you could:

🖥 Visual indicators — LED strips, desktop widgets, or dashboard panels that show green (idle), amber (thinking), blue (tool calling). Mine would sit on my desk as a physical "Hermes is working" light.

😊 Expressions & emotions — An expression field ("thinking", "excited", "confused", "working hard", "bored") would let frontends show animated avatars, emoji status, or even face tracking. Imagine Hermes "looking up" with a 🤔 while doing web research, then 😄 when it finds something.

🏠 Home automation — Home Assistant sensor that changes room lighting based on Hermes state. Purple when thinking, green when idle, red when errored.

📊 Multi-agent coordination — When spawning subagents, knowing which ones are active and what they're doing makes parallel workflows visible instead of invisible.

Happy to help prototype if needed.

Proposed Solution

Implementation ideas:

• Lightweight HTTP endpoint on a local port (like localhost:4817/status)
• Or a watched file at ~/.hermes/state/activity.json that the agent loop writes to on state transitions
• Could hook into the existing run_conversation() loop in run_agent.py — emit state changes at key points (before LLM call = "thinking", during tool dispatch = "tool_calling", on response = "responding")
• Gateway sessions write their own state; a coordinator merges them

The emotional/expression layer could be model-inferred or rule-based (e.g., tool called "web_search" → expression: "curious", error thrown → expression: "frustrated").

Bottom line: Hermes is already a capable agent. Giving it a pulse would make it a companion. The activity data is all there internally — it just needs to be surfaced.

Alternatives Considered

Skills: a skill can get you 60% of the way, but not the real-time stuff.

What a skill CAN do:

• Tail the gateway log and detect recent activity
• Write a heartbeat file every few seconds
• Parse cron job states from hermes cron list
• Monitor processes with pgrep
• Basically: "was Hermes active in the last N seconds?"

What a skill CAN'T do:

• Hook into the agent loop to emit "thinking" → "tool_calling" → "responding" in real-time
• Know the difference between waiting for an LLM response vs actually idle
• Capture subagent or cron session state (they're isolated processes)
• Emit structured emotional/expression metadata per action

The gap: A skill is always reactive — it reads logs after the fact. There's latency. Your visual indicator would show "Hermes was thinking 2 seconds ago" rather than "Hermes is thinking right now." For a green/amber/red status light, that's fine. For an animated expression that reacts to each tool call? You need the agent loop to emit events as they happen.

Feature Type

New tool

Scope

Medium (few files, < 300 lines)

Contribution

• I'd like to implement this myself and submit a PR

Debug Report (optional)