agenthub-monitor
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@agenthub-monitorshow the current pipeline dashboard"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
AgentHub Monitor
An MCP App server: it renders an interactive pipeline dashboard inside the host window (Claude Desktop, Claude Code, and other MCP App–capable clients) instead of returning a wall of text.
The dashboard shows two things side by side:
DAG state — nodes of a pipeline run, grouped into waves, each with its own status.
Harness metrics — scenario pass rate, critical failures, accumulated cost and latency.
Point it at your own pipeline's JSON export and it becomes a live view of your runs. With no configuration it serves a built-in sample, so the UI is useful the moment you install it.
Tools
Tool | What it does | Read-only |
| Renders the dashboard inline in the host | yes |
| Returns the current pipeline state as structured JSON | yes |
| Records an action request in the server's own state | no |
trigger_action does not execute anything. It annotates the server's in-memory state so the
dashboard can show that an action was requested. This server runs no commands, spawns no
processes, and makes no network calls.
Related MCP server: ui-mcp
Install
Requires Python 3.10+. No third-party dependencies.
git clone https://github.com/NEVELSK65/mcp-agenthub-monitor.git
cd mcp-agenthub-monitor
python3 -m unittest discover -s tests # optional: verifyConfigure
Add to your MCP client configuration:
{
"mcpServers": {
"agenthub-monitor": {
"command": "python3",
"args": ["/absolute/path/to/mcp-agenthub-monitor/server.py"],
"env": {
"AGENTHUB_STATE_FILE": "/absolute/path/to/your/pipeline-state.json"
}
}
}
}AGENTHUB_STATE_FILE is optional. Without it the server returns sample data, flagged with
is_sample_data: true so it is never mistaken for a real run.
State file format
Write this JSON from your own CI, orchestrator, or test harness:
{
"dag": {
"title": "Nightly build",
"total_nodes": 6,
"completed_nodes": 4,
"waves": 3,
"node_states": {
"node_01_checkout": "COMPLETED",
"node_02_unit_tests": "COMPLETED",
"node_03_integration": "RUNNING",
"node_04_security_scan": "PENDING"
}
},
"harness": {
"pass_rate_pct": 93.75,
"total_scenarios": 16,
"passed_scenarios": 15,
"critical_failures": 0,
"total_cost_usd": 0.112,
"total_latency_ms": 41700
},
"log": "Integration stage in progress."
}The file is re-read on every tool call, so the dashboard reflects whatever your pipeline last wrote.
Node status strings are passed through to the UI as-is; COMPLETED, RUNNING, PENDING and
FAILED get distinct colours.
Resource
The UI is exposed as an MCP resource at ui://agenthub/mcp-app.html with MIME type
text/html;profile=mcp-app. Hosts that support MCP Apps render it inline; hosts that do not can
still read it as an HTML document.
Privacy
The server reads one local file (the one you name in AGENTHUB_STATE_FILE) and sends nothing
anywhere. See PRIVACY.md.
License
MIT — see LICENSE.
Available Tools
3 toolsget_statusARead-onlyIdempotent
Return the current pipeline state as structured JSON. Reads the file given by AGENTHUB_STATE_FILE if set; otherwise returns in-memory state, which is flagged with is_sample_data=true.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations cover safety (readOnly, idempotent, non-destructive), so the bar is lower, and the description adds meaningful behavioral context beyond them: it explains the data source precedence (AGENTHUB_STATE_FILE vs in-memory) and, crucially, that in-memory returns are flagged with is_sample_data=true. That is a non-obvious trait an agent needs to trust the output.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences. The primary behavior (return pipeline state as JSON) is front-loaded, with the data-source nuance following. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-param read tool with strong annotations and no output schema, the description covers behavior and the sample-data caveat well. The one gap is the absence of any routing guidance versus the sibling status/monitor tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Zero parameters, so the baseline is 4. The description correctly implies no input is needed and instead explains the environment variable that governs behavior, adding value where there is no schema surface to document.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource: return the current pipeline state as structured JSON. It distinguishes itself from trigger_action (mutation) by being a read. However it does not explicitly name a sibling, so it stops short of full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No when-to-use vs alternatives guidance. It doesn't mention show_agenthub_monitor, which is the obvious sibling an agent might confuse this with, nor does it say when this tool is preferable. Usage must be inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
show_agenthub_monitorARead-onlyIdempotent
Render the interactive pipeline dashboard inline in the host. Shows DAG node states and test-harness metrics from the configured state file, or built-in sample data when no state file is configured.
| Name | Required | Description | Default |
|---|---|---|---|
| view | No | View mode. | full |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds genuinely useful behavioral context beyond that: it renders inline in the host, reads from a configured state file, and falls back to built-in sample data when none is configured. This fallback disclosure is exactly the kind of trait annotations cannot express.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tightly written sentences with the action verb front-loaded and zero redundant content. Every clause earns its place by adding either the render target or the data-source behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only, single-optional-parameter dashboard tool with no output schema, the definition covers purpose, render location, and data sourcing. Annotations handle the safety profile. Only the absence of any sibling-routing guidance keeps it from being fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the single 'view' parameter is fully documented in the schema, including its enum and default. The description adds no information about the view mode, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Render') plus a specific resource ('interactive pipeline dashboard inline in the host') and even names the data source (configured state file or built-in sample data). This is clear and specific, but it does not explicitly differentiate itself from siblings like get_status or trigger_action, so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'inline in the host' implies this is a visual rendering tool rather than a data-fetching tool, which hints at when to use it over get_status. However, there is no explicit when-to-use guidance, no stated alternatives, and no exclusions, so the guidance is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
trigger_actionAIdempotent
Record an action request in the server's in-memory state and return the updated state. This server does not execute commands, start jobs, or reach the network — it only annotates its own state so the dashboard can reflect a requested action.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action to record. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=false). The description adds genuine value beyond that by clarifying the side effect is limited to in-memory state and that no commands are executed, no jobs started, no network reached. It does not cover permissions or retention of the recorded state, keeping it short of a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero filler, and the core side-effect ('record an action request ... return the updated state') is front-loaded. The second sentence exists solely to prevent a common misreading (that this executes something), so it earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter tool with no output schema, the description supplies everything an agent needs: what is recorded, what is mutated, what is returned, and what is explicitly not done. The absence of an output schema is compensated by the stated return value ('the updated state').
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is a single parameter, fully documented by the schema (100% coverage) with an enumerated value set, so the schema carries the semantics. The description adds nothing about the meaning of the individual enum values (run-dag, run-harness, run-diff), which is the minimum viable baseline for a fully-covered single param.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: it records an action request into the server's in-memory state and returns the updated state. An agent immediately understands this is a state-annotation tool, not an executor. It does not explicitly name or contrast with the siblings (get_status, show_agenthub_monitor), so it stops short of full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied rather than stated: an agent can infer it should call this when it wants the dashboard to reflect a requested action, but there is no explicit when-to-use versus when-not, nor any reference to the sibling tools. The 'does not execute commands' note sets expectations for the caller but is not a selection guideline.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v1.0.0- First observed
get_status - First observed
show_agenthub_monitor - First observed
trigger_action
TDQS
Scored across 3 tools
get_status and show_agenthub_monitor both surface the same pipeline state and could be confused at a glance, but they differ clearly in output form (structured JSON vs. rendered inline dashboard). trigger_action is distinct in that it only annotates state rather than reading it. The descriptions explicitly clarify these boundaries.
get_status and trigger_action follow a clean verb_noun pattern, while show_agenthub_monitor bakes the server name into the noun (show_<server>_monitor). This is a minor deviation but still readable and predictable in intent.
Three tools is on the thin side, but for a narrow monitor-and-annotate purpose each tool earns its place: read state, render dashboard, record an action request. No padding or redundant tools.
The surface covers reading and rendering state plus recording an action, but there is no way to clear or acknowledge a recorded action, and no per-node querying or filtering. These gaps leave agents at a dead end after triggering an action, though the core monitoring loop works.
Maintenance
Related MCP Connectors
Dashboards as data. Author, validate, render, and share dvt dashboards from any MCP client.
Render, verify, describe, and safely edit Mermaid diagrams through MCP.
- mcpOAuthcom.slickfast
JSON in. Chart or Page out. Same picture forever. Scientific plots included.
Create, browse, remix, collaborate on, and run durable AI workflow nodes from MCP hosts.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables orchestration of MCP tool calls through declarative YAML-defined directed graphs with data transformation, conditional routing, and observable execution flows.65 npm22MIT
- FlicenseNot gradedqualityCmaintenanceEnables agents to render shadcn-styled dashboards, forms, charts, and comparisons in a local browser via MCP tools.8 npm2-
- AlicenseNot gradedqualityBmaintenanceA local, model-independent DAG task coordinator for AI coding agents, with a static visual UI, validated state machine, resumable JSON progress, and MCP tools.MIT
- AlicenseNot gradedqualityBmaintenanceSelf-hosted operational dashboard and MCP server that catalogs runnable services and their operational context, offering a read-only MCP endpoint to list projects, service status, runbooks, and reconciliation context.1Apache 2.0