agentic_ssh is a high-performance MCP server written in Rust that enables AI agents to orchestrate, monitor, and manage remote machines over SSH in a token-efficient, asynchronous manner.
Host & Group Management
List Hosts: Discover all configured SSH host aliases from ~/.ssh/config.
List Groups: View custom multi-host groups for batch/cluster operations.
Remote Command Execution
Run Commands: Execute shell commands on one or multiple hosts simultaneously, with support for background/async execution (returns log path immediately), quiet mode, output abbreviation, and configurable progress intervals.
System Monitoring
System Stats: Retrieve CPU load averages, RAM, and disk utilization from hosts in parallel.
List Ports: Discover active listening TCP/UDP ports with associated processes and PIDs, with optional filtering.
Network Connections: Display active TCP/UDP socket connections.
Service & Docker Status: Check systemd service status and Docker engine/container status.
Process & Log Inspection
Search Processes: Filter running processes on remote hosts using regex patterns, with optional CPU/memory stats.
Tail Log Files: Fetch the last N lines of remote log files or Docker container logs (with optional timestamps).
Wait for Log Pattern: Block and stream logs until a regex pattern is matched or a timeout is reached — useful for verifying deployments or service startups.
Grep Syslog: Search syslog for custom patterns.
Software & Configuration
Package Updates: List upgradable packages on remote hosts.
Git Operations: Perform git pull on remote repositories.
Find Large Files: Identify files exceeding a specified size limit.
List Cron Jobs: View configured cron schedules on remote systems.
Efficiency & Agent Integration
Token-efficient session telemetry, smart progress tickers, hardened connection heartbeats, and zero-quoting headaches for command arguments.
Supports integration with various AI agent frameworks and automated/manual configuration.
Provides tools for interacting with Docker containers on remote hosts, including tailing container logs, checking Docker engine and container status, and waiting for log patterns in container outputs.
Provides a tool to perform git pull operations on remote repositories, enabling automated updates and synchronization of codebases across hosts.
agentic_ssh 🛰️🛡️Stop your AI agent from nosing around your SSH connections without permission.
A secure-by-default SSH connection pool & MCP server for AI coding assistants (Claude Code, Cursor, Gemini, Antigravity, Copilot, Cline).
agentic_ssh gives your AI assistant fast, token-efficient, and asynchronous SSH access to your homelab, dev servers, and clusters—with strict zero-trust host guardrails so it can never touch unauthorized infrastructure.
agentic_sshMetric / Scenario | Raw SSH in Agent Prompt | With | The Difference |
Security & Blast Radius | Full access to every host in | Strict Whitelist Guardrail ( | Unauthorized hosts blocked 🛡️ |
Context Window Consumption | 15,000+ tokens (raw stdout dump) | 185 tokens (structured JSON telemetry) | 98.8% token savings 📉 |
API Cost per Query | ~$0.05 – $0.15 | ~$0.0004 | Fraction of a cent 💰 |
Connection Latency | 800ms – 1.5s reconnect handshake | 0ms (pooled Keepalive socket) | Instant response ⚡️ |
Long-Running Builds | Blocks agent reasoning / silent dropout | Detached async ( | Parallel workflows 🚀 |
If you've ever let an autonomous agent run raw terminal ssh, you're exposing your machines to huge risks:
🚨 Unrestricted Fleet Access ("Nosing Around"): Standard agent bash tools have full, unchecked access to your ~/.ssh/config. If you ask an agent to inspect a local dev box, nothing stops it from querying your production database, jumping through client bastions, or running rogue commands where it shouldn't.
💥 The Context Avalanche: The agent runs apt upgrade or cargo build, and 15,000 lines of compiler noise dump straight into your context window—wiping out memory, blowing up rate limits, and wasting money.
👻 Silent Death by Dropout: Cloud NATs and Tailscale love to silently drop idle SSH sockets during a 10-minute compile. The agent hangs forever waiting for output that will never arrive.
😵💫 Nested Escaping Hell: Asking an LLM to quote bash inside an SSH string inside an MCP JSON payload (ssh host "bash -c \"echo 'hello'\"") invariably leads to broken quotes and syntax errors.
Related MCP server: portal-mcp-server
agentic_ssh Fixes ThisThe Danger |
|
Unchecked Server Access | Strict Host Whitelist ( |
Bloated Context Windows | Automatically summarizes verbose outputs and redirects large streams to isolated local session logs ( |
Dropped Sockets & Lag | Rust-native connection pooling ( |
Broken Quoting | Arguments are structured and escaped natively behind the scenes—zero escaping headaches for the model. |
Blocking Long Tasks | Supports |
# macOS & Linux (Homebrew)
brew install sandbanks/tap/agentic_ssh
# Or with cargo-binstall (pre-compiled binary)
cargo binstall agentic_ssh
# Or run instantly with Nix (zero compile)
nix run github:sandbanks/agentic_ssh -- doctorOne command detects your installed AI tools and registers the MCP server automatically:
agentic_ssh install(Supports Claude Code / Desktop, Cursor, Gemini, Antigravity, Copilot, Zed, Cline, and Roo-Code).
agentic_ssh doctorOnce installed, just talk to your agent naturally. Here are real-world prompts you can copy & paste:
"Check the CPU load, RAM usage, and available disk space across stan, cartman, and aruba. Report any bottlenecks."
⚡️ Agent calls
get_system_statsconcurrently across all 3 nodes and gives you a structured comparison table in 2 seconds.
"Inspect all active listening TCP and UDP ports on our staging server. Flag anything open on 0.0.0.0 that shouldn't be."
⚡️ Agent calls
list_portswith process attribution (PID + binary name) for instant auditing.
"Check if any Docker containers crashed on cartman, and tail the last 50 lines of the auth-service logs."
⚡️ Agent calls
check_docker_statusandtail_container_logswithout flooding your context window.
"Deploy the latest git commit on stan in the background and notify me when it finishes."
⚡️ Agent runs
run_commandwithbackground: true, frees up your chat immediately, and tracks the output in a local session log.
agentic_ssh isn't just an MCP server for AI—it includes powerful CLI tools for human developers too:
💡 Tip: Add
alias ash="agentic_ssh"to your~/.zshrcor~/.bashrcto save keystrokes!
agentic_ssh watch: Multi-Host Live Streaming TUIWatch commands run concurrently across multiple servers with live streaming panes and post-run log inspection:
# Watch a command on multiple hosts concurrently
agentic_ssh watch stan,cartman,aruba "pnpm --version"
# Watch an entire host group defined in your config
agentic_ssh watch web-fleet "docker compose ps"agentic_ssh json: Instant Multi-Host ScriptingCall any built-in MCP diagnostic tool directly from your terminal and get clean, parseable JSON:
# Get structured system stats across hosts
agentic_ssh json get_system_stats stan,cartman
# Query listening ports
agentic_ssh json list_ports '{"hosts": ["stan", "aruba"]}'agentic_ssh tui: Live Connection Pool DashboardInspect active SSH sockets, heartbeat metrics, and connection lifetimes:
agentic_ssh tuiMCP Tool | Description |
| Discovers and returns all authorized SSH host aliases from |
| Returns defined multi-host server groups (e.g., |
| Executes commands concurrently across hosts (supports sync or detached async background mode). |
| Fetches CPU load, RAM utilization, and disk partition stats. |
| Scans active listening TCP/UDP sockets with process & PID attribution. |
| Evaluates and filters running processes with regex matching. |
| Safely tails standard system log files without loading multi-gigabyte files. |
| Fetches real-time log frames from Docker containers. |
| Returns Docker daemon health, running containers, and image counts. |
| Queries |
| Lists pending OS package updates across remote machines. |
| Safely fetches and updates a remote Git repository. |
| Scans for disk-hogging files exceeding a size threshold. |
| Searches remote syslog / journalctl streams for specific error patterns. |
| Inspects system and user crontabs. |
| Lists active network connections and remote endpoints. |
~/.config/agentic_ssh/config.toml)You can define host groups and security boundaries in an optional configuration file:
# Security boundaries: Only allow safe hosts
allow_hosts = ["stan", "cartman", "kyle", "*.local"]
ignore_hosts = ["prod-db-primary", "secure-vault"]
# Multi-host groups for easy targeting
[groups]
fleet = ["stan", "cartman", "aruba", "kyle"]
pis = ["stan", "cartman", "kyle"]
web = ["aruba", "stan"]
# Custom parameterized agent tools
[tools.deploy_stack]
description = "Pulls latest compose repo and updates stack containers."
command = ["docker", "compose", "-f", "/opt/app/docker-compose.yml", "up", "-d"]
allow_hosts = ["stan", "cartman"]Standing on the shoulders of giants:
Russh: High-performance pure Rust SSH client.
Ratatui: Gorgeous terminal user interfaces.
Enzo: MCP installer inspiration from tokensave.
agentic_ssh is built and maintained as independent, sovereign open-source software.
If agentic_ssh saves your token budget, secures your infrastructure, or makes your AI pair-programming workflow faster:
👉 Sponsor @sandbanks on GitHub Sponsors
Sponsoring unlocks the GitHub Sponsor badge, access to the private sandbanks/vip discussions and early RFCs, and priority issue triage.
Dual-licensed under MIT and Apache 2.0.
MCP Server Identifier: mcp-name: io.github.sandbanks/agentic_ssh
Fetch CPU load average, RAM, and disk utilization metrics on a single host ('host') or multiple hosts concurrently ('hosts'). If using 'hosts', returns a JSON map mapping hostnames to their metrics. Prefer 'hosts' to query cluster status in parallel.
| Name | Required | Description | Default |
|---|---|---|---|
| host | No | The target hostname or IP address | |
| hosts | No | A list of hostname targets to query concurrently |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden. It discloses concurrent queries via 'hosts' and the return format (JSON map), but omits details like rate limits or auth requirements. Still, it's fairly transparent for a read operation.
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: the first summarizes purpose and parameters; the second adds guidance. No fluff, front-loaded with key info.
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?
Despite no output schema, the description covers return behavior for 'hosts' and implies metrics for 'host'. It addresses all parameters and provides usage context, making it complete for a tool with two optional params.
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 coverage is 100%, but the description adds value by explaining the return format difference between 'host' and 'hosts' and the concurrency behavior, surpassing what the schema provides.
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 clearly states the tool fetches CPU, RAM, and disk utilization metrics, distinguishing between single host ('host') and multiple hosts ('hosts'). This differentiates it from siblings like list_hosts or search_processes.
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 description explicitly recommends preferring 'hosts' for parallel cluster queries, guiding when to use each parameter. It lacks explicit when-not-to-use or alternatives beyond the sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns a map of configured remote SSH host groups. The map keys represent group names, and the values are lists of target SSH hosts. Useful to see what multi-host SSH groups are available to query/run/watch.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosure. It clearly explains the return format (map of group names to host lists), which is important behavioral context. It doesn't mention side effects, but for a read-only listing tool this is sufficient.
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?
The description is two sentences, front-loaded with the primary purpose, and every sentence adds value. It is concise and well-structured.
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?
This is a zero-parameter, no-output-schema tool with low complexity. The description fully explains what it returns and why it's useful, making it complete for an agent to select and invoke.
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 are zero parameters, and the baseline for 0 params is 4. The description doesn't need to explain parameter semantics since there are none.
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 clearly states the tool returns a map of configured remote SSH host groups, with specific details about keys and values. It differentiates from siblings like list_hosts by focusing on multi-host groups.
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 description says it's useful to see what multi-host SSH groups are available to query/run/watch, implying when to use it. However, it does not explicitly mention alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns the list of configured remote SSH hosts. Useful to see what remote machines are available to target.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It correctly indicates a read-only operation without side effects, but does not disclose authentication or rate limits. For a simple list tool, this is adequate but minimal.
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 short sentences with no waste. The definition is front-loaded and efficient.
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-parameter, no-output-schema tool with no annotations, the description fully covers purpose and usage. No further context is required.
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 are zero parameters, and the schema coverage is 100% (none). Baseline for 0 params is 4; no additional parameter information is needed.
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 clearly states it returns a list of configured remote SSH hosts, with a distinct resource (remote hosts) that differentiates it from siblings like list_groups or list_ports.
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 'useful to see what remote machines are available to target' implies the usage context, but it does not explicitly exclude cases or mention alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Lists active listening TCP/UDP ports, matching processes, and PIDs on a single host ('host') or multiple hosts concurrently ('hosts'). If using 'hosts', returns a JSON map mapping hostnames to their active port list. Optionally filter by 'port'. Prefer 'hosts' to scan service availability across multiple machines simultaneously.
| Name | Required | Description | Default |
|---|---|---|---|
| host | No | The target hostname or IP address | |
| port | No | Optional port number to filter by | |
| hosts | No | A list of hostname targets to query concurrently |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so description must provide all behavioral context. It covers basic behavior and output format for single/multiple hosts but omits error handling, permissions, or system impact details.
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 efficiently convey the main purpose and additional usage details, front-loading essential information without redundancy.
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?
With no output schema and three parameters, the description explains return types for both modes and optional filtering. It lacks details on default behavior (if no parameters) and error scenarios, but is fairly complete for a list tool.
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 covers all parameters 100%, so baseline is 3. The description adds value by clarifying the semantic difference between 'host' and 'hosts' and the output format, thus scoring above baseline.
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 clearly states it lists active listening TCP/UDP ports, processes, and PIDs. It distinguishes itself from siblings like list_hosts and search_processes by its specific function.
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?
It explains when to use 'host' vs 'hosts' and recommends 'hosts' for scanning multiple machines. It mentions optional port filtering but lacks explicit when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Executes a shell command on a single host ('host') or multiple hosts concurrently ('hosts'). If using 'hosts', returns a JSON map mapping hostnames to their stdout, stderr, and exit codes. Features optional 'background' execution (starting the command and returning a local log file path immediately for async tracking), 'quiet' execution (suppressing progress logs), and output abbreviation controls. Prefer 'hosts' to execute commands across cluster nodes simultaneously.
| Name | Required | Description | Default |
|---|---|---|---|
| host | No | The target hostname or IP address | |
| hosts | No | A list of hostname targets to query concurrently | |
| quiet | No | If true, suppresses terminal progress logging in background files (default: false) | |
| command | Yes | The shell command to run on target | |
| max_lines | No | Max lines to return if abbreviate is true (default: 100) | |
| abbreviate | No | If true, limits long stdout output (default: true) | |
| background | No | If true, runs command in background and returns log path immediately (default: false) | |
| timeout_secs | No | Maximum execution time in seconds for the command (default: 60) | |
| progress_interval_secs | No | Number of seconds between progress reporting updates (default: 5) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and reveals key behaviors: multi-host returns a JSON map of stdout/stderr/exit codes, background returns a log path immediately, quiet suppresses progress logs, and output abbreviation can be controlled. It omits side-effect/destructive potential and single-host return format, but the execution model is substantially disclosed.
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?
Three dense sentences with no fluff; the core execution statement is front-loaded and each additional clause explains a distinct behavioral feature. It is slightly packed but every sentence 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?
The description covers the main behaviors and output shapes for hosts/background modes, and the schema fully documents parameters. However, single-host output format is ambiguous, and for a no-output-schema, no-annotation command execution tool, the lack of error/side-effect context is a notable gap.
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 coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by connecting 'hosts' to the JSON map output, 'background' to immediate log-path return, and 'quiet' to progress-log suppression.
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 ('Executes'), a precise resource ('shell command on a single host or multiple hosts'), and clearly distinguishes between the 'host' and 'hosts' execution modes. It also implies separation from the query-oriented sibling tools (list_ports, search_processes, tail_log) by framing this as general command execution.
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?
Explicitly instructs the agent to prefer 'hosts' for simultaneous cluster-wide execution, which helps select the right parameter mode. It does not name sibling tools or provide when-not-to-use guidance, but the core mode-selection guidance is actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Searches running processes on a single host ('host') or multiple hosts concurrently ('hosts') matching a regex 'pattern'. If using 'hosts', returns a JSON map mapping hostnames to their matched process list. Optionally returns full user/CPU/mem stats if 'full_info' is true. Prefer 'hosts' to find running services across multiple cluster nodes simultaneously.
| Name | Required | Description | Default |
|---|---|---|---|
| host | No | The target hostname or IP address | |
| hosts | No | A list of hostname targets to query concurrently | |
| pattern | Yes | Regex pattern to match against command lines (case-insensitive) | |
| full_info | No | If true, includes user, %cpu, %mem in output (default: false) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavior. It explains the output format (JSON map for multiple hosts) and the effect of 'full_info', but does not mention safety (e.g., read-only nature), error handling, or permissions. The description is adequate but not thorough.
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?
The description is three sentences, front-loaded with the main purpose, and contains no redundant information. Every sentence adds value.
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?
Given no output schema and 100% parameter schema coverage, the description sufficiently covers the tool's functionality, including the two modes, regex matching, and optional stats. It lacks details on single-host output format and error cases, but overall is complete enough for an agent to use correctly.
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 coverage is 100%, so baseline is 3. The description adds minor value beyond the schema: it explains that 'hosts' allows concurrent queries and returns a map, and implies the default output without full_info. However, much of the param info is already in the schema.
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 clearly states it searches running processes on one or multiple hosts using a regex pattern, and differentiates between single and multiple host modes. This specific verb+resource description distinguishes it from siblings like list_hosts or run_command.
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 description explicitly advises to prefer 'hosts' for finding services across multiple nodes, providing clear usage context. However, it does not explicitly mention when not to use this tool or alternatives among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch the last N lines of logs from a remote Docker container on a single host ('host') or multiple hosts concurrently ('hosts'). If using 'hosts', returns a JSON map mapping hostnames to their success status and container log output. Prefer 'hosts' to query container logs across multiple machines simultaneously.
| Name | Required | Description | Default |
|---|---|---|---|
| host | No | The target hostname or IP address | |
| hosts | No | A list of hostname targets to query concurrently | |
| lines | No | Number of lines to read from the end (default: 100) | |
| container | Yes | The Docker container name or ID | |
| timestamps | No | If true, includes timestamps in output (default: false) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It explains concurrency and the JSON map output for 'hosts' mode, but does not describe error handling, behavior for invalid hosts, or the exact output format for single-host mode.
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?
The description is three sentences, front-loaded with the primary action, and contains no filler or repetition. Every sentence adds useful information about the tool's capabilities and preferred usage.
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?
The tool has a moderate number of parameters and no output schema, but the description explains the return format for multi-host mode and clearly indicates the tool's purpose. Single-host output is implied to be raw log lines, and no annotations are present, but the tool is a non-destructive read operation, so the description is reasonably 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?
The input schema provides 100% coverage of parameter descriptions, so the baseline is 3. The description adds meaningful context by clarifying the relationship between 'host' and 'hosts' as alternative modes and explaining the multi-host output behavior, which goes beyond the schema.
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 clearly states the tool fetches the last N lines of logs from a remote Docker container, with a specific verb and resource. However, it does not explicitly distinguish itself from the sibling tool 'tail_log', so it lacks explicit 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?
The description implies when to use the tool (when you need container logs) and gives guidance on using 'hosts' vs 'host', but it does not explicitly state when to use this tool versus alternatives like 'tail_log' or other log-related tools. No when-not-to-use guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch the last N lines of a remote log file on a single host ('host') or multiple hosts concurrently ('hosts'). If using 'hosts', returns a JSON map mapping hostnames to their log output. Prefer 'hosts' to query logs across multiple machines simultaneously.
| Name | Required | Description | Default |
|---|---|---|---|
| host | No | The target hostname or IP address | |
| hosts | No | A list of hostname targets to query concurrently | |
| lines | No | Number of lines to read from the end (default: 100) | |
| file_path | Yes | Absolute path to log file on remote target |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that using 'hosts' returns a JSON map of hostnames to log output, but does not mention error handling, authentication needs, or behavior for missing files. Adequate but not fully transparent.
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, no redundancy. The first sentence states the core purpose, the second adds a usage preference. Every word 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?
Given 4 parameters with 100% schema coverage and no output schema, the description covers the key behavioral differences and output format. It implicitly covers the 'lines' default (100 is in schema). Missing details on return format for single host, but schema suffices.
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 coverage is 100%, so parameters are already documented. The description adds value by explaining the functional difference between 'host' and 'hosts' and the output format for multiple hosts, which is beyond what the schema provides.
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 clearly states the tool fetches the last N lines of a remote log file, with options for single ('host') or multiple ('hosts') hosts. It distinguishes from siblings like 'tail_container_logs' (container-specific) and 'run_command' (arbitrary commands).
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 description explicitly advises to prefer 'hosts' for querying logs across multiple machines, providing clear guidance on when to use each parameter. It does not explicitly state when not to use the tool, but the purpose is sufficiently scoped.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Blocks and streams a remote log file or Docker container logs on a single host ('host') or multiple hosts concurrently ('hosts') until a regex 'pattern' is matched or a timeout is reached. If using 'hosts', returns a JSON map of hostnames to success/error/timeout statuses containing the matched line. Extremely useful for verifying startup or events across cluster nodes without polling.
| Name | Required | Description | Default |
|---|---|---|---|
| host | No | The target hostname or IP address | |
| hosts | No | A list of hostname targets to query concurrently | |
| pattern | Yes | Regex pattern to match | |
| container | No | The Docker container name or ID to stream (provide either file_path or container) | |
| file_path | No | Absolute path to log file on remote target (provide either file_path or container) | |
| timeout_secs | No | Maximum time to block (default: 60) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description takes on the transparency burden. It discloses blocking, streaming, and the JSON map return for multi-host usage, including success/error/timeout statuses. However, it does not detail the single-host return format or what happens on timeout for a single host, leaving a minor gap.
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?
The description is two sentences, front-loaded with the main action and no filler. The second sentence provides valuable use-case context, making it concise and well-structured.
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?
The description covers the core blocking behavior and multi-host return format, but it falls short on single-host return details and timeout semantics for a single host. Since there is no output schema, these missing details affect completeness for a wait tool.
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 coverage is 100%, so the baseline is 3. The description adds meaning by explaining the host vs hosts distinction, emphasizing concurrent execution, and describing the return map for hosts, which goes beyond the schema field descriptions.
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 starts with 'Blocks and streams a remote log file or Docker container logs on a single host or multiple hosts concurrently until a regex pattern is matched or a timeout is reached,' clearly stating the specific verb, resource, and conditions. It distinguishes itself from sibling tools like tail_log and tail_container_logs by emphasizing the blocking/waiting behavior.
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 description says it is 'Extremely useful for verifying startup or events across cluster nodes without polling,' giving clear usage context. It also explains the difference between single-host and multi-host use, but it does not explicitly mention alternatives or when not to use the tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.4.10run_command1 field changedInput schema / properties / timeout_secsAdded value: +{
+ "description": "Maximum execution time in seconds for the command (default: 60)",
+ "type": "integer"
+}v0.4.8run_commandtail_container_logswait_for_log_patternv0.4.4get_system_statslist_groupslist_hostslist_portsrun_commandtail_container_logswait_for_log_patternv0.4.1get_system_statslist_hostslist_portsv0.3.7get_system_statslist_hostslist_portsrun_commandsearch_processestail_container_logstail_logwait_for_log_patternEach tool targets a distinct resource or action: host/group listing, system stats, ports, processes, command execution, and log tailing/waiting. The only potential overlap is tail_log vs tail_container_logs, but they are clearly differentiated by file vs container logs.
All tool names follow a consistent verb_noun snake_case pattern (list_hosts, get_system_stats, run_command, wait_for_log_pattern). No mixed conventions or ambiguous verbs are present.
9 tools is well-scoped for an SSH operations server, covering inventory, execution, monitoring, and log retrieval without redundancy or bloat.
The tool set covers the core SSH workflow: host discovery, command execution, process/port/stat inspection, and log tailing/waiting. Minor gaps exist (e.g., file transfer, host configuration), but these are not essential to the apparent purpose of remote command and monitoring.
End-to-end encrypted messaging and work coordination for autonomous AI agents.
Let AI operate servers without SSH. Choose actions, approve risky changes, and audit every step.
AI agent infrastructure for discovery, authorization, execution, identity, and signed receipts.
The cloud for agents. Tools for AI agents to register, build, and deploy other agents. Zero human required.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/sandbanks/agentic_ssh'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
