# fleet (pypi · agents-fleet)

Every machine you have, for your agent: free GPUs, jobs, served models, software, over SSH.

- Trust score: 76/100 (medium)
- Change this week: +15
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- pypi · `agents-fleet`: 76/100 (this document), [markdown](https://verifymcp.io/servers/sinolion-fleet/agents-fleet.md), [page](https://verifymcp.io/servers/sinolion-fleet/agents-fleet)

## Channel facts

- Registry: `pypi`
- Package: `agents-fleet`
- Version: `0.6.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised build step with no custom scripting around it.
  - 4 of 40 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to sinolion/fleet).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 6 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 58/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 1781 tokens (~161/item across 11 items; 11 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 67/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 11 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 12 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the fleet MCP server?

fleet runs locally as a PyPI package, launched with uvx agents-fleet. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add sinolion-fleet -- uvx agents-fleet
```

### Cursor

```json
{
  "mcpServers": {
    "sinolion-fleet": {
      "command": "uvx",
      "args": [
        "agents-fleet"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "sinolion-fleet": {
      "command": "uvx",
      "args": [
        "agents-fleet"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add sinolion-fleet -- uvx agents-fleet
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "sinolion-fleet": {
      "type": "local",
      "command": [
        "uvx",
        "agents-fleet"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add sinolion-fleet --command uvx --arg agents-fleet
```

### Hermes

```yaml
mcp_servers:
  sinolion-fleet:
    command: "uvx"
    args: ["agents-fleet"]
```

### Netclaw

```json
{
  "McpServers": {
    "sinolion-fleet": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "agents-fleet"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add sinolion-fleet -t stdio -c uvx -a agents-fleet
```

### Other

```json
{
  "mcpServers": {
    "sinolion-fleet": {
      "command": "uvx",
      "args": [
        "agents-fleet"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-30 (score 76, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-10-29 (score 61)

First indexed and scored.

## MCP tools (11)

### `list_machines` (~136 tokens)

Every machine, with what is free right now. Filter with `tag` to pick by capability -- repeated tags must all match. Facts include gpu, cuda, rocm, metal, multi-gpu, vram-NNg, linux/macos/windows, x86_64/arm64, cores-NN, ram-NNg, storage-NNt, public-ip/mesh/lan, rental/shared/appliance, plus any tag a human set.

Input parameters:

- `fields`
- `names`
- `online` (boolean)
- `refresh` (boolean)
- `rescan` (boolean)
- `tag`

### `show_machine` (~101 tokens)

Full detail for one machine: CPU, RAM, every GPU and its jobs, mounts, listening services, the models its servers serve, its software (cuda, python, and each Python environment's torch/vllm/mlx/... versions), the folders it keeps models, datasets and media in, tags and facts. No name means the machine fleet is running on.

Input parameters:

- `name`
- `refresh` (boolean)
- `rescan` (boolean)

### `list_gpu_jobs` (~83 tokens)

Every job on every GPU across the fleet -- who runs it, how much VRAM, for how long, the command -- and which GPUs are idle. A GPU with jobs is someone's: ask before using it, and so is one in `busy_unseen`, in use by processes this login cannot see.

Input parameters:

- `names`
- `refresh` (boolean)

### `list_models` (~150 tokens)

Every model being served across the fleet: machine, server, url, and for a server that only listens on its own machine a `tunnel` command to reach it (`reach: down`: declared but not running); plus the folders each machine keeps models in, and `not_read`: machines that did not answer, so their servers are not known. Check this before downloading a model: one already served or on disk need not be fetched. `models` names a server's first 20; `models_total` says how many it serves, and the rest are at its own /v1/models.

Input parameters:

- `names`
- `refresh` (boolean)
- `rescan` (boolean)

### `set_machine_paths` (~88 tokens)

Record where a machine keeps things, in its own machine.yaml: kind is models, datasets, media, scratch, envs or one of your own; paths replace that kind's folders, and an empty list clears it. Ask the user where before recording a folder they did not name.

Input parameters:

- `kind` (string, required)
- `machine` (string, required)
- `paths` (array, required)

### `set_machine_endpoint` (~114 tokens)

Declare a model server the probe would not find by itself (an unusual port, a program it does not recognise), in the machine's own machine.yaml: port, and a base path if it is not /v1. port=None removes it (a name not declared comes back in `not_declared`). Never pass an API key; a server that wants one is shown as wanting one.

Input parameters:

- `machine` (string, required)
- `name` (string, required)
- `path` (string)
- `port`

### `run_on_machine` (~87 tokens)

Run one command on a machine and return its output and exit code. This is how work actually gets started -- fleet resolves the address and connects as the user does, so never build an ssh command by hand. Returns within 120 seconds: start long jobs detached (nohup ... > log 2>&1 &).

Input parameters:

- `command` (string, required)
- `machine` (string, required)

### `add_machine` (~121 tokens)

Add a machine from how the user connects to it: an ssh command such as `ssh -p 40001 root@1.2.3.4`, or a name from discover_machines. Ask for it if the user did not give one. If the machine refuses, the result has `why` and `fix` -- the one thing the user does to let fleet in. Never ask for a password.

Input parameters:

- `alias`
- `kind`
- `name`
- `ssh_command` (string, required)
- `tags`

### `discover_machines` (~62 tokens)

Machines the user can already reach that are not added yet: the Host entries of their ~/.ssh/config, and the machines on their tailnet. Offer the ones that look relevant; add one with add_machine(ssh_command=its name) once the user agrees.

### `doctor_machine` (~69 tokens)

Why a machine will not let fleet in, and the exact fix for it: the key line to run there, the provider account to add the key to, or the Tailscale SSH rule. Changes nothing; tell the user what it says -- access is theirs to grant.

Input parameters:

- `name`

### `edit_machine` (~227 tokens)

Label a machine, or change what it costs per hour (for the $/HR column and burn rate), how it is reached, or which disks to watch for free space: disk_paths means exactly these paths from now on -- for a container or rental whose `/` is not where the space is -- and autodetect_disks goes back. rename gives it a new name, alias a short one (empty clears it). Tags, cost and note are written to the machine's own machine.yaml, so everyone who looks at it reads them; local=True keeps tags and cost in this machine's list instead (for a machine you cannot or should not write to). Measured facts such as cuda or vram-24g come from probes.

Input parameters:

- `add_tags`
- `alias`
- `autodetect_disks` (boolean)
- `cost_per_hour`
- `disk_paths`
- `local` (boolean)
- `name` (string, required)
- `note`
- `remove_tags`
- `rename`
- `ssh_command`

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/sinolion-fleet/agents-fleet#diagnostics

## Score history

- 2026-11-05: 76
- 2026-11-04: 76
- 2026-11-03: 76
- 2026-11-02: 76
- 2026-11-01: 76
- 2026-10-31: 76
- 2026-10-30: 76
- 2026-10-29: 61

## Common questions

### What is the fleet MCP server?

fleet is an MCP server listed in the public MCP registry as io.github.sinolion/fleet. Every machine you have, for your agent: free GPUs, jobs, served models, software, over SSH. This page covers its PyPI package (agents-fleet).

### Is the fleet MCP server safe to use?

fleet scores 76 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the fleet MCP server expose?

fleet exposes 11 tools: list_machines, show_machine, list_gpu_jobs, list_models, set_machine_paths, and 6 more. Their descriptions and schemas cost roughly 1,238 tokens of context every time the server is loaded.

### Is the fleet MCP server still maintained?

fleet is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the fleet MCP server under?

fleet declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/agents-fleet/
- Socket report: https://socket.dev/pypi/package/agents-fleet
- Repository: https://github.com/sinolion/fleet
- Changelog RSS feed: https://verifymcp.io/servers/sinolion-fleet/agents-fleet.xml
- Changelog JSON feed: https://verifymcp.io/servers/sinolion-fleet/agents-fleet.json
- HTML version of this page: https://verifymcp.io/servers/sinolion-fleet/agents-fleet