Skip to main content
Glama

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

show_agenthub_monitor

Renders the dashboard inline in the host

yes

get_status

Returns the current pipeline state as structured JSON

yes

trigger_action

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: verify

Configure

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 tools
get_statusA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

A3.7/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose4/5

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.

Usage Guidelines2/5

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_monitorA
Read-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.

ParametersJSON Schema
NameRequiredDescriptionDefault
viewNoView mode.full

TDQS

A3.8/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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_actionA
Idempotent

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
actionYesAction to record.

TDQS

A3.9/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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.

  1. 3 tool updatesv1.0.0
    • First observedget_status
    • First observedshow_agenthub_monitor
    • First observedtrigger_action

TDQS

A3.8/5.0

Scored across 3 tools

Disambiguation4/5

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.

Naming Consistency4/5

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.

Tool Count4/5

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.

Completeness3/5

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

ActivityMaintained
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    Enables orchestration of MCP tool calls through declarative YAML-defined directed graphs with data transformation, conditional routing, and observable execution flows.
    65 npm
    22
    MIT
  • A
    license
    Not graded
    quality
    B
    maintenance
    Self-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.
    1
    Apache 2.0