What can you do with this server?

Proximo is a governed Proxmox control-plane MCP server for finding, inspecting, planning, and safely executing API operations across PVE, PBS, PMG, and PDM, with receipts and audit verification. * Find API addresses by plain-language query, with plane filtering and blast-radius/access hints. * Plan operations read-only: inspect verdict, required args, current target state, proposed change, and vendor schema before acting. * Read Proxmox data via GET paths or words, with lean rows, field selection, task waiting, change tracking, and diagnostics. * Execute governed mutations via POST/PUT/DELETE only with confirm=true, arming, and an authored blast-radius tier; every call is receipted. * Undo mutations by replaying a receipt's captured before-state through the vendor's own write path where supported. * Inspect the audit ledger for recent actions, mutations, targets, and truncation notices. * Verify ledger integrity by walking the hash chain and optionally checking against a pinned head or sealed archive.

Which integrations are available for this server?

Provides tools for managing Proxmox VE, Proxmox Backup Server, Proxmox Mail Gateway, and Proxmox Datacenter Manager, including guest lifecycle, storage, snapshots, container exec, and a trust layer for safe AI-driven infrastructure operations.

How do I use Proximo?

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., "@Proximo list all VMs on node pve1" 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.

Proximo

by john-broadway

Overview Schema Source Related Servers Discussions Admin

Python

Local

Named for Proximo, the lanista of Gladiator. The story is the design, joint for joint.

He armed his fighter with exactly what he needed, never more. He answered for every move in the arena. A lanista, not a jailer. The Spaniard earns his name by conduct, on the record, and the helmet comes off: truth said plainly, at cost. His last act opened the cages, holding the wooden sword of his own freedom. A tool should hope to end that well.

"Win the crowd and you will win your freedom."

The others make you pick: a read-only toy, or full keys and pray. Proximo won't. Every dangerous move is planned: the verdict, the live target and the change, before anything runs. Every move is proven: a tamper-evident record. And undoable wherever the platform gives us a primitive: a mutation captures the record it is about to change and puts it back through the vendor's own write; a risky in-container command can take a snapshot first, and refuses to run if it can't.

Trust built into the substrate, not bolted on after. Hand an AI agent the keys; keep the receipts.

Sovereign and agent-agnostic. Your metal, your token, a ledger you own. No cloud, no phone-home, no standing server unless you opt in.

What it does

Ask, in plain English: "why is ct 105 thrashing?" An AI agent pulls node and guest status, tails the logs, and (if you opened that lane) runs a diagnostic inside the container to find out.

If there's a fix, it shows you the plan before it touches anything: the verdict, the target as it stands, the exact change. Takes a snapshot first if you ask it to, and won't run if it can't. Applies. Hands you a keyed receipt of exactly what changed, with the before-state captured so it can be put back.

It does all of that with six tools, over every address the four Proxmox products publish. No wrappers, no catalog to page through, no tool per endpoint: find the address, plan it, read or call it, and prove the record. The whole surface fits a small local model's window.

That's the product: a hypervisor an AI can operate without being able to wreck it.

Read-only by default. No mutation runs on the first call: it returns its blast radius as a plan for you to see first. A tamper-evident receipt for every change.

The comparison isn't Proximo vs. the GUI. It's Proximo vs. handing an LLM your root token and hoping.

Don't take our word for any of it. Verify it yourself.

# 1. The tool count is real. Ask the door itself, cold (=> 6).
#    (in a clone of this repo, after `uv sync`)
uv run python -c "import asyncio; from proximo.core.doors.mcp import build_server; \
print(len(asyncio.run(build_server().list_tools())))"

# 2. The container image is what the repo built. Sigstore provenance (exit 0 = verified):
gh attestation verify oci://ghcr.io/john-broadway/proximo:latest --owner john-broadway

# 3. The security posture is graded by a third party, not by us:
#    https://scorecard.dev/viewer/?uri=github.com/john-broadway/proximo

The rest is in VERIFY.md: forge a ledger byte and watch verify() refuse, grep the outbound surface for phone-home (there is none). These checks work on any tool, from any vendor. Demand them everywhere.

Related MCP server: ProxmoxMCP-Plus

Quickstart

// your MCP client config (Claude Desktop / Claude Code / Cursor / …)
{
  "mcpServers": {
    "proximo": {
      "command": "uvx",
      "args": ["proximo-proxmox"],
      "timeout": 60,                                     // startup is ~3.5s; a 3s client default drops the server silently
      "env": {
        "PROXIMO_API_BASE_URL": "https://your-pve:8006/api2/json",
        "PROXIMO_TOKEN_PATH": "/path/to/token-file"   // USER@REALM!TOKENID=SECRET, by reference, never inlined
      }
    }
  }
}

Claude Code, one line:

claude mcp add proximo --env PROXIMO_API_BASE_URL=https://your-pve:8006/api2/json \
  --env PROXIMO_TOKEN_PATH=/path/to/token-file -- uvx proximo-proxmox

Or install with one click:

Install in VS Code Install in Cursor

Both prompt for the token file path; the secret never lands in client config. No token yet? uvx proximo-proxmox mint pve prints the least-privilege runbook.

Then preflight what your token can actually do (read-only):

uvx proximo-proxmox doctor

Start with a read-only token. Proximo is useful long before you grant it write. Full token-first walkthrough: docs/SETUP.md · more install paths: Install & run.

Why Proximo exists

Everything that touches a Proxmox product is a call: the web UI, pct and qm on a host, curl against the API, an agent's tool. Most of those calls leave no plan behind them, no receipt, and no way back. Proximo is the one client that governs the call before it runs, records it, and can put the record back, whichever door it came in by. Trust by construction:

	A call on its own	Through Proximo
Before it runs	nothing	a plan, recorded first: the verdict, the live target, the exact change, the blast radius
Record of what happened	app logs, editable	keyed, hash-chained ledger; `audit_verify` catches edits, reordering and, against a pinned head, truncation
Undo	by hand, if you kept notes	the record captured first, restored through the vendor's own write
Command inside an LXC	broad SSH	opt-in, fail-closed allowlist, judged like any mutation
Products covered	one at a time	PVE + PBS + PMG + PDM, one governed plane
Verify the artifact you run	varies	signed image · PyPI provenance · SBOM · Scorecard

Proximo is a community project, standing on its own. MCP, A2A, REST and a shell with no model in the loop are its doors; the governance is the product.

The trust layer: what makes Proximo different

The spine has six pillars. Four stand by default:

Control	What it does
PLAN	Every mutation first returns a recorded preview: the exact change, live state, blast radius, an advisory risk rating. Nothing mutates without its plan recorded; one `confirm=true` call records and performs.
PROVE	Keyed (HMAC-SHA256), hash-chained audit ledger; `audit_verify` catches edits, reordering, insertion. Pin the head off-box (`expected_head`) to catch truncation too: that's the strong guarantee, and it's opt-in.
UNDO	One rule: every mutation with a GET twin captures the record before it runs, and the receipt carries an `undo.id`; the restore is the vendor's own write at the same path, with the captured record, as a governed mutation (planned, armed, receipted, itself undoable). A container command can take a snapshot first and then fail closed if it can't. Where the vendor publishes no write to put a record back (a delete, a collection, a path with no PUT) the answer is a sentence, never a guessed reverse call.
DIAGNOSE	Read-only evidence battery + node health → advisory flags that surface incompleteness too, so an empty list never reads as a false clean bill.

Two are yours to raise, by design, off until their state paths exist, because both are only worth having if those paths sit outside the agent's reach. A pillar Proximo raised for you would be a pillar the agent could lower for itself:

Pillar (off until configured)	What it holds
CONSENT	Independent, out-of-band approval per plan: an agent (compromised, confused, or steered by injected text) cannot confirm its own mutation. Grants live in a directory only you write (`PROXIMO_CONSENT_DIR`), expire on a TTL, and never clear a taint.
CONTAIN	The kill-switch: one trip file halts every mutation immediately, mid-incident, no redeploy and no restart. Checked fresh on every mutation; fails closed. Put the trip path where only you can write (`PROXIMO_CONTAIN_TRIP_PATH`).

proximo doctor reports the spine: which pillars stand, which sockets are empty, and exactly how to fill them. Four more controls ship off until configured: ARM (a mutation runs only while the served token is the write token), a FORBID/RATE ENVELOPE, TAINT (the prompt-injection mitigation), and PRINCIPAL (who-asked attribution). Scope and lease are not Proximo's any more: the write token's own ACL is the scope and its own expire is the lease, both enforced by Proxmox, and proximo mint prints the commands that make such a token. What each control defends against: SECURITY.md.

Honesty note (load-bearing): risk ratings are an advisory heuristic, not a sandbox — LOW means "no state change," not "safe," and the absence of a HIGH flag is not a safety signal. Review every change yourself. The floor beneath it all is the token you mint: Proxmox RBAC holds even if Proximo's process is fully compromised — a stronger guarantee than anything Proximo's own code provides. Scope it to exactly what you mean to grant: SECURITY.md.

Hold any tool to this, including this one: The Keys Test. Ten questions to ask before you hand an AI agent real infrastructure. Proximo's own scorecard published, partials included.

Demo

The record defends itself:

Surfaces & tools: one control plane

Surface	Backend	For
Proxmox VE	REST API + scoped token	node/guest lifecycle, storage, SDN, identity, HA, firewall
Proxmox Backup Server	REST API + scoped token	datastores, namespaces, snapshots, sync, GC, verify, tape
Proxmox Mail Gateway	Ticket auth	mail flow, quarantine, filtering rules, domains, services
Proxmox Datacenter Manager	API token	federated fleet: reads plus governed control (power/snapshot/migrate, dry-run-first)
Container and node shell	`ssh` → `pct exec`, a fixed host battery	run-command-in-container, `psql`, log tailing, a host health read: what the API structurally can't do. Opt-in lanes, each behind its own switch and allowlist, judged like any mutation

Those backends are deliberately boring. Anyone can call them. The product is the trust layer over them.

Six tools, every address. The vendor publishes the API; Proximo serves it whole and governs each address by what it is: 1,804 published addresses across the four products, 884 reads, 785 mutations open to an armed operator each with an authored blast-radius tier, 32 opened by an operator's switch (guest agent, container and node shell), 5 on the download lane, 20 held on purpose with a sentence, 78 excluded as not JSON calls. The record is generated from the vendor's own schema and a stale copy fails the suite: docs/arena.md.

Where an operator actually starts, in the six-tool grammar:

You want to…	Say	Worth knowing
Find the address	`proximo_find "list datastores"`	verbs pick the method; the vendor's own words match
See the whole cluster at once	`proximo_read pve /cluster/resources`	lean rows (names, states, ids) and a total; `fields=all` for the vendor's rows
Find out why a container is sick	`proximo_read pve /nodes/{node}/lxc/{vmid} diagnose=true`	the battery: status, storage, failed tasks, and the shell probes if that lane is open
Power / lifecycle, any mutation	`proximo_plan`, then `proximo_call … confirm=true`	the plan reads the target first; nothing moves without `confirm=true`, an arm and a tier
Put it back	`proximo_call pve undo <undo.id>`	the captured record, written back through the vendor's own PUT
Preflight a token / config	`proximo doctor`	run this before wiring an agent
Prove the record wasn't touched	`audit_verify`	on every door, always

The six tools with typed inputs: docs/TOOLS.md · the walkthrough: docs/SETUP.md.

Install & run

The core alone, no model in the loop: the same install ships proximo-core pve GET /nodes/pve1/status (or --plan on any address: the verdict and the published schema, touching nothing), and the estate memory behind proximo-core learn | where 105 | uses local | changed 24h: what the governed reads have seen, answered from one file beside the ledger, no model, no network. Its import closure is httpx and nothing else (measured by a test); every published address on all four products; the same arm gate, tiers and audit ledger as the MCP door. The core has its own network doors, each the 0.44 face's perimeter with the core behind it: proximo-mcp-http (MCP over streamable HTTP), proximo-http (REST, POST /tools/{name} with an OpenAPI document) and proximo-a2a (an Agent2Agent card whose skills are the six tools).

📦 0.51.0: on PyPI, GitHub, and GHCR (signed multi-arch image).
New in 0.51.0 (the license is AGPL-3.0-or-later). Every release through 0.50.1 stays Apache-2.0, and the code contributors brought in stays available under it too. The rest are fixes. A read's answer stays under its cap: 394,752 reads at twelve cap settings, none over, and a cap set lower than an answer needs is raised to the default and named. In a running door a receipt no longer reads the whole ledger: on 0.50.1 a read cost 486 ms at 37,632 ledger rows, now 1.2 ms (a new process, as each proximo-core call is, still reads it once). A cut answer's fields= advice names keys its rows really carry.
Recent: 0.50.1 let the operator raise the exit ceiling (PROXIMO_EXIT_MAX_BYTES, up to 64 KiB, from alexdelprete's measurements on #114); 0.50.0 brought the estate memory back, one SQLite file beside the ledger answering learn | where | uses | changed with no model and no network; 0.49.1 routed shell calls across a cluster by target and node (from PR #107) and gave the operator the shell wait. See SECURITY.md for what each control honestly holds.

Proximo runs on your machine, on demand. No daemon, no open port.

uvx proximo-proxmox            # zero-install run (PyPI package: proximo-proxmox; command stays `proximo`)
# or: pip install proximo-proxmox            the core, MCP door included
# or: pip install "proximo-proxmox[a2a]"     + the optional A2A face
# or: pip install "proximo-proxmox[http]"    + the optional HTTP/OpenAPI face
# or: pip install "proximo-proxmox[mcp-http]" + the optional MCP-over-streamable-HTTP face
# or, from source:  git clone https://github.com/john-broadway/proximo.git && cd proximo && uv pip install -e .

Wire it into your MCP client as the command proximo, with the PROXIMO_* env vars; see packaging/proximo.env.example.

Docker (GHCR): docker run -i --rm … ghcr.io/john-broadway/proximo:latest. Multi-arch, SBOM, sigstore-signed provenance (gh attestation verify oci://ghcr.io/john-broadway/proximo --owner john-broadway). Mirrored to Docker Hub (docker.io/jebroadway/proximo, identical digest); GHCR stays the signed primary.

Safe by default: API-only out of the box. The two near-root edges are opt-in and say so loudly: LXC exec (PROXIMO_ENABLE_EXEC=1, near-root on the host) and the qemu-guest-agent edge (PROXIMO_ENABLE_AGENT=1, near-root in a guest). Each is scoped by its own fail-closed allowlist.
Smallest footprint by construction: the door advertises six schemas and nothing else. Measured on this release, tools/list over stdio is 5,544 bytes on the wire (about 1,400 tokens at the four-bytes-a-token heuristic; 1,568 as a stock 1.5B's chat template renders it, counted by its server), and that is the whole cost of connecting; the estate behind it is searched, not loaded. There is nothing to scope: a plane you have not configured is simply not reachable, a plane you have is reachable whole, and the gates do not shrink with the doorway. PLAN and PROVE apply to every address however small the model.

The network faces (experimental, opt-in): proximo-a2a speaks Agent2Agent. proximo-http serves plain HTTP + generated /openapi.json for no-code clients. proximo-mcp-http serves MCP itself over Streamable HTTP (the SDK's native transport) for networked MCP clients: no third-party stdio→HTTP bridge, so the perimeter stays Proximo's. LXC on your Proxmox host, one line: on the PVE node as root, bash -c "$(curl -fsSL https://raw.githubusercontent.com/john-broadway/proximo/main/packaging/lxc/ct/proximo.sh)" builds a Debian 13 container running proximo-mcp-http with Proximo from PyPI, its own service user, and a minted bearer on port 41243. Community-scripts engine (MIT) pointed at Proximo's own tree, their telemetry off; the same line inside the container updates it. Details: docs/SETUP.md, files: packaging/lxc/.

All three serve the full surface through the same spine as MCP. No second code path; trust spine and token scope inherited. Fail-closed perimeter: loopback, bearer-token required off-localhost, DNS-rebind and CSRF defended. Details: SECURITY.md.

At scale

One container is the demo. A cluster is the point.

The whole cluster in one call. proximo_read pve /cluster/resources: every VM, node, storage pool, SDN object, as lean rows with a total.
One tamper-evident record across every node. "Show me every state-changing action this month, and prove the log wasn't touched" becomes a query you can actually answer. No human at the CLI walks away with that.
Where the time comes back. On one node a senior at the CLI is faster, and that's fine. Across a dozen nodes and hundreds of guests, a bounded, audited agent earns its keep.

Many boxes, one Proximo: register remotes in a TOML file (secrets by reference, never inlined), point PROXIMO_TARGETS at it, aim a call with target="edge-pve" (the shell door: --target edge-pve). The target travels with the call. PLAN and EXECUTE hit the same box, the ledger records which, cross-plane calls error. Config shape: packaging/targets.example.toml.

Status: the arena record

🩸 0.51.0: AGPL-3.0-or-later from here; a read stays under its cap. 394,752 reads at twelve cap settings, none over; in a running door a receipt costs 1.2 ms at 37,632 ledger rows, where 0.50.1 took 486 ms. Eleven adversarial rounds closed. 4,651 tests. Every release before it (every pillar, every redteam, every fix) lives in CHANGELOG.md.

The numbers, honestly: six tools over 1,804 published addresses, governed by what each address is (its method decides read or write, total by construction; the blast-radius tier is the one human-authored column, and an untiered mutation is refused, armed or not). 4,651 in-process tests (ruff + pyright clean) pin the engine, the six pillars, the doors and the records, and a gate round neuters each pillar's gate one at a time and asks the suite to notice. This workspace administers its own Proxmox estate through Proximo daily (dogfood).

Proven live (not mocks): the governed path end to end against a real PVE 9 node through this door, plans reading the live target, receipts on the keyed chain, before-state captures and their restore. The 0.44 wrappers' live record (a 3-node cluster, PBS, PMG, PDM, a real cross-datacenter move) stays in CHANGELOG.md where it was earned; it is not re-claimed for the core. Not yet proven — said plainly: a small local model finishing a whole task through this door. Measured and driven on 0.45: a stock 1.5B behind llama.cpp with a 4,096-token context the server enforces, against a real PVE node, read-only. Its calls landed and the door's refusals named the fix each time (an invented field, the real ones listed); the prompt peaked at 3,074 tokens; the model did not finish the task, it invented a number. The window holds; a 1.5B does not. Hardware-watchdog fencing (needs physical iTCO/IPMI), and behavior at production scale. The 20 held addresses are never fired: refused by sentence, by design, not a gap.

Documentation

Document	What it answers
Setup	Token-first walkthrough: mint a least-privilege token, verify it, widen deliberately.
The Junction	Why Proximo exists: two roots on two planes, and the door that governs both lanes.
Verify	Every trust claim paired with the command that proves it. Run them cold.
Security	The two-deployment trust model, every control, what each honestly holds, reporting.
Threat model	What Proximo defends against, what it doesn't, where the boundaries sit.
Tools	The six tools, typed inputs: find, plan, read, call, and the two ledger reads.
Agents	The page written for the agent itself: Proximo's sharp edges, stated first.
Known issues	What's broken or odd right now, said plainly.
Contributing	Dev setup, the CI gates, what a PR is expected to keep intact.
Changelog	Every release, every redteam, every fix: the full build history.

License

AGPL-3.0-or-later, so nobody can take it closed. Full text in LICENSE. Every release through 0.50.1 was Apache-2.0 and stays Apache-2.0. The code Alessandro Del Prete (@alexdelprete) and RavenLiao contributed came in under Apache-2.0; their copyright stays theirs, and those portions remain available under Apache-2.0 as well (LICENSES/Apache-2.0.txt).

Credits

Built by John Broadway with Claude and Maude: a human-AI partnership, and the first thing we made on this box to give away to the world. Claude Opus 4.8 built the trust pillars and the original tool surface and has carried the work since; Claude Fable 5 ran the 101-agent release audit and the first publish. Every commit carries its co-author trailer. Outside contributors: Alessandro Del Prete (@alexdelprete), MCP over Streamable HTTP; RavenLiao (@RavenLiao), PVE SSH routed by target and node.

"Are you not entertained?" Stars, issues, and sparring partners welcome. Strength and honor. ⚔️

Available Tools

6 tools

audit_entriesC

Read-only

READ-ONLY: the PROVE ledger, newest first, bounded; says when it truncated.

Name	Required	Description	Default
`limit`	No
`action`	No
`target`	No
`mutations_only`	No

Output Schema

Name	Required	Description
No output parameters

TDQS

C2.9/5.0

Behavior4/5

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

Annotations already declare readOnlyHint=true, so 'READ-ONLY' earns no credit, but the description adds real behavior: results are ordered newest-first, the result set is bounded, and truncation is signaled explicitly. Ordering and truncation signaling are exactly the traits an agent needs to paginate or widen a limit.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

One front-loaded fragment with zero filler; the safety marker leads and ordering/truncation follow. It is arguably too terse for four undocumented parameters, but nothing is wasted.

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?

An output schema exists, so return values needn't be explained, but with zero schema description coverage across four parameters and no usage guidance, the agent is left guessing about action/target/mutations_only semantics. For a filtered ledger read, this is incomplete.

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

Parameters2/5

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

Schema description coverage is 0% for four parameters, so the description must compensate and does not. 'bounded' hints at limit and 'truncated' at the same, but action, target, and mutations_only are undocumented in both schema and description – an agent cannot tell what values action/target accept or what mutations_only filters.

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

Purpose3/5

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

Names the resource ('the PROVE ledger') and ordering ('newest first') but uses no verb – the read action is only implied by 'READ-ONLY'. Sibling audit_verify is separated only implicitly (ledger reading vs. verification), so an agent must infer the distinction.

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 statement of when to use this over audit_verify or proximo_read, and no exclusions or prerequisites. The only guidance is the read-only marker, which is already in annotations.

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

audit_verifyA

Read-only

READ-ONLY: walk the chain, report the first break; expected_head catches a cut tail; path= checks a sealed archive.

Name	Required	Description	Default
`path`	No
`expected_head`	No

Output Schema

Name	Required	Description
No output parameters

TDQS

A3.9/5.0

Behavior4/5

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

The description reinforces the readOnlyHint with an upfront READ-ONLY label and adds useful behavior beyond annotations: it walks the chain and reports the first break. It also explains that expected_head detects a cut tail, which is meaningful verification context. With an output schema present, return details need not be repeated.

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?

Extremely compact and front-loaded. The READ-ONLY constraint comes first, followed by the core behavior and the two parameter use cases, with no wasted text.

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 the output schema and readOnly annotation, the description provides the essential operational context: read-only nature, chain-walking behavior, truncation detection, and archive checking. A brief clarification of what 'chain' refers to would make it fully self-contained.

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?

Schema description coverage is 0%, so the description carries the burden and does so reasonably. It assigns clear meaning to path as an archive path and expected_head as a truncation check, though it omits optionality, format expectations, and examples.

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 combination: walking an audit chain and reporting the first break. It separates itself from audit_entries by describing verification rather than listing, though 'chain' remains somewhat jargon-dependent and the sibling is not named explicitly.

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 description explains when to use each parameter — expected_head for detecting a truncated tail and path for checking a sealed archive. It does not state when to choose audit_verify over audit_entries or other alternatives, leaving selection guidance implicit.

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

proximo_callA

MUTATION: run a governed POST/PUT/DELETE. Without confirm=true it returns the plan (verdict, consent id, current, change) and mutates nothing. Refused unless the operator is armed AND the address has an authored blast-radius tier. Every call, refused or executed, is receipted. Task-backed calls are waited on (wait=N s, default 60, max 600; 0 submits only). method=undo with path=<undo.id> puts a receipt's capture back, plan first; withheld or unpublished keys come back as skipped.

Name	Required	Description	Default
`args`	No
`path`	Yes
`wait`	No
`plane`	Yes
`method`	Yes
`confirm`	No

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.5/5.0

Behavior5/5

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

Annotations only say readOnlyHint=false; the description carries everything else: dry-run default, refusal preconditions (armed operator, blast-radius tier), receipting on every call including refusals, task-backed wait semantics with default and max, and undo restore behavior with skipped-key outcomes. That is exactly the beyond-annotation context an agent needs before invoking a destructive tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads 'MUTATION:' as a hazard marker and packs only actionable facts into seven short clauses with no filler. It is dense to the point of terseness in places (e.g. 'current, change' unpacked), but nothing is extraneous.

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?

Output schema exists, so return values needn't be described, yet the plan verdict/consent-id/current/change are still named helpfully. For a governed mutation with refusal paths, receipts, and async waiting, the coverage is strong; the main omissions are what args accepts and what each plane (pve/pbs/pmg/pdm) governs.

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?

Schema description coverage is 0%, so the description must compensate. It explains confirm (default false, plans only), wait (N seconds, default 60, max 600, 0 submits only), method=undo paired with path=<undo.id>, and the plan payload fields. It leaves args (nested object) and the plane enum values unexplained, so a small gap remains.

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?

Opens with 'MUTATION: run a governed POST/PUT/DELETE', a specific verb plus resource plus governance scope. The read/plan siblings (proximo_read, proximo_plan) are implicitly separated because this tool explicitly mutates, and the plan-without-confirm behavior clarifies the boundary with proximo_plan.

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?

Gives concrete conditions: without confirm=true it only plans; refused unless operator is armed and the address has an authored blast-radius tier; method=undo reverts a receipt. It never explicitly names proximo_plan or proximo_read as the alternatives to use instead, so the routing guidance is conditional rather than comparative.

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

proximo_findB

Read-only

READ-ONLY: find API addresses by plain words ('list datastores'). A verb picks the method. Returns access and blast-radius tier. 5 by default.

Name	Required	Description	Default
`limit`	No
`plane`	No
`query`	Yes

Output Schema

Name	Required	Description
No output parameters

TDQS

B3.2/5.0

Behavior3/5

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

Annotations already declare readOnlyHint=true, and the description restates READ-ONLY, so it adds little on safety. It does add useful behavior: it returns an 'access and blast-radius tier' and that the limit defaults to 5, which is context beyond the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Four short, front-loaded sentences with no filler and the READ-ONLY constraint placed first. Slightly telegraphic phrasing ('A verb picks the method') costs a little clarity but wastes no space.

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

Completeness3/5

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

An output schema exists, so return-value explanation is not required. Still, for a 3-param tool with 0% schema coverage, the undocumented 'plane' enum and vague dispatch phrasing leave an agent short of what it needs to call confidently.

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

Parameters2/5

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

With 0% schema coverage, the description must carry parameter meaning. It explains 'query' ('plain words', with an example) and the limit default ('5 by default'), but leaves the 'plane' enum (pve/pbs/pmg/pdm) entirely unexplained, which is a significant gap.

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 and resource ('find API addresses') and gives a concrete example ('list datastores'), so the discovery intent is clear. 'A verb picks the method' signals this is a dispatcher-style lookup distinct from execution siblings, though the framing is terse.

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?

'READ-ONLY' and 'A verb picks the method' imply this is the search/discovery entry point, hinting it precedes proximo_plan/proximo_call. However, no sibling is named and there is no explicit when-to-use/when-not guidance.

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

proximo_planA

Read-only

READ-ONLY, mutates nothing: the governed verdict (armed, tier, consent) for one address, with the parameters you gave and the required ones you lack; fields='name1,name2' or 'all' shows the vendor's full schema. A mutation's plan also reads the target: current, change, noop. Run before proximo_call. path may be words: one match is planned, several come back to pick from.

Name	Required	Description	Default
`args`	No
`path`	Yes
`plane`	Yes
`fields`	No
`method`	Yes

Output Schema

Name	Required	Description
No output parameters

TDQS

A4.1/5.0

Behavior5/5

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

Annotations only declare readOnlyHint=true; the description reinforces it ('READ-ONLY, mutates nothing') and then adds substantial behavior: the verdict carries armed/tier/consent, missing required parameters are surfaced, fields='all' reveals the vendor's full schema, and mutation plans read the target as current/change/noop. It also discloses the fuzzy-path behavior (single match planned, multiple returned as candidates), which is exactly the kind of trait annotations cannot convey.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the most important guarantee (READ-ONLY) and packed with load-bearing clauses; nearly every phrase carries information. It is semicolon-dense and slightly run-on, which costs some immediate parseability, but there is no filler.

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 an output schema exists, the description needn't enumerate return fields, yet it explains the key verdict concepts and sequencing. Remaining gaps are the semantics of plane/method and how the 'required ones you lack' list should be acted on, which matter for a five-parameter planning tool.

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 0% across five parameters, so the description must compensate. It does document fields (comma-separated names or 'all'), path (may be free words, with match/candidate semantics), and indirectly args ('the parameters you gave'), but plane (an enum) and method are never explained in the description or schema, leaving genuine gaps.

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 concrete job: return the governed verdict (armed, tier, consent) for one address, plus the parameters supplied and the required ones missing, plus optional schema expansion via fields. It also differentiates from proximo_call by naming it as the tool that must follow. It doesn't distinguish itself from proximo_find, whose name-resolution territory ('path may be words') it partially overlaps.

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?

"Run before proximo_call" gives an explicit sequencing rule, and 'several come back to pick from' explains what to do when a path is ambiguous. However, there is no when-not guidance (e.g., when to skip planning and call directly) and no routing versus proximo_find/proximo_read for resolution or inspection.

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

proximo_readA

Read-only

READ-ONLY: run a GET by path or words (no leading slash). args = query parameters (params: old name). Rows come lean with a total; fields='all' or 'name,status' for others; over the cap you get counts and a next line. since='24h': what changed, from the door's snapshots. wait=N on .../tasks/{upid}/status waits up to N s (max 600). diagnose=true on a node or guest path: health and advisory flags. Credentials come back withheld.

Name	Required	Description	Default
`args`	No
`path`	Yes
`wait`	No
`plane`	Yes
`since`	No
`fields`	No
`params`	No
`diagnose`	No

Output Schema

Name	Required	Description
No output parameters

TDQS

A4/5.0

Behavior5/5

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

Although annotations already declare readOnlyHint=true, the description adds substantial behavioral context: credentials are withheld, rows include a total, over-cap responses return counts and a next line, since uses snapshots, wait has a 600s maximum, and diagnose returns health/advisory flags. These details go well beyond the annotation and help an agent understand actual behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is compact and front-loads the critical read-only GET behavior. It is dense and somewhat cryptic in places ("from the door's snapshots", "next line"), but every clause carries parameter or behavioral information.

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 eight parameters, 0% schema coverage, and an existing output schema, the description covers most invocation-relevant behavior and response nuances. The main gap is that the required plane parameter is not explained beyond its enum, but overall an agent has enough context to call the tool 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?

Schema description coverage is 0%, so the description must compensate for eight parameters. It explains args as query parameters, params as an old-name alias, path format (no leading slash), fields syntax, since, wait with a maximum, and diagnose; only plane is left unexplained, so it is strong but not complete.

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 read operation: "READ-ONLY: run a GET by path or words", which clearly identifies the verb and resource type. It distinguishes itself as a read-only GET tool, but does not explicitly differentiate its purpose from siblings like proximo_find or proximo_call.

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 description gives conditional usage hints for specific parameters (fields, since, wait, diagnose), which implies when to use those options. However, it never states when to choose proximo_read over proximo_find or proximo_call, nor does it provide explicit exclusions or prerequisites.

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.

6 tool updatesv0.49.1Oct 27, 2026
- Changedaudit_entries11 fields changed
  - removedInput schema / properties / action / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / action / default
```
Removed value: -null
```
  - removedInput schema / properties / action / title
```
Removed value: -"Action"
```
  - addedInput schema / properties / action / type
```
Added value: +"string"
```
  - removedInput schema / properties / limit / title
```
Removed value: -"Limit"
```
  - removedInput schema / properties / mutations_only / title
```
Removed value: -"Mutations Only"
```
  - removedInput schema / properties / target / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / target / default
```
Removed value: -null
```
  - removedInput schema / properties / target / title
```
Removed value: -"Target"
```
  - addedInput schema / properties / target / type
```
Added value: +"string"
```
  - removedInput schema / title
```
Removed value: -"audit_entriesArguments"
```
- Changedaudit_verify9 fields changed
  - removedInput schema / properties / expected_head / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / expected_head / default
```
Removed value: -null
```
  - removedInput schema / properties / expected_head / title
```
Removed value: -"Expected Head"
```
  - addedInput schema / properties / expected_head / type
```
Added value: +"string"
```
  - removedInput schema / properties / path / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / path / default
```
Removed value: -null
```
  - removedInput schema / properties / path / title
```
Removed value: -"Path"
```
  - addedInput schema / properties / path / type
```
Added value: +"string"
```
  - removedInput schema / title
```
Removed value: -"audit_verifyArguments"
```
- Changedproximo_call13 fields changed
  - removedInput schema / properties / args / anyOf
```
Removed value: -[
-  {
-    "additionalProperties": true,
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / args / default
```
Removed value: -null
```
  - removedInput schema / properties / args / title
```
Removed value: -"Args"
```
  - addedInput schema / properties / args / type
```
Added value: +"object"
```
  - removedInput schema / properties / confirm / title
```
Removed value: -"Confirm"
```
  - removedInput schema / properties / method / title
```
Removed value: -"Method"
```
  - removedInput schema / properties / path / title
```
Removed value: -"Path"
```
  - removedInput schema / properties / plane / title
```
Removed value: -"Plane"
```
  - removedInput schema / properties / wait / anyOf
```
Removed value: -[
-  {
-    "type": "integer"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / wait / default
```
Removed value: -null
```
  - removedInput schema / properties / wait / title
```
Removed value: -"Wait"
```
  - addedInput schema / properties / wait / type
```
Added value: +"integer"
```
  - removedInput schema / title
```
Removed value: -"_callArguments"
```
- Changedproximo_find8 fields changed
  - removedInput schema / properties / limit / title
```
Removed value: -"Limit"
```
  - removedInput schema / properties / plane / anyOf
```
Removed value: -[
-  {
-    "enum": [
-      "pve",
-      "pbs",
-      "pmg",
-      "pdm"
-    ],
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / plane / default
```
Removed value: -null
```
  - addedInput schema / properties / plane / enum
```
Added value: +[
+  "pve",
+  "pbs",
+  "pmg",
+  "pdm"
+]
```
  - removedInput schema / properties / plane / title
```
Removed value: -"Plane"
```
  - addedInput schema / properties / plane / type
```
Added value: +"string"
```
  - removedInput schema / properties / query / title
```
Removed value: -"Query"
```
  - removedInput schema / title
```
Removed value: -"findArguments"
```
- Changedproximo_plan9 fields changed
  - removedInput schema / properties / args / anyOf
```
Removed value: -[
-  {
-    "additionalProperties": true,
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / args / default
```
Removed value: -null
```
  - removedInput schema / properties / args / title
```
Removed value: -"Args"
```
  - addedInput schema / properties / args / type
```
Added value: +"object"
```
  - addedInput schema / properties / fields
```
Added value: +{
+  "type": "string"
+}
```
  - removedInput schema / properties / method / title
```
Removed value: -"Method"
```
  - removedInput schema / properties / path / title
```
Removed value: -"Path"
```
  - removedInput schema / properties / plane / title
```
Removed value: -"Plane"
```
  - removedInput schema / title
```
Removed value: -"_planArguments"
```
- Changedproximo_read21 fields changed
  - addedInput schema / properties / args
```
Added value: +{
+  "type": "object"
+}
```
  - removedInput schema / properties / diagnose / title
```
Removed value: -"Diagnose"
```
  - removedInput schema / properties / fields / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / fields / default
```
Removed value: -null
```
  - removedInput schema / properties / fields / title
```
Removed value: -"Fields"
```
  - addedInput schema / properties / fields / type
```
Added value: +"string"
```
  - removedInput schema / properties / params / anyOf
```
Removed value: -[
-  {
-    "additionalProperties": true,
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / params / default
```
Removed value: -null
```
  - removedInput schema / properties / params / title
```
Removed value: -"Params"
```
  - addedInput schema / properties / params / type
```
Added value: +"object"
```
  - removedInput schema / properties / path / title
```
Removed value: -"Path"
```
  - removedInput schema / properties / plane / title
```
Removed value: -"Plane"
```
  - removedInput schema / properties / since / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / since / default
```
Removed value: -null
```
  - removedInput schema / properties / since / title
```
Removed value: -"Since"
```
  - addedInput schema / properties / since / type
```
Added value: +"string"
```
  - removedInput schema / properties / wait / anyOf
```
Removed value: -[
-  {
-    "type": "integer"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / wait / default
```
Removed value: -null
```
  - removedInput schema / properties / wait / title
```
Removed value: -"Wait"
```
  - addedInput schema / properties / wait / type
```
Added value: +"integer"
```
  - removedInput schema / title
```
Removed value: -"_readArguments"
```

9 tool updatesv0.46.2Oct 24, 2026

Changedaudit_entries15 fields changed

addedInput schema / properties / action / anyOf

Added value: +[
+  {
+    "type": "string"
+  },
+  {
+    "type": "null"
+  }
+]

removedInput schema / properties / action / description

Removed value: -"Only this exact tool name, e.g. 'pve_guest_config_set'."

addedInput schema / properties / action / title
```
Added value: +"Action"
```
removedInput schema / properties / action / type
```
Removed value: -[
-  "string",
-  "null"
-]
```

removedInput schema / properties / limit / description

Removed value: -"Newest N entries to return (default 20)."

addedInput schema / properties / limit / title
```
Added value: +"Limit"
```
removedInput schema / properties / mutations_only / description
```
Removed value: -"Only entries that changed state."
```
addedInput schema / properties / mutations_only / title
```
Added value: +"Mutations Only"
```

removedInput schema / properties / principal

Removed value: -{
-  "default": null,
-  "description": "Only entries attributed to this caller id.",
-  "type": [
-    "string",
-    "null"
-  ]
-}

addedInput schema / properties / target / anyOf

Added value: +[
+  {
+    "type": "string"
+  },
+  {
+    "type": "null"
+  }
+]

removedInput schema / properties / target / description

Removed value: -"Only entries against this exact target, e.g. 'vmid=100'."

addedInput schema / properties / target / title
```
Added value: +"Target"
```
removedInput schema / properties / target / type
```
Removed value: -[
-  "string",
-  "null"
-]
```
addedInput schema / title
```
Added value: +"audit_entriesArguments"
```

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "additionalProperties": true,
+  "title": "audit_entriesDictOutput",
+  "type": "object"
+}

Changedaudit_verify7 fields changed

addedInput schema / properties / expected_head / anyOf

Added value: +[
+  {
+    "type": "string"
+  },
+  {
+    "type": "null"
+  }
+]

removedInput schema / properties / expected_head / description

Removed value: -"64-char hex head() value pinned off-box; verifying against it also catches tail truncation, a forged tail-append, or a full ledger replacement. Omit to fall back to PROXIMO_AUDIT_EXPECTED_HEAD."

addedInput schema / properties / expected_head / title
```
Added value: +"Expected Head"
```
removedInput schema / properties / expected_head / type
```
Removed value: -[
-  "string",
-  "null"
-]
```

addedInput schema / properties / path

Added value: +{
+  "anyOf": [
+    {
+      "type": "string"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "title": "Path"
+}

addedInput schema / title
```
Added value: +"audit_verifyArguments"
```

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "additionalProperties": true,
+  "title": "audit_verifyDictOutput",
+  "type": "object"
+}

Changedproximo_call11 fields changed

addedInput schema / properties / args

Added value: +{
+  "anyOf": [
+    {
+      "additionalProperties": true,
+      "type": "object"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "title": "Args"
+}

removedInput schema / properties / arguments

Removed value: -{
-  "anyOf": [
-    {
-      "additionalProperties": true,
-      "type": "object"
-    },
-    {
-      "type": "null"
-    }
-  ],
-  "default": null,
-  "description": "The tool's arguments as an object, e.g. {'vmid': 100, 'action': 'reboot'}. Get the shape from proximo_tool_schema. Omit/null for a no-arg tool."
-}

addedInput schema / properties / confirm

Added value: +{
+  "default": false,
+  "title": "Confirm",
+  "type": "boolean"
+}

addedInput schema / properties / method

Added value: +{
+  "title": "Method",
+  "type": "string"
+}

addedInput schema / properties / path

Added value: +{
+  "title": "Path",
+  "type": "string"
+}

addedInput schema / properties / plane

Added value: +{
+  "enum": [
+    "pve",
+    "pbs",
+    "pmg",
+    "pdm"
+  ],
+  "title": "Plane",
+  "type": "string"
+}

removedInput schema / properties / tool

Removed value: -{
-  "description": "Exact tool name to run, e.g. 'pve_guest_power' (from proximo_find_tools). Non-resident names are fine.",
-  "type": "string"
-}

addedInput schema / properties / wait

Added value: +{
+  "anyOf": [
+    {
+      "type": "integer"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "title": "Wait"
+}

changedInput schema / required

Previous value: -[
-  "tool"
-]New value: +[
+  "plane",
+  "method",
+  "path"
+]

addedInput schema / title
```
Added value: +"_callArguments"
```

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "additionalProperties": true,
+  "title": "_callDictOutput",
+  "type": "object"
+}

Addedproximo_find
Removedproximo_find_tools
Addedproximo_plan

Changedproximo_read12 fields changed

removedInput schema / properties / arguments

Removed value: -{
-  "anyOf": [
-    {
-      "additionalProperties": true,
-      "type": "object"
-    },
-    {
-      "type": "null"
-    }
-  ],
-  "default": null,
-  "title": "Arguments"
-}

addedInput schema / properties / diagnose

Added value: +{
+  "default": false,
+  "title": "Diagnose",
+  "type": "boolean"
+}

addedInput schema / properties / fields

Added value: +{
+  "anyOf": [
+    {
+      "type": "string"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "title": "Fields"
+}

addedInput schema / properties / params

Added value: +{
+  "anyOf": [
+    {
+      "additionalProperties": true,
+      "type": "object"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "title": "Params"
+}

addedInput schema / properties / path

Added value: +{
+  "title": "Path",
+  "type": "string"
+}

addedInput schema / properties / plane

Added value: +{
+  "enum": [
+    "pve",
+    "pbs",
+    "pmg",
+    "pdm"
+  ],
+  "title": "Plane",
+  "type": "string"
+}

addedInput schema / properties / since

Added value: +{
+  "anyOf": [
+    {
+      "type": "string"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "title": "Since"
+}

removedInput schema / properties / tool

Removed value: -{
-  "title": "Tool",
-  "type": "string"
-}

addedInput schema / properties / wait

Added value: +{
+  "anyOf": [
+    {
+      "type": "integer"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "title": "Wait"
+}

changedInput schema / required

Previous value: -[
-  "tool"
-]New value: +[
+  "plane",
+  "path"
+]

changedInput schema / title

Previous value: -"proximo_readArguments"New value: +"_readArguments"

changedOutput schema / (root)

Previous value: -nullNew value: +{
+  "additionalProperties": true,
+  "title": "_readDictOutput",
+  "type": "object"
+}

Removedproximo_recall
Removedproximo_tool_schema

1 tool updatev0.36.0Aug 23, 2026
- Addedproximo_read

2 tool updatesv0.32.0Aug 11, 2026

Changedproximo_call2 fields changed

addedInput schema / properties / arguments / description

Added value: +"The tool's arguments as an object, e.g. {'vmid': 100, 'action': 'reboot'}. Get the shape from proximo_tool_schema. Omit/null for a no-arg tool."

addedInput schema / properties / tool / description

Added value: +"Exact tool name to run, e.g. 'pve_guest_power' (from proximo_find_tools). Non-resident names are fine."

Changedproximo_find_tools3 fields changed

addedOutput schema / properties / result / anyOf

Added value: +[
+  {
+    "items": {
+      "additionalProperties": true,
+      "type": "object"
+    },
+    "type": "array"
+  },
+  {
+    "additionalProperties": true,
+    "type": "object"
+  }
+]

removedOutput schema / properties / result / items

Removed value: -{
-  "additionalProperties": true,
-  "type": "object"
-}

removedOutput schema / properties / result / type
```
Removed value: -"array"
```

720 tool updatesv0.31.1Aug 7, 2026
- Addedaudit_entries
- Changedaudit_verify4 fields changed
  - removedInput schema / properties / expected_head / anyOf
```
Removed value: -[
-  {
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]
```
  - removedInput schema / properties / expected_head / title
```
Removed value: -"Expected Head"
```
  - addedInput schema / properties / expected_head / type
```
Added value: +[
+  "string",
+  "null"
+]
```
  - removedInput schema / title
```
Removed value: -"audit_verifyArguments"
```
- Removedct_diagnose
- Removedct_exec
- Removedct_logs
- Removedct_psql
- Removedpbs_acl_get
- Removedpbs_acl_update
- Removedpbs_acme_account_create
- Removedpbs_acme_account_delete
- Removedpbs_acme_account_get
- Removedpbs_acme_account_list
- Removedpbs_acme_account_update
- Removedpbs_acme_cert_order
- Removedpbs_acme_cert_renew
- Removedpbs_acme_challenge_schema
- Removedpbs_acme_directories
- Removedpbs_acme_plugin_create
- Removedpbs_acme_plugin_delete
- Removedpbs_acme_plugin_get
- Removedpbs_acme_plugin_update
- Removedpbs_acme_plugins_list
- Removedpbs_acme_tos
- Removedpbs_admin_gc_jobs_list
- Removedpbs_admin_prune_jobs_list
- Removedpbs_admin_sync_jobs_list
- Removedpbs_admin_traffic_control_status
- Removedpbs_admin_verify_jobs_list
- Removedpbs_apt_changelog
- Removedpbs_apt_repositories_get
- Removedpbs_apt_repository_add
- Removedpbs_apt_repository_set
- Removedpbs_apt_update_refresh
- Removedpbs_apt_updates_list
- Removedpbs_apt_versions
- Removedpbs_datastore_active_operations
- Removedpbs_datastore_create
- Removedpbs_datastore_delete
- Removedpbs_datastore_get
- Removedpbs_datastore_mount
- Removedpbs_datastore_prune
- Removedpbs_datastore_rrd
- Removedpbs_datastore_s3_refresh
- Removedpbs_datastore_status
- Removedpbs_datastore_unmount
- Removedpbs_datastore_update
- Removedpbs_datastores_list
- Removedpbs_datastores_usage
- Removedpbs_encryption_key_create
- Removedpbs_encryption_key_delete
- Removedpbs_encryption_key_list
- Removedpbs_encryption_key_toggle_archive
- Removedpbs_gc_start
- Removedpbs_gc_status
- Removedpbs_group_change_owner
- Removedpbs_group_delete
- Removedpbs_group_move
- Removedpbs_group_notes_get
- Removedpbs_group_notes_set
- Removedpbs_groups_list
- Removedpbs_job_create
- Removedpbs_job_delete
- Removedpbs_job_run
- Removedpbs_job_update
- Removedpbs_jobs_list
- Removedpbs_metrics_influxdb_http_create
- Removedpbs_metrics_influxdb_http_delete
- Removedpbs_metrics_influxdb_http_get
- Removedpbs_metrics_influxdb_http_list
- Removedpbs_metrics_influxdb_http_update
- Removedpbs_metrics_influxdb_udp_create
- Removedpbs_metrics_influxdb_udp_delete
- Removedpbs_metrics_influxdb_udp_get
- Removedpbs_metrics_influxdb_udp_list
- Removedpbs_metrics_influxdb_udp_update
- Removedpbs_metrics_servers_list
- Removedpbs_metrics_status
- Removedpbs_namespace_create
- Removedpbs_namespace_delete
- Removedpbs_namespace_move
- Removedpbs_namespaces_list
- Removedpbs_node_cert_delete
- Removedpbs_node_cert_upload
- Removedpbs_node_certificates_list
- Removedpbs_node_config_get
- Removedpbs_node_config_set
- Removedpbs_node_disk_directory_create
- Removedpbs_node_disk_directory_delete
- Removedpbs_node_disk_directory_list
- Removedpbs_node_disk_initgpt
- Removedpbs_node_disk_smart
- Removedpbs_node_disk_wipe
- Removedpbs_node_disk_zfs_create
- Removedpbs_node_disk_zfs_get
- Removedpbs_node_disk_zfs_list
- Removedpbs_node_disks_list
- Removedpbs_node_dns_get
- Removedpbs_node_dns_set
- Removedpbs_node_identity
- Removedpbs_node_journal
- Removedpbs_node_network_iface_create
- Removedpbs_node_network_iface_delete
- Removedpbs_node_network_iface_get
- Removedpbs_node_network_iface_update
- Removedpbs_node_network_list
- Removedpbs_node_network_reload
- Removedpbs_node_network_revert
- Removedpbs_node_report
- Removedpbs_node_rrd
- Removedpbs_node_service_control
- Removedpbs_node_service_status
- Removedpbs_node_services_list
- Removedpbs_node_status
- Removedpbs_node_subscription_check
- Removedpbs_node_subscription_delete
- Removedpbs_node_subscription_get
- Removedpbs_node_subscription_set
- Removedpbs_node_syslog
- Removedpbs_node_task_log
- Removedpbs_node_task_status
- Removedpbs_node_task_stop
- Removedpbs_node_time_get
- Removedpbs_node_time_set
- Removedpbs_notification_endpoint_create
- Removedpbs_notification_endpoint_delete
- Removedpbs_notification_endpoint_get
- Removedpbs_notification_endpoint_list
- Removedpbs_notification_endpoint_update
- Removedpbs_notification_matcher_delete
- Removedpbs_notification_matcher_field_values
- Removedpbs_notification_matcher_fields
- Removedpbs_notification_matcher_get
- Removedpbs_notification_matcher_set
- Removedpbs_notification_matchers_list
- Removedpbs_notification_target_test
- Removedpbs_notification_targets_list
- Removedpbs_permissions_get
- Removedpbs_prune
- Removedpbs_pull
- Removedpbs_push
- Removedpbs_realm_ad_create
- Removedpbs_realm_ad_delete
- Removedpbs_realm_ad_get
- Removedpbs_realm_ad_list
- Removedpbs_realm_ad_update
- Removedpbs_realm_ldap_create
- Removedpbs_realm_ldap_delete
- Removedpbs_realm_ldap_get
- Removedpbs_realm_ldap_list
- Removedpbs_realm_ldap_update
- Removedpbs_realm_openid_create
- Removedpbs_realm_openid_delete
- Removedpbs_realm_openid_get
- Removedpbs_realm_openid_list
- Removedpbs_realm_openid_update
- Removedpbs_realm_pam_get
- Removedpbs_realm_pam_set
- Removedpbs_realm_pbs_get
- Removedpbs_realm_pbs_set
- Removedpbs_realm_sync
- Removedpbs_remote_create
- Removedpbs_remote_delete
- Removedpbs_remote_get
- Removedpbs_remote_scan
- Removedpbs_remote_scan_groups
- Removedpbs_remote_scan_namespaces
- Removedpbs_remote_update
- Removedpbs_remotes_list
- Removedpbs_roles_list
- Removedpbs_s3_check
- Removedpbs_s3_client_create
- Removedpbs_s3_client_delete
- Removedpbs_s3_client_get
- Removedpbs_s3_client_list
- Removedpbs_s3_client_update
- Removedpbs_s3_list_buckets
- Removedpbs_s3_reset_counters
- Removedpbs_snapshot_delete
- Removedpbs_snapshot_notes_set
- Removedpbs_snapshot_protected_get
- Removedpbs_snapshot_protected_set
- Removedpbs_snapshots_list
- Removedpbs_tape_backup
- Removedpbs_tape_backup_job_create
- Removedpbs_tape_backup_job_delete
- Removedpbs_tape_backup_job_get
- Removedpbs_tape_backup_job_list
- Removedpbs_tape_backup_job_run
- Removedpbs_tape_backup_job_update
- Removedpbs_tape_changer_create
- Removedpbs_tape_changer_delete
- Removedpbs_tape_changer_get
- Removedpbs_tape_changer_list
- Removedpbs_tape_changer_status
- Removedpbs_tape_changer_transfer
- Removedpbs_tape_changer_update
- Removedpbs_tape_drive_barcode_label_media
- Removedpbs_tape_drive_cartridge_memory
- Removedpbs_tape_drive_catalog
- Removedpbs_tape_drive_clean
- Removedpbs_tape_drive_create
- Removedpbs_tape_drive_delete
- Removedpbs_tape_drive_eject
- Removedpbs_tape_drive_format
- Removedpbs_tape_drive_get
- Removedpbs_tape_drive_inventory
- Removedpbs_tape_drive_inventory_update
- Removedpbs_tape_drive_label_media
- Removedpbs_tape_drive_list
- Removedpbs_tape_drive_load_media
- Removedpbs_tape_drive_load_slot
- Removedpbs_tape_drive_read_label
- Removedpbs_tape_drive_restore_key
- Removedpbs_tape_drive_rewind
- Removedpbs_tape_drive_status
- Removedpbs_tape_drive_unload
- Removedpbs_tape_drive_update
- Removedpbs_tape_drive_volume_statistics
- Removedpbs_tape_key_create
- Removedpbs_tape_key_delete
- Removedpbs_tape_key_get
- Removedpbs_tape_key_list
- Removedpbs_tape_key_update_password
- Removedpbs_tape_media_content
- Removedpbs_tape_media_destroy
- Removedpbs_tape_media_list
- Removedpbs_tape_media_move
- Removedpbs_tape_media_sets
- Removedpbs_tape_media_status_get
- Removedpbs_tape_media_status_set
- Removedpbs_tape_pool_create
- Removedpbs_tape_pool_delete
- Removedpbs_tape_pool_get
- Removedpbs_tape_pool_list
- Removedpbs_tape_pool_update
- Removedpbs_tape_restore
- Removedpbs_tape_scan_changers
- Removedpbs_tape_scan_drives
- Removedpbs_tasks_list
- Removedpbs_tfa_add
- Removedpbs_tfa_delete
- Removedpbs_tfa_entry_get
- Removedpbs_tfa_list
- Removedpbs_tfa_unlock
- Removedpbs_tfa_update
- Removedpbs_tfa_user_get
- Removedpbs_tfa_webauthn_get
- Removedpbs_tfa_webauthn_set
- Removedpbs_token_create
- Removedpbs_token_delete
- Removedpbs_token_update
- Removedpbs_traffic_control_delete
- Removedpbs_traffic_control_upsert
- Removedpbs_traffic_controls_list
- Removedpbs_user_create
- Removedpbs_user_delete
- Removedpbs_user_get
- Removedpbs_user_token_get
- Removedpbs_user_tokens_list
- Removedpbs_user_update
- Removedpbs_users_list
- Removedpbs_verify_start
- Removedpbs_version
- Removedpdm_acl_list
- Removedpdm_node_status
- Removedpdm_pbs_datastores_list
- Removedpdm_pbs_remote_status
- Removedpdm_pbs_snapshots_list
- Removedpdm_ping
- Removedpdm_pve_cluster_status
- Removedpdm_pve_lxc_config
- Removedpdm_pve_lxc_list
- Removedpdm_pve_lxc_migrate
- Removedpdm_pve_lxc_power
- Removedpdm_pve_lxc_remote_migrate
- Removedpdm_pve_lxc_snapshot_create
- Removedpdm_pve_lxc_snapshot_delete
- Removedpdm_pve_lxc_snapshot_rollback
- Removedpdm_pve_node_list
- Removedpdm_pve_qemu_config
- Removedpdm_pve_qemu_list
- Removedpdm_pve_qemu_migrate
- Removedpdm_pve_qemu_power
- Removedpdm_pve_qemu_remote_migrate
- Removedpdm_pve_qemu_snapshot_create
- Removedpdm_pve_qemu_snapshot_delete
- Removedpdm_pve_qemu_snapshot_rollback
- Removedpdm_pve_resources
- Removedpdm_remote_config_get
- Removedpdm_remote_version
- Removedpdm_remotes_list
- Removedpdm_resources_list
- Removedpdm_resources_status
- Removedpdm_roles_list
- Removedpdm_tasks_list
- Removedpdm_users_list
- Removedpdm_version
- Removedpmg_action_bcc_create
- Removedpmg_action_bcc_update
- Removedpmg_action_delete
- Removedpmg_action_disclaimer_create
- Removedpmg_action_disclaimer_update
- Removedpmg_action_field_create
- Removedpmg_action_field_update
- Removedpmg_action_notification_create
- Removedpmg_action_notification_update
- Removedpmg_action_objects_list
- Removedpmg_action_removeattachments_create
- Removedpmg_action_removeattachments_update
- Removedpmg_apt_changelog
- Removedpmg_apt_repositories_get
- Removedpmg_apt_repository_add
- Removedpmg_apt_repository_set
- Removedpmg_apt_update_refresh
- Removedpmg_apt_updates_list
- Removedpmg_apt_versions
- Removedpmg_backup_create
- Removedpmg_doctor
- Removedpmg_domain_create
- Removedpmg_domain_delete
- Removedpmg_domains_list
- Removedpmg_mynetworks_add
- Removedpmg_mynetworks_remove
- Removedpmg_node_rrddata
- Removedpmg_node_status
- Removedpmg_node_syslog
- Removedpmg_postfix_flush
- Removedpmg_postfix_qshape
- Removedpmg_quarantine_action
- Removedpmg_quarantine_attachment
- Removedpmg_quarantine_blocklist_add
- Removedpmg_quarantine_blocklist_list
- Removedpmg_quarantine_blocklist_remove
- Removedpmg_quarantine_spam
- Removedpmg_quarantine_spamstatus
- Removedpmg_quarantine_spamusers
- Removedpmg_quarantine_virus
- Removedpmg_quarantine_virusstatus
- Removedpmg_quarantine_welcomelist_add
- Removedpmg_quarantine_welcomelist_list
- Removedpmg_quarantine_welcomelist_remove
- Removedpmg_relay_config
- Removedpmg_ruledb_digest
- Removedpmg_ruledb_rule_action_attach
- Removedpmg_ruledb_rule_action_detach
- Removedpmg_ruledb_rule_actions_list
- Removedpmg_ruledb_rule_create
- Removedpmg_ruledb_rule_delete
- Removedpmg_ruledb_rule_from_attach
- Removedpmg_ruledb_rule_from_detach
- Removedpmg_ruledb_rule_from_list
- Removedpmg_ruledb_rule_get
- Removedpmg_ruledb_rule_to_attach
- Removedpmg_ruledb_rule_to_detach
- Removedpmg_ruledb_rule_to_list
- Removedpmg_ruledb_rule_update
- Removedpmg_ruledb_rule_what_attach
- Removedpmg_ruledb_rule_what_detach
- Removedpmg_ruledb_rule_what_list
- Removedpmg_ruledb_rule_when_attach
- Removedpmg_ruledb_rule_when_detach
- Removedpmg_ruledb_rule_when_list
- Removedpmg_ruledb_rules_list
- Removedpmg_service_control
- Removedpmg_service_status
- Removedpmg_spam_config
- Removedpmg_spam_config_update
- Removedpmg_statistics_domains
- Removedpmg_statistics_mail
- Removedpmg_statistics_mailcount
- Removedpmg_statistics_receiver
- Removedpmg_statistics_recent
- Removedpmg_statistics_sender
- Removedpmg_statistics_spamscores
- Removedpmg_statistics_virus
- Removedpmg_tasks_list
- Removedpmg_tracker_detail
- Removedpmg_tracker_list
- Removedpmg_transport_create
- Removedpmg_transport_delete
- Removedpmg_what_group_create
- Removedpmg_what_group_delete
- Removedpmg_what_group_get
- Removedpmg_what_group_objects
- Removedpmg_what_group_update
- Removedpmg_what_groups_list
- Removedpmg_what_object_add
- Removedpmg_what_object_delete
- Removedpmg_what_object_update
- Removedpmg_when_group_create
- Removedpmg_when_group_delete
- Removedpmg_when_group_get
- Removedpmg_when_group_objects
- Removedpmg_when_group_update
- Removedpmg_when_groups_list
- Removedpmg_when_object_add
- Removedpmg_when_object_delete
- Removedpmg_when_object_update
- Removedpmg_who_group_create
- Removedpmg_who_group_delete
- Removedpmg_who_group_get
- Removedpmg_who_group_objects
- Removedpmg_who_group_update
- Removedpmg_who_groups_list
- Removedpmg_who_object_add
- Removedpmg_who_object_delete
- Removedpmg_who_object_update
- Addedproximo_call
- Addedproximo_find_tools
- Addedproximo_recall
- Addedproximo_tool_schema
- Removedpve_acl_list
- Removedpve_acl_modify
- Removedpve_acl_prune
- Removedpve_acme_account_create
- Removedpve_acme_account_delete
- Removedpve_acme_account_update
- Removedpve_acme_cert_order
- Removedpve_acme_cert_renew
- Removedpve_acme_cert_revoke
- Removedpve_acme_plugin_create
- Removedpve_acme_plugin_delete
- Removedpve_acme_plugin_update
- Removedpve_agent_exec
- Removedpve_agent_file_read
- Removedpve_agent_file_write
- Removedpve_agent_fs
- Removedpve_agent_info
- Removedpve_agent_set_password
- Removedpve_apt_changelog
- Removedpve_apt_repositories_get
- Removedpve_apt_repository_add
- Removedpve_apt_repository_set
- Removedpve_apt_update_refresh
- Removedpve_apt_updates_list
- Removedpve_apt_versions
- Removedpve_backup
- Removedpve_backup_delete
- Removedpve_backup_freshness
- Removedpve_backup_job_create
- Removedpve_backup_job_delete
- Removedpve_backup_job_list
- Removedpve_backup_job_update
- Removedpve_backup_list
- Removedpve_ceph_cfg_db
- Removedpve_ceph_cfg_raw
- Removedpve_ceph_cfg_value
- Removedpve_ceph_cmd_safety
- Removedpve_ceph_crush
- Removedpve_ceph_flag_get
- Removedpve_ceph_flag_set
- Removedpve_ceph_flags_list
- Removedpve_ceph_flags_set
- Removedpve_ceph_fs_create
- Removedpve_ceph_fs_destroy
- Removedpve_ceph_fs_list
- Removedpve_ceph_init
- Removedpve_ceph_log
- Removedpve_ceph_mds_create
- Removedpve_ceph_mds_destroy
- Removedpve_ceph_mds_list
- Removedpve_ceph_metadata
- Removedpve_ceph_mgr_create
- Removedpve_ceph_mgr_destroy
- Removedpve_ceph_mgr_list
- Removedpve_ceph_mon_create
- Removedpve_ceph_mon_destroy
- Removedpve_ceph_mon_list
- Removedpve_ceph_osd_create
- Removedpve_ceph_osd_destroy
- Removedpve_ceph_osd_in
- Removedpve_ceph_osd_lv_info
- Removedpve_ceph_osd_metadata
- Removedpve_ceph_osd_out
- Removedpve_ceph_osd_scrub
- Removedpve_ceph_osd_tree
- Removedpve_ceph_pool_create
- Removedpve_ceph_pool_destroy
- Removedpve_ceph_pool_list
- Removedpve_ceph_pool_set
- Removedpve_ceph_pool_status
- Removedpve_ceph_rules
- Removedpve_ceph_service_restart
- Removedpve_ceph_service_start
- Removedpve_ceph_service_stop
- Removedpve_ceph_status
- Removedpve_clone
- Removedpve_cloudinit_get
- Removedpve_cloudinit_set
- Removedpve_cluster_resources
- Removedpve_cluster_status
- Removedpve_create_container
- Removedpve_create_vm
- Removedpve_delete_guest
- Removedpve_diagnose
- Removedpve_disk_move
- Removedpve_disk_resize
- Removedpve_doctor
- Removedpve_firewall_alias_create
- Removedpve_firewall_alias_delete
- Removedpve_firewall_alias_list
- Removedpve_firewall_alias_update
- Removedpve_firewall_ipset_create
- Removedpve_firewall_ipset_delete
- Removedpve_firewall_ipset_entry_add
- Removedpve_firewall_ipset_entry_remove
- Removedpve_firewall_options_get
- Removedpve_firewall_options_set
- Removedpve_firewall_rule_add
- Removedpve_firewall_rule_remove
- Removedpve_firewall_rule_update
- Removedpve_firewall_rules_list
- Removedpve_firewall_security_group_create
- Removedpve_firewall_security_group_delete
- Removedpve_firewall_set_enabled
- Removedpve_group_create
- Removedpve_group_delete
- Removedpve_group_get
- Removedpve_group_update
- Removedpve_groups_list
- Removedpve_guest_config_get
- Removedpve_guest_config_revert
- Removedpve_guest_config_set
- Removedpve_guest_migrate
- Removedpve_guest_power
- Removedpve_guest_status
- Removedpve_ha_groups_list
- Removedpve_ha_resource_add
- Removedpve_ha_resource_remove
- Removedpve_ha_resources_list
- Removedpve_ha_rule_create
- Removedpve_ha_rule_delete
- Removedpve_ha_rule_update
- Removedpve_ha_rules_list
- Removedpve_hardware_list
- Removedpve_ipset_list
- Removedpve_list_guests
- Removedpve_mapping_pci_create
- Removedpve_mapping_pci_delete
- Removedpve_mapping_pci_list
- Removedpve_mapping_pci_update
- Removedpve_mapping_usb_create
- Removedpve_mapping_usb_delete
- Removedpve_mapping_usb_list
- Removedpve_mapping_usb_update
- Removedpve_metrics_server_delete
- Removedpve_metrics_server_list
- Removedpve_metrics_server_set
- Removedpve_network_apply
- Removedpve_network_iface_create
- Removedpve_network_iface_update
- Removedpve_network_list
- Removedpve_node_acme_domains_set
- Removedpve_node_cert_delete
- Removedpve_node_cert_upload
- Removedpve_node_certificates
- Removedpve_node_disk_initgpt
- Removedpve_node_disk_smart
- Removedpve_node_disk_wipe
- Removedpve_node_disks_list
- Removedpve_node_dns
- Removedpve_node_dns_set
- Removedpve_node_hosts_get
- Removedpve_node_hosts_set
- Removedpve_node_journal
- Removedpve_node_migrateall
- Removedpve_node_rrddata
- Removedpve_node_service_control
- Removedpve_node_service_status
- Removedpve_node_services_list
- Removedpve_node_startall
- Removedpve_node_status
- Removedpve_node_stopall
- Removedpve_node_storage_backend_create
- Removedpve_node_storage_backend_delete
- Removedpve_node_storage_backend_list
- Removedpve_node_subscription
- Removedpve_node_syslog
- Removedpve_node_time_get
- Removedpve_node_time_set
- Removedpve_notification_endpoint_create
- Removedpve_notification_endpoint_delete
- Removedpve_notification_endpoint_list
- Removedpve_notification_endpoint_update
- Removedpve_notification_matcher_delete
- Removedpve_notification_matcher_set
- Removedpve_notification_test
- Removedpve_overbroad_grants
- Removedpve_pool_create
- Removedpve_pool_delete
- Removedpve_pool_get
- Removedpve_pool_update
- Removedpve_pools_list
- Removedpve_realm_create
- Removedpve_realm_delete
- Removedpve_realm_get
- Removedpve_realm_update
- Removedpve_realms_list
- Removedpve_replication_create
- Removedpve_replication_delete
- Removedpve_replication_update
- Removedpve_restore
- Removedpve_role_create
- Removedpve_role_delete
- Removedpve_role_update
- Removedpve_roles_list
- Removedpve_rollback
- Removedpve_sdn_apply
- Removedpve_sdn_controller_create
- Removedpve_sdn_controller_delete
- Removedpve_sdn_controller_get
- Removedpve_sdn_controller_update
- Removedpve_sdn_controllers_list
- Removedpve_sdn_dns_create
- Removedpve_sdn_dns_delete
- Removedpve_sdn_dns_get
- Removedpve_sdn_dns_list
- Removedpve_sdn_dns_update
- Removedpve_sdn_dry_run
- Removedpve_sdn_fabric_create
- Removedpve_sdn_fabric_delete
- Removedpve_sdn_fabric_get
- Removedpve_sdn_fabric_node_create
- Removedpve_sdn_fabric_node_delete
- Removedpve_sdn_fabric_node_get
- Removedpve_sdn_fabric_node_update
- Removedpve_sdn_fabric_nodes_list
- Removedpve_sdn_fabric_nodes_list_all
- Removedpve_sdn_fabric_status_interfaces
- Removedpve_sdn_fabric_status_neighbors
- Removedpve_sdn_fabric_status_routes
- Removedpve_sdn_fabric_update
- Removedpve_sdn_fabrics_all
- Removedpve_sdn_fabrics_list
- Removedpve_sdn_ipam_create
- Removedpve_sdn_ipam_delete
- Removedpve_sdn_ipam_get
- Removedpve_sdn_ipam_status
- Removedpve_sdn_ipam_update
- Removedpve_sdn_ipams_list
- Removedpve_sdn_lock_acquire
- Removedpve_sdn_lock_release
- Removedpve_sdn_prefix_list_create
- Removedpve_sdn_prefix_list_delete
- Removedpve_sdn_prefix_list_entries_list
- Removedpve_sdn_prefix_list_entry_create
- Removedpve_sdn_prefix_list_entry_delete
- Removedpve_sdn_prefix_list_entry_get
- Removedpve_sdn_prefix_list_entry_update
- Removedpve_sdn_prefix_list_get
- Removedpve_sdn_prefix_list_update
- Removedpve_sdn_prefix_lists_list
- Removedpve_sdn_rollback
- Removedpve_sdn_route_map_entries_list
- Removedpve_sdn_route_map_entries_list_all
- Removedpve_sdn_route_map_entry_create
- Removedpve_sdn_route_map_entry_delete
- Removedpve_sdn_route_map_entry_get
- Removedpve_sdn_route_map_entry_update
- Removedpve_sdn_route_maps_list
- Removedpve_sdn_subnet_create
- Removedpve_sdn_subnet_delete
- Removedpve_sdn_subnet_get
- Removedpve_sdn_subnet_list
- Removedpve_sdn_subnet_update
- Removedpve_sdn_vnet_create
- Removedpve_sdn_vnet_delete
- Removedpve_sdn_vnet_firewall_options_get
- Removedpve_sdn_vnet_firewall_options_set
- Removedpve_sdn_vnet_firewall_rule_add
- Removedpve_sdn_vnet_firewall_rule_get
- Removedpve_sdn_vnet_firewall_rule_remove
- Removedpve_sdn_vnet_firewall_rule_update
- Removedpve_sdn_vnet_firewall_rules_list
- Removedpve_sdn_vnet_get
- Removedpve_sdn_vnet_ip_create
- Removedpve_sdn_vnet_ip_delete
- Removedpve_sdn_vnet_ip_update
- Removedpve_sdn_vnet_mac_vrf
- Removedpve_sdn_vnet_update
- Removedpve_sdn_vnets_list
- Removedpve_sdn_zone_bridges
- Removedpve_sdn_zone_content
- Removedpve_sdn_zone_create
- Removedpve_sdn_zone_delete
- Removedpve_sdn_zone_get
- Removedpve_sdn_zone_ip_vrf
- Removedpve_sdn_zone_status_list
- Removedpve_sdn_zone_update
- Removedpve_sdn_zones_list
- Removedpve_security_groups_list
- Removedpve_snapshot_create
- Removedpve_snapshot_delete
- Removedpve_snapshot_list
- Removedpve_storage_config_get
- Removedpve_storage_config_list
- Removedpve_storage_content
- Removedpve_storage_content_delete
- Removedpve_storage_create
- Removedpve_storage_delete
- Removedpve_storage_download
- Removedpve_storage_status
- Removedpve_storage_update
- Removedpve_task_log
- Removedpve_task_status
- Removedpve_task_stop
- Removedpve_task_wait
- Removedpve_tasks_list
- Removedpve_template_convert
- Removedpve_tfa_delete
- Removedpve_tfa_get
- Removedpve_tfa_list
- Removedpve_token_create
- Removedpve_token_revoke
- Removedpve_tokens_list
- Removedpve_user_create
- Removedpve_user_delete
- Removedpve_user_get
- Removedpve_user_update
- Removedpve_users_list
113 tool updatesv0.24.0Jul 17, 2026
- Addedpve_ceph_cfg_db
- Addedpve_ceph_cfg_raw
- Addedpve_ceph_cfg_value
- Addedpve_ceph_cmd_safety
- Addedpve_ceph_crush
- Addedpve_ceph_flag_get
- Addedpve_ceph_flag_set
- Addedpve_ceph_flags_list
- Addedpve_ceph_flags_set
- Addedpve_ceph_fs_create
- Addedpve_ceph_fs_destroy
- Addedpve_ceph_fs_list
- Addedpve_ceph_init
- Addedpve_ceph_log
- Addedpve_ceph_mds_create
- Addedpve_ceph_mds_destroy
- Addedpve_ceph_mds_list
- Addedpve_ceph_metadata
- Addedpve_ceph_mgr_create
- Addedpve_ceph_mgr_destroy
- Addedpve_ceph_mgr_list
- Addedpve_ceph_mon_create
- Addedpve_ceph_mon_destroy
- Addedpve_ceph_mon_list
- Addedpve_ceph_osd_create
- Addedpve_ceph_osd_destroy
- Addedpve_ceph_osd_in
- Addedpve_ceph_osd_lv_info
- Addedpve_ceph_osd_metadata
- Addedpve_ceph_osd_out
- Addedpve_ceph_osd_scrub
- Addedpve_ceph_osd_tree
- Addedpve_ceph_pool_create
- Addedpve_ceph_pool_destroy
- Addedpve_ceph_pool_list
- Addedpve_ceph_pool_set
- Addedpve_ceph_pool_status
- Addedpve_ceph_rules
- Addedpve_ceph_service_restart
- Addedpve_ceph_service_start
- Addedpve_ceph_service_stop
- Addedpve_ceph_status
- Changedpve_sdn_apply2 fields changed
  - addedInput schema / properties / lock_token
```
Added value: +{
+  "anyOf": [
+    {
+      "type": "string"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "description": "SDN cluster lock token to use for this write, if one is held (from pve_sdn_lock_acquire).",
+  "title": "Lock Token"
+}
```
  - addedInput schema / properties / release_lock
```
Added value: +{
+  "anyOf": [
+    {
+      "type": "boolean"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "description": "Whether PVE releases the lock automatically after a successful commit (only relevant when lock_token is given; PVE's own default is True — omit to use it).",
+  "title": "Release Lock"
+}
```
- Addedpve_sdn_controller_create
- Addedpve_sdn_controller_delete
- Addedpve_sdn_controller_get
- Addedpve_sdn_controller_update
- Addedpve_sdn_controllers_list
- Addedpve_sdn_dns_create
- Addedpve_sdn_dns_delete
- Addedpve_sdn_dns_get
- Addedpve_sdn_dns_list
- Addedpve_sdn_dns_update
- Addedpve_sdn_dry_run
- Addedpve_sdn_fabric_create
- Addedpve_sdn_fabric_delete
- Addedpve_sdn_fabric_get
- Addedpve_sdn_fabric_node_create
- Addedpve_sdn_fabric_node_delete
- Addedpve_sdn_fabric_node_get
- Addedpve_sdn_fabric_node_update
- Addedpve_sdn_fabric_nodes_list
- Addedpve_sdn_fabric_nodes_list_all
- Addedpve_sdn_fabric_status_interfaces
- Addedpve_sdn_fabric_status_neighbors
- Addedpve_sdn_fabric_status_routes
- Addedpve_sdn_fabric_update
- Addedpve_sdn_fabrics_all
- Addedpve_sdn_fabrics_list
- Addedpve_sdn_ipam_create
- Addedpve_sdn_ipam_delete
- Addedpve_sdn_ipam_get
- Addedpve_sdn_ipam_status
- Addedpve_sdn_ipam_update
- Addedpve_sdn_ipams_list
- Addedpve_sdn_lock_acquire
- Addedpve_sdn_lock_release
- Addedpve_sdn_prefix_list_create
- Addedpve_sdn_prefix_list_delete
- Addedpve_sdn_prefix_list_entries_list
- Addedpve_sdn_prefix_list_entry_create
- Addedpve_sdn_prefix_list_entry_delete
- Addedpve_sdn_prefix_list_entry_get
- Addedpve_sdn_prefix_list_entry_update
- Addedpve_sdn_prefix_list_get
- Addedpve_sdn_prefix_list_update
- Addedpve_sdn_prefix_lists_list
- Addedpve_sdn_rollback
- Addedpve_sdn_route_map_entries_list
- Addedpve_sdn_route_map_entries_list_all
- Addedpve_sdn_route_map_entry_create
- Addedpve_sdn_route_map_entry_delete
- Addedpve_sdn_route_map_entry_get
- Addedpve_sdn_route_map_entry_update
- Addedpve_sdn_route_maps_list
- Addedpve_sdn_subnet_get
- Addedpve_sdn_vnet_firewall_options_get
- Addedpve_sdn_vnet_firewall_options_set
- Addedpve_sdn_vnet_firewall_rule_add
- Addedpve_sdn_vnet_firewall_rule_get
- Addedpve_sdn_vnet_firewall_rule_remove
- Addedpve_sdn_vnet_firewall_rule_update
- Addedpve_sdn_vnet_firewall_rules_list
- Addedpve_sdn_vnet_get
- Addedpve_sdn_vnet_ip_create
- Addedpve_sdn_vnet_ip_delete
- Addedpve_sdn_vnet_ip_update
- Addedpve_sdn_vnet_mac_vrf
- Addedpve_sdn_zone_bridges
- Addedpve_sdn_zone_content
- Addedpve_sdn_zone_get
- Addedpve_sdn_zone_ip_vrf
- Addedpve_sdn_zone_status_list
110 tool updatesv0.23.0Jul 16, 2026
- Addedpbs_admin_gc_jobs_list
- Addedpbs_admin_prune_jobs_list
- Addedpbs_admin_sync_jobs_list
- Addedpbs_admin_traffic_control_status
- Addedpbs_admin_verify_jobs_list
- Addedpbs_datastore_active_operations
- Addedpbs_datastore_mount
- Addedpbs_datastore_prune
- Addedpbs_datastore_rrd
- Addedpbs_datastore_s3_refresh
- Addedpbs_datastore_unmount
- Addedpbs_datastores_usage
- Addedpbs_encryption_key_create
- Addedpbs_encryption_key_delete
- Addedpbs_encryption_key_list
- Addedpbs_encryption_key_toggle_archive
- Addedpbs_group_delete
- Addedpbs_group_move
- Addedpbs_group_notes_get
- Addedpbs_group_notes_set
- Addedpbs_groups_list
- Addedpbs_metrics_influxdb_http_create
- Addedpbs_metrics_influxdb_http_delete
- Addedpbs_metrics_influxdb_http_get
- Addedpbs_metrics_influxdb_http_list
- Addedpbs_metrics_influxdb_http_update
- Addedpbs_metrics_influxdb_udp_create
- Addedpbs_metrics_influxdb_udp_delete
- Addedpbs_metrics_influxdb_udp_get
- Addedpbs_metrics_influxdb_udp_list
- Addedpbs_metrics_influxdb_udp_update
- Addedpbs_metrics_servers_list
- Addedpbs_metrics_status
- Addedpbs_namespace_move
- Addedpbs_node_config_get
- Addedpbs_node_config_set
- Addedpbs_node_identity
- Addedpbs_node_report
- Addedpbs_node_rrd
- Addedpbs_pull
- Addedpbs_push
- Addedpbs_remote_scan
- Addedpbs_remote_scan_groups
- Addedpbs_remote_scan_namespaces
- Addedpbs_s3_check
- Addedpbs_s3_client_create
- Addedpbs_s3_client_delete
- Addedpbs_s3_client_get
- Addedpbs_s3_client_list
- Addedpbs_s3_client_update
- Addedpbs_s3_list_buckets
- Addedpbs_s3_reset_counters
- Addedpbs_snapshot_protected_get
- Addedpbs_tape_backup
- Addedpbs_tape_backup_job_create
- Addedpbs_tape_backup_job_delete
- Addedpbs_tape_backup_job_get
- Addedpbs_tape_backup_job_list
- Addedpbs_tape_backup_job_run
- Addedpbs_tape_backup_job_update
- Addedpbs_tape_changer_create
- Addedpbs_tape_changer_delete
- Addedpbs_tape_changer_get
- Addedpbs_tape_changer_list
- Addedpbs_tape_changer_status
- Addedpbs_tape_changer_transfer
- Addedpbs_tape_changer_update
- Addedpbs_tape_drive_barcode_label_media
- Addedpbs_tape_drive_cartridge_memory
- Addedpbs_tape_drive_catalog
- Addedpbs_tape_drive_clean
- Addedpbs_tape_drive_create
- Addedpbs_tape_drive_delete
- Addedpbs_tape_drive_eject
- Addedpbs_tape_drive_format
- Addedpbs_tape_drive_get
- Addedpbs_tape_drive_inventory
- Addedpbs_tape_drive_inventory_update
- Addedpbs_tape_drive_label_media
- Addedpbs_tape_drive_list
- Addedpbs_tape_drive_load_media
- Addedpbs_tape_drive_load_slot
- Addedpbs_tape_drive_read_label
- Addedpbs_tape_drive_restore_key
- Addedpbs_tape_drive_rewind
- Addedpbs_tape_drive_status
- Addedpbs_tape_drive_unload
- Addedpbs_tape_drive_update
- Addedpbs_tape_drive_volume_statistics
- Addedpbs_tape_key_create
- Addedpbs_tape_key_delete
- Addedpbs_tape_key_get
- Addedpbs_tape_key_list
- Addedpbs_tape_key_update_password
- Addedpbs_tape_media_content
- Addedpbs_tape_media_destroy
- Addedpbs_tape_media_list
- Addedpbs_tape_media_move
- Addedpbs_tape_media_sets
- Addedpbs_tape_media_status_get
- Addedpbs_tape_media_status_set
- Addedpbs_tape_pool_create
- Addedpbs_tape_pool_delete
- Addedpbs_tape_pool_get
- Addedpbs_tape_pool_list
- Addedpbs_tape_pool_update
- Addedpbs_tape_restore
- Addedpbs_tape_scan_changers
- Addedpbs_tape_scan_drives
- Addedpbs_version
128 tool updatesv0.22.0Jul 15, 2026
- Addedpbs_acl_get
- Addedpbs_acl_update
- Addedpbs_acme_account_create
- Addedpbs_acme_account_delete
- Addedpbs_acme_account_get
- Addedpbs_acme_account_list
- Addedpbs_acme_account_update
- Addedpbs_acme_cert_order
- Addedpbs_acme_cert_renew
- Addedpbs_acme_challenge_schema
- Addedpbs_acme_directories
- Addedpbs_acme_plugin_create
- Addedpbs_acme_plugin_delete
- Addedpbs_acme_plugin_get
- Addedpbs_acme_plugin_update
- Addedpbs_acme_plugins_list
- Addedpbs_acme_tos
- Addedpbs_apt_changelog
- Addedpbs_apt_repositories_get
- Addedpbs_apt_repository_add
- Addedpbs_apt_repository_set
- Addedpbs_apt_update_refresh
- Addedpbs_apt_updates_list
- Addedpbs_apt_versions
- Addedpbs_node_cert_delete
- Addedpbs_node_cert_upload
- Addedpbs_node_certificates_list
- Addedpbs_node_disk_directory_create
- Addedpbs_node_disk_directory_delete
- Addedpbs_node_disk_directory_list
- Addedpbs_node_disk_initgpt
- Addedpbs_node_disk_smart
- Addedpbs_node_disk_wipe
- Addedpbs_node_disk_zfs_create
- Addedpbs_node_disk_zfs_get
- Addedpbs_node_disk_zfs_list
- Addedpbs_node_disks_list
- Addedpbs_node_dns_get
- Addedpbs_node_dns_set
- Addedpbs_node_journal
- Addedpbs_node_network_iface_create
- Addedpbs_node_network_iface_delete
- Addedpbs_node_network_iface_get
- Addedpbs_node_network_iface_update
- Addedpbs_node_network_list
- Addedpbs_node_network_reload
- Addedpbs_node_network_revert
- Addedpbs_node_service_control
- Addedpbs_node_service_status
- Addedpbs_node_services_list
- Addedpbs_node_status
- Addedpbs_node_subscription_check
- Addedpbs_node_subscription_delete
- Addedpbs_node_subscription_get
- Addedpbs_node_subscription_set
- Addedpbs_node_syslog
- Addedpbs_node_task_log
- Addedpbs_node_task_status
- Addedpbs_node_task_stop
- Addedpbs_node_time_get
- Addedpbs_node_time_set
- Addedpbs_notification_endpoint_create
- Addedpbs_notification_endpoint_delete
- Addedpbs_notification_endpoint_get
- Addedpbs_notification_endpoint_list
- Addedpbs_notification_endpoint_update
- Addedpbs_notification_matcher_delete
- Addedpbs_notification_matcher_field_values
- Addedpbs_notification_matcher_fields
- Addedpbs_notification_matcher_get
- Addedpbs_notification_matcher_set
- Addedpbs_notification_matchers_list
- Addedpbs_notification_target_test
- Addedpbs_notification_targets_list
- Addedpbs_permissions_get
- Addedpbs_realm_ad_create
- Addedpbs_realm_ad_delete
- Addedpbs_realm_ad_get
- Addedpbs_realm_ad_list
- Addedpbs_realm_ad_update
- Addedpbs_realm_ldap_create
- Addedpbs_realm_ldap_delete
- Addedpbs_realm_ldap_get
- Addedpbs_realm_ldap_list
- Addedpbs_realm_ldap_update
- Addedpbs_realm_openid_create
- Addedpbs_realm_openid_delete
- Addedpbs_realm_openid_get
- Addedpbs_realm_openid_list
- Addedpbs_realm_openid_update
- Addedpbs_realm_pam_get
- Addedpbs_realm_pam_set
- Addedpbs_realm_pbs_get
- Addedpbs_realm_pbs_set
- Addedpbs_roles_list
- Addedpbs_tfa_add
- Addedpbs_tfa_delete
- Addedpbs_tfa_entry_get
- Addedpbs_tfa_list
- Addedpbs_tfa_unlock
- Addedpbs_tfa_update
- Addedpbs_tfa_user_get
- Addedpbs_tfa_webauthn_get
- Addedpbs_tfa_webauthn_set
- Addedpbs_token_create
- Addedpbs_token_delete
- Addedpbs_token_update
- Addedpbs_user_create
- Addedpbs_user_delete
- Addedpbs_user_get
- Addedpbs_user_token_get
- Addedpbs_user_tokens_list
- Addedpbs_user_update
- Addedpbs_users_list
- Addedpmg_apt_changelog
- Addedpmg_apt_repositories_get
- Addedpmg_apt_repository_add
- Addedpmg_apt_repository_set
- Addedpmg_apt_update_refresh
- Addedpmg_apt_updates_list
- Addedpmg_apt_versions
- Addedpve_apt_changelog
- Addedpve_apt_repositories_get
- Addedpve_apt_repository_add
- Addedpve_apt_repository_set
- Addedpve_apt_update_refresh
- Addedpve_apt_updates_list
- Addedpve_apt_versions

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

A3.7/5.0

Scored 2026-10-27 09:20 across 6 tools

Disambiguation4/5

Each tool has a distinct core role: discovery (find), pre-flight (plan), GET (read), mutation (call), and audit ledger/verification. Some overlap exists between proximo_plan and proximo_call without confirm=true, and between proximo_find and proximo_read's word-based lookup, but descriptions clarify the boundaries.

Naming Consistency4/5

The four core tools follow a clear proximo_<verb> pattern (find, plan, read, call). The audit tools use a different prefix and mix noun/verb forms (audit_entries vs audit_verify), which is a minor deviation but still readable and logically grouped.

Tool Count5/5

Six tools is well-scoped for a governed API proxy: discovery, planning, reading, mutating, and audit ledger/verification. Each tool earns its place without redundancy.

Completeness4/5

The surface covers the full lifecycle—find, plan, read, mutate, and audit—with no obvious dead ends. Minor gaps exist (e.g., no dedicated tool to list global consent/arming status), but agents can work around them via proximo_plan or audit_entries.

Maintenance

ActivityActive

ResponsivenessResponsive

Resources

Related MCP Connectors

Bastrio
io.bastr
Manage remote servers, SSH terminals, files, databases and proxies with scoped access and approvals.
Networking & Infrastructure Shell Access Security
1
https://bastr.io/api/mcp
browser-ssh
com.browserssh
Scoped, audited SSH exec, sessions, and SFTP on your saved servers without exposing credentials
Shell Access File Systems
2
https://api.browserssh.com/mcp
emisar
dev.emisar
Let AI operate servers without SSH. Choose actions, approve risky changes, and audit every step.
Cloud Platforms Security Networking & Infrastructure
2330
https://emisar.dev/api/mcp/rpc
ReMCP B
site.remcp
Securely control computers you explicitly pair through files, terminals, processes, screenshots, desktop UI/input, clipboard, browser automation, diagnostics, and document tools.
Command Line File Systems OS Automation
1741
https://remcp.site/mcp

Related MCP Servers

Proxmox MCP Server
Virtualization Developer Tools Cloud Platforms
canvrno
A
license
Not graded
quality
F
maintenance
A Python-based server enabling interaction with Proxmox hypervisors. It supports secure authentication and provides tools for managing nodes, VMs, clusters, and storage.
Updated 2 years ago (2025-02-19 20:16 UTC)
297
MIT
ProxmoxMCP-Plus
Virtualization Developer Tools App Automation
RekklesNA
A
license
Not graded
quality
A
maintenance
An enhanced Python-based MCP server that enables complete VM lifecycle management and monitoring of Proxmox virtualization platforms through natural language, with 11 REST API endpoints for seamless integration.
Updated 2 days ago (2026-11-01 23:21 UTC)
2,863 PyPI
635
MIT
Proxmox MCP Server
Virtualization Cloud Platforms Developer Tools
mjrestivo16
A
license
Not graded
quality
D
maintenance
Enables comprehensive management of Proxmox Virtual Environment through 35 tools for VMs, containers, storage, backups, snapshots, and cluster operations via the Proxmox VE API.
Updated a year ago (2025-12-04 07:03 UTC)
14 npm
22
MIT
ProxmoxMCP-Plus
Virtualization Monitoring
rodaddy
A
license
Not graded
quality
C
maintenance
Enables comprehensive management of Proxmox virtualization environments, including VM and container lifecycle, snapshots, backups, monitoring, and OpenAPI integration.
Updated 2 months ago (2026-08-23 00:22 UTC)
12
MIT