Mindscape: A Live Cognitive Graph for Hermes Agent

This is a submission for the Hermes Agent Challenge: Build With Hermes Agent

What I Built

I built Mindscape, a Hermes Agent plugin that turns agent activity into a live, visual cognitive graph.

The idea started from a simple fascination: Hermes Agent can plan, use tools, reason across multiple steps, and build context over time — but most of that process is normally hidden inside logs, chat messages, or terminal output.

I wanted to see the agent’s thinking structure visually.

So I built a Mindscape view for Hermes: an Obsidian-like graph where sessions, tool calls, reasoning snapshots, decisions, memory nodes, errors, and project architecture can become connected nodes.

Instead of treating an agent run as a flat chat history, Mindscape treats it as a growing map of cognition.

The plugin adds a new dashboard section inside Hermes where you can explore:

• a live graph view
• a timeline of cognitive events
• clustered concepts and tags
• searchable nodes
• an inspector panel with metadata, relations, timestamps, and node type

Mindscape is meant to answer questions like:

• What did the agent do?
• Which tools were involved?
• What decisions were made?
• Which concepts are connected?
• What reasoning or errors happened during a session?
• How does a project or task evolve over time?

It is both a visualization tool and a lightweight graph memory layer for Hermes Agent.

Demo

Here are a few screenshots from the current version.

Graph View

The graph view shows concepts as connected nodes. Different node types use different colors, and selecting a node opens the inspector on the right.

Example node types include:

• reasoning
• tool call
• decision
• session
• memory
• error
• manual nodes

Timeline View

The timeline shows the same graph as a chronological event stream. This makes it easier to understand what happened first, what came later, and how a session evolved.

Inspector

When a node is selected, Mindscape shows:

• title
• type
• content
• tags
• metadata
• timestamps
• relations to other nodes

This is useful when debugging an agent workflow or when trying to understand why a particular decision or tool call happened.

Code

GitHub repository:

https://github.com/southy404/hermes-mindscape

Install directly from GitHub:

hermes plugins install southy404/hermes-mindscape --enable

Then start the Hermes dashboard:

hermes dashboard

Open the Mindscape tab in the dashboard sidebar.

Mindscape also includes an optional example graph for quick testing:

curl -X POST "http://127.0.0.1:9119/api/plugins/mindscape/seed-demo?force=true"

The plugin works without the demo seed. The seed is only there to help users quickly see what the graph looks like.

My Tech Stack

• Hermes Agent
• Hermes plugin system
• Python
• FastAPI-style plugin API routes
• Hermes lifecycle hooks
• Hermes dashboard plugin extension
• Vanilla JavaScript
• SVG force-directed graph rendering
• CSS
• Local persistent JSON graph storage
• WebSocket-ready update flow

The plugin is structured as a standard Hermes plugin:

hermes-mindscape/
├── plugin.yaml
├── manifest.json
├── __init__.py
├── README.md
├── dashboard/
│   ├── plugin_api.py
│   └── dist/
│       ├── index.js
│       └── style.css
├── graph/
│   ├── store.py
│   └── events.py
└── hooks/
    └── graph_hooks.py

How I Used Hermes Agent

Hermes Agent is not just used as a theme or wrapper here. Mindscape is built around Hermes itself.

The plugin connects to Hermes in three main ways:

1. Hermes as the agentic source

Mindscape is designed around the kind of work Hermes does: planning, tool use, multi-step reasoning, session management, and project execution.

Instead of only showing the final answer, Mindscape tries to preserve the structure around the agent’s process.

A tool call can become a node.
A decision can become a node.
A reasoning snapshot can become a node.
A session can become a node.
An error can become a node.
A relation between two ideas can become an edge.

That makes the agent’s work easier to inspect after the fact.

2. Hermes plugin hooks

Mindscape uses Hermes plugin hooks to observe agent activity defensively.

The goal is not to interrupt Hermes or change its behavior. The goal is to listen, capture useful events, and convert them into graph data.

For example, hooks can capture:

• session start
• tool calls
• reasoning snapshots
• subagent events
• errors or failed actions

Those events are normalized into Mindscape nodes with metadata, tags, timestamps, and relations.

3. Hermes Dashboard integration

The project also extends the Hermes dashboard with a full custom UI.

I wanted the plugin to feel native inside Hermes instead of being a separate external app. The dashboard plugin provides:

• graph navigation
• zoom controls
• node creation
• editing and deletion
• timeline view
• cluster view
• search
• inspector panel

This makes Mindscape useful not only as a backend logging system but as an interactive visual workspace.

Why I Built It

I have always liked visual knowledge tools like mind maps, graph views, and Obsidian-style note networks.

When working with AI agents, I often found myself wondering:

What would it look like if the agent’s reasoning and tool usage became a living map?

Hermes Agent was a good fit for this idea because it already has the important pieces:

• tool use
• sessions
• plugins
• hooks
• dashboard extensions
• local-first execution
• multi-step agent workflows

Mindscape connects those pieces into a visual layer.

The long-term idea is that agents should not only produce answers — they should leave behind inspectable cognitive traces.

What Makes It Useful

Mindscape can help with:

• debugging agent workflows
• understanding which tools were used
• reviewing reasoning paths
• visualizing project architecture
• tracking decisions over time
• exploring agent memory
• showing non-technical users what an agent is doing
• turning hidden logs into visible structure

For example, if Hermes works on a complex project, Mindscape can show the related components, decisions, tools, errors, and sessions as a graph instead of scattered text.

That makes the agent feel less like a black box.

What Was Challenging

The hardest part was not only building the graph.

The hard part was making it feel like a real Hermes plugin:

• installable from GitHub
• visible in the Hermes dashboard
• safe to load
• persistent across sessions
• not dependent on personal demo data
• defensive when hooks are unavailable
• usable even with an empty graph
• clean enough for public release

I also had to make sure the plugin did not require manual local copying. The final version is structured so it can be installed directly through Hermes:

hermes plugins install southy404/hermes-mindscape --enable

What I Learned

This project made me appreciate Hermes Agent’s plugin architecture much more.

The plugin system makes it possible to build something that is not just a tool, but a new interface for understanding agent behavior.

I also learned that visualizing agent activity changes how you think about agents.

A chat transcript is linear.
A log file is technical.
A graph is explorable.

That makes a big difference.

Future Ideas

I would like to continue improving Mindscape with:

• richer live WebSocket updates
• better automatic semantic linking
• graph snapshots
• reasoning replay
• import/export
• SQLite storage
• 3D graph mode
• multi-agent views
• memory confidence scoring
• export to Markdown or Obsidian
• automatic project architecture mapping

The bigger vision is a Hermes-native cognitive map that grows as the agent works.

Final Thoughts

Mindscape is my attempt to make agentic behavior visible.

Hermes Agent can already plan, use tools, and reason through tasks. Mindscape adds a visual layer on top of that — a way to inspect the shape of the agent’s work.

For me, the exciting part is not only the graph itself.

It is the idea that open source agents should be understandable, inspectable, and explorable.

That is what Mindscape tries to make possible.