# Moltline Optimize (remote · mcp.moltlinestudio.com)

Vehicle routing, 3-D packing, cutting stock, rostering and knapsack with OR-Tools. 7 of 11 free.

- Trust score: 79/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-21

## Components

- remote · `mcp.moltlinestudio.com`: 79/100 (this document), [markdown](https://verifymcp.io/servers/com-moltlinestudio-optimize/optimize.md), [page](https://verifymcp.io/servers/com-moltlinestudio-optimize/optimize)

## Channel facts

- Endpoint: `https://mcp.moltlinestudio.com/optimize`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.2.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, 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-09-21.

- **Endpoint Security**: 83/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Every tool declares its destructiveHint and none is destructive, so open access doesn't expose one.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC is configured correctly; the domain's records validate against the full chain to the root.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 59/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4069 tokens (~369/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**: 50/100
  - Stability observed for 15 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **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 supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Moltline Optimize MCP server?

Moltline Optimize is a hosted endpoint at https://mcp.moltlinestudio.com/optimize, so there is nothing to install locally. 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 --transport http com-moltlinestudio-optimize 'https://mcp.moltlinestudio.com/optimize'
```

### Cursor

```json
{
  "mcpServers": {
    "com-moltlinestudio-optimize": {
      "url": "https://mcp.moltlinestudio.com/optimize"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-moltlinestudio-optimize": {
      "type": "http",
      "url": "https://mcp.moltlinestudio.com/optimize"
    }
  }
}
```

### Codex

```toml
[mcp_servers.com-moltlinestudio-optimize]
url = "https://mcp.moltlinestudio.com/optimize"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-moltlinestudio-optimize": {
      "type": "remote",
      "url": "https://mcp.moltlinestudio.com/optimize",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-moltlinestudio-optimize --url 'https://mcp.moltlinestudio.com/optimize' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-moltlinestudio-optimize:
    url: "https://mcp.moltlinestudio.com/optimize"
```

### Netclaw

```json
{
  "McpServers": {
    "com-moltlinestudio-optimize": {
      "Transport": "http",
      "Url": "https://mcp.moltlinestudio.com/optimize"
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-moltlinestudio-optimize -t streamable-http -u 'https://mcp.moltlinestudio.com/optimize'
```

### Other

```json
{
  "mcpServers": {
    "com-moltlinestudio-optimize": {
      "type": "http",
      "url": "https://mcp.moltlinestudio.com/optimize"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## 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-09-21 (score 79, +1)

No change was recorded against any check on this day. Stability & Change Management went from 47 to 50. That category is still filling its 30-day observation window: 14 days of observed history at the previous scan, 15 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-19 (score 78, +1)

No change was recorded against any check on this day. Stability & Change Management went from 40 to 43. That category is still filling its 30-day observation window: 12 days of observed history at the previous scan, 13 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-17 (score 77, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-14 (score 76, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-12 (score 75, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-10 (score 74, +1)

No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-08 (score 73, +1)

No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-07 (score 72, +9)

- [security improvement] Authorization: unverified → partial
- [security improvement] HSTS header: unverified → pass
- [functional improvement] Stability: unverified → 0.03

## MCP tools (11)

### `route_plan` (~409 tokens)

Route Plan

Order up to 12 stops into the shortest single-vehicle route on your distance matrix. FREE.

Typical input {"stops": [{"id": "depot"}, {"id": "A"}, {"id": "B"}],
"matrix": [[0, 5, 9], [5, 0, 4], [9, 4, 0]]} returns {"routes":
[{"vehicle": 0, "stops": [...], "distance": 18.0}], "total_distance":
18.0, "solver_status": "FEASIBLE", "note": "..."}. The matrix is in
your units (km, minutes, cost) and must be square with the depot at
index 0 unless depot says otherwise; optional demand per stop with
vehicle_capacity turns it into a capacity check. Use for one driver's
day or a courier's loop. Not for several vehicles or time windows: use
route_plan_fleet. Not a map service: bring your own distances or call
distance_matrix_haversine for straight-line values. Errors: on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": "<what is wrong and how to fix it>"} (for example {"error": "stops must be a list of stop objects, depot first"}). Every call is read-only and idempotent, so after correcting the input it is always safe to retry.

Input parameters:

- `depot` (integer): index of the depot in stops (default 0).
- `matrix` (array, required): square distance (or time) matrix, row i column j = cost from stop i to stop j.
- `stops` (array, required): list of stop objects, depot first: id, optional demand.
- `time_limit_s` (number): solver time budget in seconds (default 3, max 15).
- `vehicle_capacity` (number): optional capacity in the units of demand (0 = unlimited).

### `route_plan_fleet` (~487 tokens)

Route Plan Fleet

Capacitated, time-windowed routing for a fleet over up to 200 stops. PREMIUM (license).

Typical input {"stops": [{"id": "depot", "window": [480, 1080]},
{"id": "A", "demand": 3, "window": [540, 720], "service_min": 10}, ...],
"matrix": [[...]], "vehicles": [{"id": "van1", "capacity": 10},
{"id": "van2", "capacity": 8, "max_distance": 120}]} returns {"routes":
[{"vehicle": "van1", "stops": [{"id": "A", "arrive_min": 545, ...}],
"distance": 42.5, "load": 9}], "unserved": [], "solver_status":
"FEASIBLE"}. Windows and service times are minutes from the start of
the day; travel time comes from time_matrix (minutes) or, if absent, the
distance matrix read as minutes. Set drop_penalty to allow stops to be
left unserved at that cost instead of returning INFEASIBLE. Use for
daily dispatch. Not a map service; bring your own matrices. Errors: on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": "<what is wrong and how to fix it>"} (for example {"error": "stops must be a list of stop objects, depot first"}). Every call is read-only and idempotent, so after correcting the input it is always safe to retry.

Input parameters:

- `depot` (integer): index of the depot in stops (default 0).
- `drop_penalty` (number): cost of leaving a stop unserved (0 = every stop must be served).
- `matrix` (array, required): square distance matrix in your units.
- `stops` (array, required): depot first; each: id, demand, window [earliest_min, latest_min], service_min.
- `time_limit_s` (number): solver time budget in seconds (default 10, max 60).
- `time_matrix` (array): optional square travel-time matrix in minutes (defaults to matrix).
- `vehicles` (array, required): list of {id, capacity, max_distance}; capacity in the units of demand.

### `distance_matrix_haversine` (~268 tokens)

Distance Matrix Haversine

Straight-line (great-circle) distance matrix from coordinates. FREE.

Typical input {"points": [{"id": "depot", "lat": 51.5, "lon": -0.12},
{"id": "A", "lat": 51.52, "lon": -0.1}]} returns {"matrix": [[0,
2.6], [2.6, 0]], "unit": "km", "kind": "straight-line (haversine), not
road distance"}. Use when you have no road matrix and a straight-line
approximation is acceptable, or to sanity-check one. Not road routing:
real driving distances are longer and the difference is not uniform. Errors: on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": "<what is wrong and how to fix it>"} (for example {"error": "points must be a list of at least two <value> objects"}). Every call is read-only and idempotent, so after correcting the input it is always safe to retry.

Input parameters:

- `points` (array, required): list of {id, lat, lon} (up to 200).
- `unit` (string): km (default) or mi.

### `pack_bins` (~411 tokens)

Pack Bins

Place up to 20 boxes into containers or pallets with rotation, weight and support rules. FREE.

Typical input {"items": [{"id": "A", "l": 60, "w": 40, "h": 30,
"weight": 12, "qty": 4}], "containers": [{"id": "pallet", "l": 120,
"w": 80, "h": 150, "max_weight": 500, "qty": 2}]} returns
{"containers_used": 1, "containers": [{"placements": [{"id": "A",
"x": 0, "y": 0, "z": 0, "l": 60, "w": 40, "h": 30}, ...],
"volume_fill_pct": 20.0}], "unplaced": []}. rotation per item: any,
upright (rotate around the vertical axis only) or fixed; fragile items
carry nothing; rules.min_support (default 0.6) is the share of a box's
base that must rest on the floor or on boxes below. Use to decide pallet
or carton count before booking freight. Not proven optimal: it is a
first-fit-decreasing heuristic, reported as such. Errors: on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": "<what is wrong and how to fix it>"}. Every call is read-only and idempotent, so after correcting the input it is always safe to retry.

Input parameters:

- `containers` (array, required): list of {id, l, w, h, max_weight, qty}; used in the order given.
- `items` (array, required): list of {id, l, w, h, weight, qty, rotation, fragile}, all in one length unit.
- `rules` (object): optional {min_support: 0-1, default_rotation: any|upright|fixed}.

### `pack_bins_large` (~301 tokens)

Pack Bins Large

Same packer as pack_bins for up to 300 item units and 200 containers. PREMIUM (license).

Typical input {"items": [{"id": "SKU1", "l": 40, "w": 30, "h": 20,
"weight": 5, "qty": 120}, ...], "containers": [{"id": "euro-pallet",
"l": 120, "w": 80, "h": 180, "max_weight": 800, "qty": 10}]} returns
the same shape as pack_bins: containers with placements, fill
percentages, weights and any unplaced units. Use for order
consolidation and load planning. Not proven optimal (first-fit
decreasing on extreme points, reported as such). Errors: on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": "<what is wrong and how to fix it>"}. Every call is read-only and idempotent, so after correcting the input it is always safe to retry.

Input parameters:

- `containers` (array, required): list of {id, l, w, h, max_weight, qty}.
- `items` (array, required): list of {id, l, w, h, weight, qty, rotation, fragile}.
- `rules` (object): optional {min_support: 0-1, default_rotation: any|upright|fixed}.

### `cutting_stock_1d` (~377 tokens)

Cutting Stock 1D

Least-waste cut plan for bars, pipes or boards from stock lengths, with saw kerf. FREE.

Typical input {"stock": [{"length": 6000, "cost": 30}], "parts":
[{"length": 2200, "qty": 3}, {"length": 1500, "qty": 4}], "kerf": 3}
returns {"bars": [{"stock_length": 6000, "cuts": [2200, 2200, 1500],
"waste": 94}], "bars_used": 3, "waste_pct": 4.2, "solver_status":
"OPTIMAL"}. Minimises total stock cost (or count when no cost); CP-SAT
proves optimality when it finishes inside the time limit and otherwise
returns the best plan found as FEASIBLE. Use for a cut list of up to 200
pieces. Not for sheets: use cutting_stock_2d. Errors: on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": "<what is wrong and how to fix it>"} (for example {"error": "stock and parts must be non-empty lists (<value> and <value>)"}). Every call is read-only and idempotent, so after correcting the input it is always safe to retry.

Input parameters:

- `kerf` (number): material lost per cut (same unit as lengths).
- `parts` (array, required): required pieces: {length, qty}.
- `stock` (array, required): stock lengths available: {length, cost, qty} (qty = how many of that length may be used; default unlimited).
- `time_limit_s` (number): solver time budget in seconds (default 3, max 15).

### `cutting_stock_2d` (~415 tokens)

Cutting Stock 2D

Guillotine cut layouts for rectangular parts from sheets, with kerf and grain. PREMIUM (license).

Typical input {"sheets": [{"id": "ply", "l": 2440, "w": 1220, "qty":
5}], "parts": [{"id": "side", "l": 800, "w": 400, "qty": 6}], "kerf":
3} returns {"sheets_used": 1, "layouts": [{"sheet": "ply", "placements":
[{"id": "side", "x": 0, "y": 0, "l": 800, "w": 400, "rotated": false}],
"fill_pct": 64.5, "offcuts": [...]}], "unplaced": []}. Every cut is a
guillotine cut (edge to edge): the sheet is ripped into strips and each
strip cross-cut, which is what a panel saw does; grain true forbids
rotating parts unless a part sets rotate true. Use for cabinet, sign
and sheet-metal cut lists. Not proven optimal: a best-fit shelf
heuristic, reported as such. Errors: on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": "<what is wrong and how to fix it>"} (for example {"error": "sheets and parts must be non-empty lists (<value> and <value>)"}). Every call is read-only and idempotent, so after correcting the input it is always safe to retry.

Input parameters:

- `grain` (boolean): true when parts must keep their orientation (l along the sheet's l).
- `kerf` (number): saw blade width lost per cut.
- `parts` (array, required): {id, l, w, qty, rotate}; rotate overrides the grain rule per part.
- `sheets` (array, required): {id, l, w, qty}; used in the order given.

### `roster_shifts` (~448 tokens)

Roster Shifts

Assign staff to shifts under availability, skills, hour caps and rest gaps. PREMIUM (license).

Typical input {"staff": [{"id": "ana", "skills": ["till"],
"max_hours": 40, "unavailable": ["sat-am"]}, ...], "shifts": [{"id":
"sat-am", "start": "2026-09-12T08:00", "end": "2026-09-12T14:00",
"required": 2, "skill": "till"}, ...], "rules": {"min_rest_hours": 11,
"max_consecutive_days": 6}} returns {"assignments": [{"shift":
"sat-am", "staff": ["ana", "ben"]}], "unfilled": [{"shift": "sun-pm",
"short": 1}], "hours": {"ana": 30.0}, "solver_status": "OPTIMAL"}. The
objective fills as many required slots as possible, then spreads hours
evenly, then honours preferences (staff.prefer / staff.avoid shift ids).
Use for weekly rotas of up to 60 staff and 150 shifts. Not a
determination of labour-law compliance: the rules are the ones you pass. Errors: on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": "<what is wrong and how to fix it>"} (for example {"error": "staff and shifts must be non-empty lists"}). Every call is read-only and idempotent, so after correcting the input it is always safe to retry.

Input parameters:

- `rules` (object): {min_rest_hours (default 0), max_consecutive_days (default 7), max_shifts_per_day (default 1)}.
- `shifts` (array, required): {id, start, end (ISO 8601 local), required, skill, weight}.
- `staff` (array, required): {id, skills[], max_hours, min_hours, unavailable[], prefer[], avoid[], max_shifts}.
- `time_limit_s` (number): solver time budget in seconds (default 10, max 60).

### `knapsack_select` (~327 tokens)

Knapsack Select

Choose the items that maximise value under one or more capacity limits. FREE.

Typical input {"items": [{"id": "a", "value": 60, "weight": 10, "cost":
120}, {"id": "b", "value": 100, "weight": 20, "cost": 300}], "limits":
{"weight": 25, "cost": 400}} returns {"selected": ["a"], "value": 60,
"used": {"weight": 10, "cost": 120}, "slack": {"weight": 15, "cost":
280}, "solver_status": "OPTIMAL"}. Any numeric item field named in
limits is a constrained resource; qty lets an item be taken several
times. Use for budgets, cargo, campaign or feature selection. Not for
dependencies between items. Errors: on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": "<what is wrong and how to fix it>"} (for example {"error": "items must be a non-empty list of <value>"}). Every call is read-only and idempotent, so after correcting the input it is always safe to retry.

Input parameters:

- `items` (array, required): {id, value, qty, <resource fields>}: value to maximise plus one number per limited resource.
- `limits` (object, required): {resource_name: capacity} for each constrained field.
- `time_limit_s` (number): solver time budget in seconds (default 3, max 15).

### `validate_problem` (~294 tokens)

Validate Problem

Check a problem's shape and obvious feasibility before spending solver time. FREE.

Typical input {"type": "route", "problem": {"stops": [...], "matrix":
[[...]], "vehicles": [...]}} returns {"ok": false, "issues": ["total
demand 34 exceeds total capacity 30"], "size": {"stops": 14,
"vehicles": 2}, "tier_hint": "route_plan_fleet (licence) - more than 12
stops"}. Types: route, pack, cut1d, cut2d, roster, knapsack; the problem
object uses the same fields as the matching tool. Use first when an
agent has assembled the problem from other data. Not a solve: it never
calls the solver. Errors: on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": "<what is wrong and how to fix it>"} (for example {"error": "type must be one of <value>"}). Every call is read-only and idempotent, so after correcting the input it is always safe to retry.

Input parameters:

- `problem` (object, required): the same object you would pass to the tool (stops/matrix/vehicles, items/containers, ...).
- `type` (string, required): route, pack, cut1d, cut2d, roster or knapsack.

### `explain_solution` (~261 tokens)

Explain Solution

Plain-language summary of a solution from this server and the constraints that bind. FREE.

Typical input {"solution": <result of route_plan_fleet>} returns
{"summary": "2 vehicles serve 14 stops over 96.4 km; 1 stop unserved",
"binding_constraints": ["van2 is at 100% of capacity", "stop C arrives
at the end of its window"], "status": "FEASIBLE"}. It recognises
results from route_plan, route_plan_fleet, pack_bins, cutting_stock_1d,
cutting_stock_2d, roster_shifts and knapsack_select by their fields.
Use to turn solver output into a message for a dispatcher or a shop
floor. Not a re-solve. Errors: on invalid, missing, or malformed input this tool never raises a protocol error — it returns {"error": "<what is wrong and how to fix it>"} (for example {"error": "solution must be the result object returned by a solve tool on this server"}). Every call is read-only and idempotent, so after correcting the input it is always safe to retry.

Input parameters:

- `solution` (object, required): the result object returned by one of this server's solve tools.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/com-moltlinestudio-optimize/optimize#diagnostics

## Score history

- 2026-09-21: 79
- 2026-09-20: 78
- 2026-09-19: 78
- 2026-09-18: 77
- 2026-09-17: 77
- 2026-09-16: 76
- 2026-09-15: 76
- 2026-09-14: 76
- 2026-09-13: 75
- 2026-09-12: 75
- 2026-09-11: 74
- 2026-09-10: 74
- 2026-09-09: 73
- 2026-09-08: 73
- 2026-09-07: 72
- 2026-09-06: 63

## Common questions

### What is the Moltline Optimize MCP server?

Moltline Optimize is an MCP server listed in the public MCP registry as com.moltlinestudio/optimize. Vehicle routing, 3-D packing, cutting stock, rostering and knapsack with OR-Tools. 7 of 11 free. This page covers its hosted endpoint (https://mcp.moltlinestudio.com/optimize).

### Is the Moltline Optimize MCP server safe to use?

Moltline Optimize scores 79 out of 100 on VerifyMCP. 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 Moltline Optimize MCP server expose?

Moltline Optimize exposes 11 tools: route_plan, route_plan_fleet, distance_matrix_haversine, pack_bins, pack_bins_large, and 6 more. Their descriptions and schemas cost roughly 3,998 tokens of context every time the server is loaded.

### Does the Moltline Optimize MCP server require authentication?

No. We connected to Moltline Optimize without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the Moltline Optimize MCP server still maintained?

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

## Links

- Remote endpoint: https://mcp.moltlinestudio.com/optimize
- Repository: https://github.com/GarphenGate/moltline-mcp
- Website: https://moltlinestudio.com/servers.html#optimize
- Changelog RSS feed: https://verifymcp.io/servers/com-moltlinestudio-optimize/optimize.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-moltlinestudio-optimize/optimize.json
- HTML version of this page: https://verifymcp.io/servers/com-moltlinestudio-optimize/optimize