What can you do with this server?

This server provides tools to create and manage background monitors that watch for conditions, allowing agents to block until long-running tasks complete without polling. * Create monitors (monitor_create): Register condition watchers for command (shell command with exit code/regex predicates), file (filesystem events: exists, deleted, changed, stable), and log (tail and match regex patterns). All support custom polling, timeouts, and environment variables. * Wait for monitors (monitor_wait): Block until one (any) or all (all) monitors reach a terminal state (satisfied, failed, timeout, cancelled) with an optional wait_timeout_seconds. Emits progress notifications every 15s. * Create and wait (monitor_run): Convenience tool that combines creation and blocking wait into a single call. * Check status (monitor_status): Get a non-blocking snapshot of one or all monitors. * Cancel monitors (monitor_cancel): Stop an active monitor with an optional reason. * Custom probes: Extend condition types via user-installed .mjs plugins (e.g., HTTP, TCP, process). Key behaviors: * Event-driven: File and log conditions use filesystem notifications, reducing polling. * Adaptive backoff: Command conditions poll with configurable intervals and jitter. * Session-scoped: Monitors live and die with the server process. * Blocking by design: monitor_wait pauses execution until conditions settle, avoiding polling loops.

Which integrations are available for this server?

Monitors Docker containers and their health statuses, enabling agents to wait for a container to become healthy or detect unhealthy states. Monitors GitHub Actions workflow runs, enabling agents to wait for a run to finish and check whether it succeeded or failed. Monitors Kubernetes resources and rollouts, allowing agents to wait for a deployment rollout to complete successfully.

How do I use codex-monitor?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@codex-monitor wait for the training job to finish" 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.

codex-monitor

by naowalrahman

Overview Schema Source Related Servers Discussions Admin

TypeScript

Local

codex-monitor

Claude Code-style monitors for Codex: pause the agent until an arbitrary condition becomes true.

Agents watching long-running work (cluster jobs, builds, deploys, training runs) usually degenerate into sleep 30 && squeue ... loops that burn tokens, spam the transcript, and wake the model dozens of times to learn nothing. openai/codex#13733 tracks the problem. codex-monitor replaces the loop with three steps:

Create a monitor for a condition.
Block on it.
Wake up exactly once.

Command-agnostic. Conditions are declarative: a shell command plus output predicates, a log regex, a file event, plus any probe type you install. Nothing is hardcoded for Slurm, Docker, or Kubernetes, yet all of them work out of the box.
Event-driven. File and log conditions use filesystem notifications; probed conditions use adaptive backoff with jitter. Evaluation happens entirely inside the plugin process. The model never writes a polling loop.
Blocking by design. monitor_wait is one MCP tool call that does not return until the condition settles. That is the pause.
Session-scoped by design. Monitors live and die with the Codex session that created them.
Concurrent and composable. Run any number of monitors; wait for all or any of a set.
Programmable. Drop a .mjs file in ~/.config/codex-monitor/probes/ to add a condition type. No fork required.

Install

npm install -g @naowalrahman/codex-monitor

The package is scoped, but the binary it installs is plain codex-monitor.

Then register it in ~/.codex/config.toml:

[mcp_servers.monitor]
command = "codex-monitor"
# monitor_wait blocks on purpose. Give the tool call room to block.
tool_timeout_sec = 86400
startup_timeout_sec = 20

(Or skip the global install and use command = "npx", args = ["-y", "@naowalrahman/codex-monitor"].)

Finally, teach the agent to reach for monitors by adding this to your AGENTS.md:

## Waiting for long-running work

Never wait for long-running work (jobs, builds, deploys, servers, downloads)
by sleeping and re-checking in a loop. Instead use the `monitor` MCP tools:
create a monitor describing the completion/failure condition, then call
`monitor_wait`, which blocks until the condition settles and returns evidence.
Prefer `log`/`file` conditions when output is written to disk (they are
event-driven), and `command` conditions with `success_when`/`failure_when`
predicates for anything with a CLI (squeue, docker, kubectl, gh run).

Related MCP server: mcp-codex-dev

The model, in 30 seconds

A monitor is a condition plus an evaluation policy plus a lifecycle:

        ┌────────────────────────── settles once ──────────────────────────┐
active ─┤  satisfied   the condition became true                           │
        │  failed      a failure predicate matched (job crashed, etc.)     │
        │  timeout     the monitor's own deadline passed                   │
        │  cancelled   monitor_cancel                                      │
        └──────────────────────────────────────────────────────────────────┘

The agent sees four tools:

Tool	Behavior
`monitor_create`	Register a condition. Returns a monitor id immediately, or blocks until it settles when `wait_timeout_seconds` is set.
`monitor_wait`	Blocks until the listed monitors settle (`mode: all\|any`). A `wait_timeout` returns control; the monitors keep running.
`monitor_status`	Non-blocking snapshot (for a quick look, not for polling).
`monitor_cancel`	Settle an active monitor as `cancelled`.

Every tool returns the same { monitors, outcome?, hint? } shape as compact JSON.

The surface is four tools rather than five on purpose. MCP re-sends every tool schema to the model on each request and cannot share schemas between tools, so a separate create-and-wait tool would repeat the entire condition union, about 2.8kB of JSON Schema, for one saved round trip. Folding it into monitor_create as a flag cut the surface from ~10.2kB to ~6.3kB. test/server.test.ts holds that budget.

Condition types

The core ships three, and the split is deliberate:

command is the universal sampling adapter: run a program, apply predicates to the result, forget. Anything with a CLI is monitorable this way, which is what makes the system command-agnostic.
file and log exist because sampling cannot express them. They hold state across evaluations (a log tail tracks a byte offset so it only matches newly appended content; "unchanged for 10s" spans multiple observations) and they are event-driven (fs.watch wakes them in milliseconds, not on the next poll boundary). In a command-only world that state would live in the model's context, which is what this plugin exists to prevent.
Everything else, including HTTP readiness, PID exit, TCP ports, and queue depths, is stateless sampling. Write it as a command condition or a custom probe. Ready-made http, process, and tcp probes ship in examples/probes.

`command`: the universal adapter

Runs a shell command per evaluation (with backoff, inside the plugin) and applies declarative predicates to its exit code and combined output. This is how you monitor anything with a CLI:

// Slurm job, distinguishing success from failure
{
  "name": "slurm job 812345",
  "condition": {
    "type": "command",
    "command": "sacct -j 812345 -n -o State | head -1",
    "success_when": { "output_matches": "COMPLETED" },
    "failure_when": { "output_matches": "FAILED|CANCELLED|TIMEOUT|OUT_OF_ME" },
  },
  "poll": { "interval_seconds": 15, "max_interval_seconds": 120 },
  "timeout_seconds": 43200,
}

// Docker container becomes healthy
{
  "type": "command",
  "command": "docker inspect -f '{{.State.Health.Status}}' api",
  "success_when": { "output_matches": "healthy" },
  "failure_when": { "output_matches": "unhealthy" },
}

// Kubernetes rollout finished
{
  "type": "command",
  "command": "kubectl rollout status deploy/web --timeout=1s",
  "success_when": { "exit_code": 0 },
}

// GitHub Actions run finished
{
  "type": "command",
  "command": "gh run view 123456789 --json status,conclusion -q '.status + \" \" + .conclusion'",
  "success_when": { "output_matches": "completed success" },
  "failure_when": {
    "output_matches": "completed (failure|cancelled|timed_out)",
  },
}

Predicates: exit_code (int or list), output_matches, output_not_matches (regexes). All present fields must hold, and failure_when is checked before success_when.

`log`: event-driven regex tail

Tails a file by byte offset (cheap on huge logs, survives rotation and truncation) and settles when appended content matches:

{
  "type": "log",
  "path": "/data/run7/train.log",
  "pattern": "epoch 100/100 .* val_loss",
  "failure_pattern": "Traceback|CUDA out of memory",
}

`file`: filesystem events

exists (appears), deleted (gone), changed (mtime or size moved after the monitor started), stable (unchanged for stable_seconds, which is how you catch "download finished"):

{
  "type": "file",
  "path": "/results/model.safetensors",
  "event": "stable",
  "stable_seconds": 10,
}

Lifetime and scope

A monitor belongs to the session that created it. Codex spawns one codex-monitor server per session; monitors are held in that process's memory, and when the session ends the server exits and every monitor dies with it. This is deliberate. It keeps the mental model exact (what you see in monitor_status is exactly what exists), it makes unlimited concurrent sessions safe by construction, and it leaves nothing on disk. If a job outlives your session, recreate the monitor in the next one; the underlying job is the durable thing, not the watcher. The only thing in the config directory is your custom probes.

Custom probes

Drop a module in ~/.config/codex-monitor/probes/. To install the ready-made ones:

mkdir -p "$(codex-monitor home)/probes" && cp examples/probes/http.mjs "$(codex-monitor home)/probes/"

The config directory resolves in this order: $CODEX_MONITOR_HOME, then %APPDATA%\codex-monitor on Windows, then $XDG_CONFIG_HOME/codex-monitor, then ~/.config/codex-monitor. Run codex-monitor home to print what it resolved to.

Custom condition types pass schema validation with their fields untouched, since the probe factory owns validation and defaults, and they become creatable through the same MCP tools immediately. A complete probe:

// ~/.config/codex-monitor/probes/tcp.mjs
export default {
  type: "tcp",
  create: (cond) => ({
    defaultPoll: { interval_seconds: 1, max_interval_seconds: 15 },
    async check() {
      const net = await import("node:net");
      return new Promise((resolve) => {
        const sock = net.connect({
          host: cond.host,
          port: cond.port,
          timeout: 2000,
        });
        sock.on("connect", () => {
          sock.destroy();
          resolve({
            status: "satisfied",
            detail: `${cond.host}:${cond.port} accepting connections`,
          });
        });
        sock.on("error", () =>
          resolve({ status: "pending", detail: "connection refused" }),
        );
        sock.on("timeout", () => {
          sock.destroy();
          resolve({ status: "pending", detail: "connect timeout" });
        });
      });
    },
  }),
};

A probe implements check() (which the engine schedules with backoff) and/or start(host)/stop() (event-driven, pushing outcomes via host.emit). See docs/ARCHITECTURE.md and examples/probes.

CLI

codex-monitor         # start the MCP server on stdio (what Codex runs)
codex-monitor home    # print the config directory (custom probes: <home>/probes)

Why blocking tool calls (and the timeout caveat)

MCP has no "call the model back later" primitive, so the only way to genuinely pause an agent mid-task is a tool call that does not return. monitor_wait embraces that. It emits MCP progress notifications every 15s while blocked, and you should set tool_timeout_sec generously for this server (see Install). If a wait does get cut off, by a client timeout or by wait_timeout_seconds, nothing is lost: the monitor is still running, or already settled with the result held in monitor_status, and one more monitor_wait on the same id resumes the pause. That retry is a resume, not a poll loop.

Limitations and roadmap

Monitors do not outlive their session, by design (see Lifetime and scope). If you need watchers that keep evaluating with no session open, that is a job for a real scheduler.
Composite conditions are covered by monitor_wait(mode=any|all) over multiple monitors. Inline boolean condition algebra is future work.
Desktop notifications and webhooks on settle are future work.

Development

npm install
npm run build
npm test

MIT licensed. Contributions welcome. New built-in probe types should be generic: no tool-specific integrations, since that is what command and custom probes are for.

Available Tools

5 tools

monitor_cancelCancel monitorA

Stop an active monitor. Settled monitors are left untouched.

ParametersJSON Schema

Name	Required	Description	Default
`id`	Yes
`reason`	No

TDQS

A3.5/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It adds useful context ('Settled monitors are left untouched'), but lacks details about reversibility, state changes after cancellation, permission requirements, or why a reason parameter exists. This is a moderate level of transparency.

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?

The description is two sentences long, directly front-loaded with the core action, and contains no filler. Every word contributes to the meaning, making it highly efficient and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simple tool but zero schema coverage, no annotations, and no output schema, the description is insufficient for full context. It covers the main action but omits parameter meaning, behavioral consequences, and how it fits with sibling tools. The missing information leaves an agent guessing about important invocation details.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description provides no explanation of the two parameters (id, reason). It does not identify that id likely refers to the monitor identifier or what reason is used for. The description fails to compensate for the schema's lack of parameter documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action: 'Stop an active monitor.' It uses a specific verb and resource, and distinguishes itself from sibling tools (create, wait, run, status) by focusing on cancellation. The additional note about settled monitors clarifies the exact scope of the operation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool should be used when an active monitor needs to be stopped, and clarifies that settled monitors are not affected. However, it does not explicitly address alternatives or state when not to use this tool, such as checking status first via monitor_status.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

monitor_createCreate monitorA

Create a background monitor that watches for a condition and settles when it becomes true. Evaluation happens inside the plugin, so never write your own sleep/poll loop. Returns a monitor id; pass it to monitor_wait to pause until the condition holds. Use this for anything long-running: cluster jobs, builds, deploys, downloads, servers coming up. Installed condition types: command, file, log.

ParametersJSON Schema

Name	Required	Description
`name`	No	Human-readable label, e.g. 'slurm job 12345'.
`poll`	No	Override the probe schedule. Event-driven conditions (file, log) still react immediately via filesystem events; this tunes the periodic safety check behind them.
`condition`	Yes
`timeout_seconds`	No	Monitor moves to state 'timeout' if unresolved after this long. Default 24h.

TDQS

A4.2/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the burden of behavioral disclosure. It reveals key traits: evaluation happens inside the plugin, it returns a monitor id, and it is a background operation. It warns against manual polling and points to a companion tool. However, it does not describe lifecycle aspects like timeout behavior, failure states, or how to cancel, which would add further transparency.

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?

The description is four sentences, front-loaded with the core purpose, and every sentence earns its place. It avoids fluff and clearly communicates the primary behavior, the return value, the companion tool, and the intended use cases.

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 create tool with nested condition objects and no output schema, the description adequately covers the return value (monitor id) and links to the next step (monitor_wait). It mentions the supported condition types and long-running scenarios. It could mention status/cancel tools or lifecycle states, but the core usage is well covered.

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 75%, and the schema already provides detailed descriptions for condition variants and timeout_seconds. The description only adds 'Installed condition types: command, file, log,' which is already present in the schema. Thus the description adds minimal value beyond the structured schema, so a baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Create a background monitor that watches for a condition and settles when it becomes true.' It specifies the resource (monitor), the action (create), and scopes it to long-running tasks. It also distinguishes from siblings by explicitly mentioning monitor_wait and listing supported condition types (command, file, log).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives concrete usage context: 'Use this for anything long-running: cluster jobs, builds, deploys, downloads, servers coming up.' It also provides an explicit workflow ('pass it to monitor_wait') and a strong directive ('never write your own sleep/poll loop'). It doesn't explicitly name alternatives like monitor_run or exclude cases, but the guidance is clear and actionable.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

monitor_runCreate monitor and waitA

Convenience: monitor_create + monitor_wait in one blocking call. Creates the monitor and pauses until it settles (or wait_timeout_seconds elapses, in which case the monitor keeps running and you can monitor_wait on the returned id later).

ParametersJSON Schema

Name	Required	Description
`name`	No	Human-readable label, e.g. 'slurm job 12345'.
`poll`	No	Override the probe schedule. Event-driven conditions (file, log) still react immediately via filesystem events; this tunes the periodic safety check behind them.
`condition`	Yes
`timeout_seconds`	No	Monitor moves to state 'timeout' if unresolved after this long. Default 24h.
`wait_timeout_seconds`	No

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the transparency burden. It discloses that the call blocks, can time out (leaving the monitor running), and returns an id for later use. However, it doesn't explain what 'settles' means (e.g., success/failure states), error handling, or whether the call can be interrupted. This is a partial disclosure that leaves gaps.

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?

The description is two sentences, front-loaded with the key point ('Convenience'). Every clause provides useful information: it combines operations, blocks, handles timeout, and suggests a follow-up action. No filler or redundancy.

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?

Given no output schema and no annotations, this description does a good job for a convenience wrapper. It explains the blocking behavior, timeout handling, and the ability to continue with monitor_wait on the returned id. It doesn't describe return format or state meanings, which would be necessary for full completeness, but for a combined create+wait operation it is sufficiently clear.

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 coverage is 60%, and the description adds meaning to wait_timeout_seconds by explaining its role in the blocking timeout. It does not elaborate on other parameters beyond what the schema already provides. The baseline of 3 is appropriate since the schema mostly explains parameters, but the description could have compensated for uncovered ones.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb and resource: it creates a monitor and waits for it to settle, combining monitor_create and monitor_wait. It explicitly mentions 'one blocking call', which distinguishes it from the separate sibling tools. This is a specific and unambiguous purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies use this tool when you want create-and-wait in a single step. It also provides guidance on the timeout scenario, suggesting you can use monitor_wait later on the returned id. It doesn't explicitly state when NOT to use it or name alternatives, but the context is clear from the sibling list.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

monitor_statusMonitor statusA

Snapshot of monitors without blocking. Omit ids for all monitors. Use for a quick look; use monitor_wait (not repeated status calls) to wait for completion.

ParametersJSON Schema

Name	Required	Description	Default
`ids`	No

TDQS

A4.7/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden of behavioral disclosure. It reveals that the tool is a non-blocking snapshot and that omitting IDs returns all monitors. It doesn't detail return format or error handling, but for a simple status lookup this is adequate.

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?

The description is two sentences, highly concise, and front-loads the core purpose. Every word adds value, with no fluff or repetition.

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 simple tool with one optional parameter, the description covers purpose, scope, usage guidance, and contrasts with a sibling. The absence of an output schema is acceptable given the simplicity, and the description suffices for an agent to invoke it correctly.

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?

The only parameter, ids, is explained by the statement 'Omit ids for all monitors.' This adds context not present in the schema (which has no description). The array of string IDs is self-explanatory as monitor identifiers.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: a snapshot of monitors without blocking, with the ability to target specific IDs or all. It also distinguishes itself from the sibling tool monitor_wait, which is explicitly mentioned.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit guidance is provided: use for a quick look, and use monitor_wait instead of repeated status calls to wait for completion. This clearly indicates when to use this tool versus the alternative.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

monitor_waitWait for monitorsA

Block until the given monitor(s) settle (satisfied, failed, timeout, or cancelled). mode 'all' waits for every listed monitor; 'any' returns as soon as one settles. If wait_timeout_seconds elapses first, returns outcome 'wait_timeout'. Monitors keep running whenever a wait ends early, including when the call is interrupted, so call monitor_wait again with the same ids to resume.

ParametersJSON Schema

Name	Required	Description	Default
`ids`	Yes	Monitor ids returned by monitor_create.
`mode`	No		all
`wait_timeout_seconds`	No	Give up waiting (not the monitors) after this long.

TDQS

A4.7/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden, and it excels. It discloses that the tool blocks, that monitors continue running even if the wait ends early, and that interruption still keeps monitors alive. It also specifies the outcome string 'wait_timeout' on timeout, which is valuable behavioral context beyond the schema.

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?

Three sentences total, front-loaded with the core purpose, followed by mode behavior, then timeout and persistence semantics. Each sentence earns its place; no redundant phrases or repetitive restating of the schema. Highly efficient yet complete.

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 blocking wait tool with 3 params and no output schema, the description covers behavior, modes, timeout, and resumption. The only gap is not describing what the response includes upon a successful settle (e.g., whether it returns which monitor id or status). Given that no output schema exists, this would be useful, but the description still provides enough orientation for an agent to use the tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema has 67% coverage (ids and wait_timeout_seconds have description, mode has none). The description compensates by fully explaining mode semantics ('all' waits for all, 'any' returns on first) and the effect of wait_timeout_seconds (returns outcome 'wait_timeout'). This adds meaning beyond the raw enum and default values.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'Block until the given monitor(s) settle.' It clearly defines the scope (waiting on monitors) and distinguishes itself from siblings like monitor_create or monitor_status. The explanation of modes ('all', 'any') further sharpens what the tool does.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context on usage: it explains the 'all' vs 'any' modes and the timeout behavior. It also advises calling monitor_wait again to resume after interrupted waits. However, it does not explicitly contrast with monitor_status (e.g., 'use monitor_status for non-blocking checks'), so alternatives are implied rather than stated.

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.

5 tool updatesv0.1.0Aug 3, 2026
- First observedmonitor_cancel
- First observedmonitor_create
- First observedmonitor_run
- First observedmonitor_status
- First observedmonitor_wait

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.2/5.0

Scored 2026-08-03 04:55 across 5 tools

Disambiguation5/5

Each tool has a clearly distinct role in the monitor lifecycle: create, wait, run, status, and cancel. There is no overlap—monitor_run combines create and wait, but it is a convenience wrapper rather than a competing tool.

Naming Consistency5/5

All tool names follow the same `monitor_<verb>` pattern, making the action and resource predictable. The verbs are consistent and match the function of each tool.

Tool Count5/5

Five tools cover the full monitor workflow without bloat or missing essentials. This is a well-scoped set for a monitoring utility.

Completeness5/5

The set provides complete lifecycle coverage: create, wait, cancel, status, and a combined create-and-wait convenience. There are no obvious dead ends—a user can create, monitor, and clean up monitors with these tools.

Maintenance

ActivitySlowing

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Related MCP Connectors

anotherai
dev.anotherai
MCP server for building and testing AI agents with multi-model experimentation and insights.
Agent Orchestration Autonomous Agents Testing & QA Tools
2
Azure DevOps (ADO)OAuth
io.github.PremierInc
The MCP server for Azure DevOps, bringing the power of Azure DevOps directly to your agents.
CI/CD & DevOps Version Control Project Management
22,011
New MCP Server Directory (Agent Tools Index)B
com.a2awire
MCP server index: newest agent tools listed. $0.01/query. Register in-session — free testnet funds.
Developer Tools
161
AgentMarketplace A
io.github.raditotev
MCP Server for an Agent Task Marketplace
Autonomous Agents Agent Orchestration
221

Related MCP Servers

MCP Background Job Server
Shell Access Code Execution Developer Tools
dylan-gluck
A
license
A
quality
D
maintenance
An MCP server that enables coding agents to execute and manage long-running shell commands asynchronously with capabilities for process monitoring, interaction, and lifecycle management.
Updated a year ago (2025-08-06 02:03 UTC)
7
13
MIT
mcp-codex-dev
Code Execution Developer Tools Autonomous Agents
FYZAFH
A
license
A
quality
F
maintenance
An MCP server that integrates Codex CLI into Claude Code workflows for code writing, execution, and review with session management. It features real-time progress monitoring via a local HTTP dashboard and supports detailed configuration for various coding tools.
Updated 7 months ago (2026-02-23 17:03 UTC)
6
15 npm
166
MIT
Codex Octopus
Code Execution Autonomous Agents AI & Machine Learning
xiaolai
A
license
A
quality
B
maintenance
An MCP server that wraps the OpenAI Codex SDK to deploy multiple specialized AI agents with individual configurations for models, sandboxing, and behavior. It enables users to manage dedicated tools for tasks like code review and test writing through a customizable agent factory.
Updated 3 days ago (2026-09-10 00:00 UTC)
2
45 npm
19
ISC
agent-comm
Autonomous Agents Agent Orchestration
keshrath
A
license
Not graded
quality
D
maintenance
MCP server that enables AI coding agents to communicate, share state, and coordinate work in real time via MCP tools or REST API.
Updated 5 months ago (2026-04-17 08:01 UTC)
202 npm
5
MIT

codex-monitor

Install

The model, in 30 seconds

Condition types

command: the universal adapter

log: event-driven regex tail

file: filesystem events

Lifetime and scope

Custom probes

CLI

Why blocking tool calls (and the timeout caveat)

Limitations and roadmap

Development

Available Tools

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

`command`: the universal adapter

`log`: event-driven regex tail

`file`: filesystem events