# unisafe LP insight (remote · unisafe.envelop.is)

Uniswap v4 LP managers for agents: history, strategies, Watcher, owner txs, create for USDC.

- Trust score: 73/100 (medium)
- Change this week: 0
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

> **Recent critical change**: Authorization (2026-11-12). See the changelog below before you install this server.

## Components

- remote · `unisafe.envelop.is`: 73/100 (this document), [markdown](https://verifymcp.io/servers/is-envelop-unisafe-insight/unisafe.md), [page](https://verifymcp.io/servers/is-envelop-unisafe-insight/unisafe)

## Channel facts

- Endpoint: `https://unisafe.envelop.is/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.8.2`

## 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-11-21.

- **Endpoint Security**: 46/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (watch_subscribe).
  - HTTPS enforcement could not be verified: the plaintext port answered with HTTP 404, which proves neither a plaintext path nor enforcement.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 77/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 4794 tokens (~159/item across 30 items; 23 tools + 7 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 100/100
  - No destabilizing schema changes in the last 30 days.
- **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.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "prepare_withdraw" implies "withdraw" and declares readOnlyHint instead, contradicting what its own name says it does.
  - An AI judge read all 25 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 unisafe LP insight MCP server?

unisafe LP insight is a hosted endpoint at https://unisafe.envelop.is/mcp, 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 is-envelop-unisafe-insight 'https://unisafe.envelop.is/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "is-envelop-unisafe-insight": {
      "url": "https://unisafe.envelop.is/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "is-envelop-unisafe-insight": {
      "type": "http",
      "url": "https://unisafe.envelop.is/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.is-envelop-unisafe-insight]
url = "https://unisafe.envelop.is/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "is-envelop-unisafe-insight": {
      "type": "remote",
      "url": "https://unisafe.envelop.is/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add is-envelop-unisafe-insight --url 'https://unisafe.envelop.is/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  is-envelop-unisafe-insight:
    url: "https://unisafe.envelop.is/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "is-envelop-unisafe-insight": {
      "Transport": "http",
      "Url": "https://unisafe.envelop.is/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add is-envelop-unisafe-insight -t streamable-http -u 'https://unisafe.envelop.is/mcp'
```

### Other

```json
{
  "mcpServers": {
    "is-envelop-unisafe-insight": {
      "type": "http",
      "url": "https://unisafe.envelop.is/mcp"
    }
  }
}
```

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-11-15 (score 73, 0)

- [security] The server rewrote its instructions, which are the text every model session reads
- [functional] Server version: 0.8.1 → 0.8.2

### 2026-11-14 (score 73, 0)

- [security] The server rewrote its instructions, which are the text every model session reads
- [security] Tool “prepare_create_manager” rewrote its description, which is the text the model reads
- [security] Tool “rank_pools” rewrote its description, which is the text the model reads
- [security] Tool “watch_subscribe” rewrote its description, which is the text the model reads
- [security] Tool “watch_terms” rewrote its description, which is the text the model reads
- [security] Tool “create_manager” is now declared destructive
- [security] Tool “watch_subscribe” is now declared destructive
- [functional] Server version: 0.8.0 → 0.8.1
- [cosmetic] “prepare_create_manager” reworded the description of “strategy”
- [cosmetic] “quote_create_manager” reworded the description of “strategy”

### 2026-11-13 (score 73, +1)

- [security] Stability: 0.97 → pass
- [security] The server rewrote its instructions, which are the text every model session reads
- [functional regression] Schema quality: 3903 → 4729
- [functional] Server version: 0.7.0 → 0.8.0
- [functional] New tool “create_manager”
- [functional] New tool “get_operation”
- [functional] New tool “quote_create_manager”
- [functional] New tool “relayer_status”

### 2026-11-12 (score 72, −9)

- [critical regression] Authorization: partial → fail
- [security] The server rewrote its instructions, which are the text every model session reads
- [security] New tool “watch_cancel”, which the server declares destructive
- [functional regression] Schema quality: pass → fail
- [functional] Destructive annotations: pass → 0
- [functional] Server version: 0.6.0 → 0.7.0
- [functional] New tool “get_strategy”
- [functional] New tool “list_strategies”
- [functional] New tool “prepare_create_manager”
- [functional] New tool “prepare_deposit”
- [functional] New tool “prepare_set_operator”
- [functional] New tool “prepare_withdraw”
- [functional] New tool “watch_bind”
- [functional] New tool “watch_prepare”
- [functional] New tool “watch_status”
- [functional] New tool “watch_strategy”
- [functional] New tool “watch_subscribe”
- [functional] New tool “watch_terms”

### 2026-11-10 (score 81, +1)

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

### 2026-11-08 (score 80, +1)

- [security] The server rewrote its instructions, which are the text every model session reads

### 2026-11-06 (score 79, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-11-04 (score 78, 0)

- [security] Tool “get_prices” rewrote its description, which is the text the model reads

## MCP tools (23)

### `get_position_history` (~114 tokens)

Position history

Every position of a manager, or one position by salt: when it opened, its pool, its lifetime fees and its events. Answered from the index, falling back to the Envelop history API and then to a log scan; the answer says which one served it and how current that source is.

Input parameters:

- `chainId` (integer, required): EVM chain id, e.g. 42161 for Arbitrum One
- `manager` (string, required): Manager NFT contract address
- `salt` (string): Position key

### `list_managers` (~112 tokens)

Managers a wallet owns

Every unisafe LP manager (Stable and Volatile) the wallet currently owns, on every chain the Envelop oracle indexes, with the app link for each — the way in when you know the owner and not the managers. Other Envelop wNFTs the wallet holds are left out. An empty list means it owns none; when the oracle cannot answer this is an error, not an empty list.

Input parameters:

- `owner` (string, required): Wallet address that owns the managers (an EOA or a smart account)

### `list_operators` (~95 tokens)

Operators of a manager

Addresses currently authorised to rebalance a manager's positions. They can never withdraw — that is enforced by the contract. On the scan path the answer may be `partial`, which means a revoked operator could still be listed; from the index it never is.

Input parameters:

- `chainId` (integer, required): EVM chain id, e.g. 42161 for Arbitrum One
- `manager` (string, required): Manager NFT contract address

### `rank_pools` (~170 tokens)

Rank a manager's pools by what they are paying

Fee APR over the last 24 hours for each pool this manager is configured with, best first — the Uniswap gateway's figure, or the subgraph's last complete day for a pool the gateway does not list (`aprSource`). Only the manager's own pools are candidates: a move can target a pool only if the owner fixed it into the set when the manager was created. Pools that could not be scored are listed separately with the reason — a pool missing from the ranking is not a bad pool. `gatewayStale` / `gatewayDataAt` say when the gateway's figures are older than they should be.

Input parameters:

- `chainId` (integer, required): EVM chain id, e.g. 42161 for Arbitrum One
- `manager` (string, required): Manager NFT contract address

### `suggest_move` (~227 tokens)

Suggest moving a position to a better-paying pool

Compares the position's current pool against the rest of the manager's set and, when the gap is worth it, returns the numbers for a move: destination pool, ticks, and how much liquidity. A pool sharing no currency with the position is suggested only when the manager (v2.2) can bridge to it through another of its own pools; the answer then names that bridge. It returns NUMBERS, never calldata — pass them to the local envelop-mcp-lp server's propose_move, which re-derives each one against chain state and puts it through the policy and the price-oracle guard before anything is signed. The full ranking and the caveats come back with every answer so the suggestion can be disagreed with.

Input parameters:

- `chainId` (integer, required): EVM chain id, e.g. 42161 for Arbitrum One
- `manager` (string, required): Manager NFT contract address
- `minGainPct` (number): Minimum APR advantage, in percentage points, before moving is suggested. Default 1.
- `salt` (string, required): Position key

### `get_prices` (~222 tokens)

USD prices and gas cost

What things are worth on a chain: token USD prices (the Uniswap gateway's map; the native token, address zero, priced as the chain's WETH), the gas price, and the typical USD cost of each operator operation at it (recenter, move, allocate, reinvest, claim). For weighing whether an operation pays before simulating it — a simulation's own gas estimate is better once there is one. `tokens` narrows the map and lists the ones it cannot price; `derived` names known stablecoins the gateway left unpriced, priced from a stablecoin they are pooled with; `stale` marks a copy served while a refresh fails; `gatewayStale: true` means the gateway's last answer (`gatewayDataAt`) is over 3 hours old, so the prices are that old answer's, not current.

Input parameters:

- `chainId` (integer, required): EVM chain id, e.g. 42161 for Arbitrum One
- `tokens` (array): Token addresses to price; all known when omitted

### `list_strategies` (~102 tokens)

Think Tank strategies

The strategies the Envelop Think Tank factory has released (the shelf on unisafe's landing and /strategies): id, title, chain, product (stable/volatile), pools, the paper run's live numbers and the backtest, and `blocked` — null when it may be started now, otherwise why not. `fresh` says how old the shelf is. Free, read-only. Next: get_strategy(id) for one in full.

### `get_strategy` (~132 tokens)

One Think Tank strategy in full

One strategy by id (think-tank/<slug>) or slug: the shelf entry, its playbook, its `actions`, its agent rules (strategy.json + STRATEGY.md) — returned only when they hash to the sha256 the shelf publishes, otherwise `rules.ok: false` with the reason — and its manager template (the pools a manager for it is created with). `next` says how to run it: prepare_create_manager with this strategy, then deposit and an operator, and watch_strategy for the Watcher.

Input parameters:

- `id` (string, required): think-tank/<slug> or <slug>

### `watch_terms` (~92 tokens)

Watcher: price and terms

The Watcher (Сторож) follows a manager's positions against a Think Tank strategy and says when the strategy calls for an action (Telegram to the owner; in `agent` mode it audits the owner's agent). Price per manager per period in USDC (`priceUsdc` 0 = free beta), `periodDays`, how payment is taken (x402, in USDC) and the Telegram bot.

### `watch_strategy` (~89 tokens)

Watcher: can it follow this strategy?

Whether the Watcher can follow a strategy, and how: `action` recenter (it says when to recenter) or notify (it says the position is out of range), and the wait before it speaks. `ok: false` with a reason — do not ask the owner to sign or pay for it.

Input parameters:

- `id` (string, required): think-tank/<slug> or <slug>

### `watch_status` (~98 tokens)

Watcher: a manager's watches

A manager's watches (strategy, positions, mode, status, paid `until`) and the Watcher's current advice per position (`due` = act now, `waiting` = out of range, inside the strategy's wait), plus the owner's shared strategy bindings. Public.

Input parameters:

- `chainId` (integer, required): EVM chain id, e.g. 42161 for Arbitrum One
- `manager` (string, required): Manager NFT contract address

### `watch_prepare` (~268 tokens)

Watcher: typed data for the owner to sign

Step 1 of starting (Watch), stopping (Unwatch) or sharing (Bind) a watch. Returns EIP-712 `typedData` for the manager's OWNER (ownerOf(1) — `signer` names them) to sign with their own wallet, valid 10 minutes, and `next`: the tool to pass {chainId, message, signature} to — watch_subscribe, watch_cancel or watch_bind. This server signs nothing and an agent's own key is not the owner's unless it owns the manager.

Input parameters:

- `chainId` (integer, required): The manager's chain
- `kind` (string, required): Watch = start or update watching (may cost); Unwatch = stop; Bind = share which positions follow a strategy (free)
- `manager` (string, required): Manager NFT contract address
- `mode` (string): Watch only. owner (default) — the Watcher tells the owner when to act; agent — the owner's agent acts and the Watcher audits it
- `positions` (array): Position salts (get_position_history). Watch: 1–32; Bind: 0–32 (none forgets the binding); Unwatch: none
- `strategy` (string, required): Strategy id, think-tank/<slug> (list_strategies)

### `watch_subscribe` (~210 tokens)

Watcher: start or update a watch (may be paid)

Step 2 of a Watch: the owner-signed message from watch_prepare. Free inside the manager's paid period or during the beta; otherwise one period costs the `priceUsdc` watch_terms returns, paid by x402. Without payment the result is an error whose structuredContent is the x402 PaymentRequired: an x402 MCP client retries with the payment in _meta["x402/payment"]; any other client POSTs `payBody` to `payUrl` and pays its HTTP 402 with an x402 wallet. `extend: true` buys one more period now. Returns the watch and a Telegram link for the owner.

Input parameters:

- `chainId` (integer, required): The manager's chain (the typed data domain's chainId)
- `extend` (boolean): Pay for one more period even inside a paid one
- `message` (object, required): `typedData.message` from watch_prepare, unchanged
- `signature` (string, required): The owner's EIP-712 signature over that typed data

### `watch_cancel` (~98 tokens)

Watcher: stop a watch

Stop watching a manager for a strategy: the owner-signed `Unwatch` message from watch_prepare(kind: Unwatch). A paid period is not refunded and stays usable.

Input parameters:

- `chainId` (integer, required): The manager's chain (the typed data domain's chainId)
- `message` (object, required): `typedData.message` from watch_prepare, unchanged
- `signature` (string, required): The owner's EIP-712 signature over that typed data

### `watch_bind` (~111 tokens)

Watcher: share which positions follow a strategy

Free. The owner-signed `Bind` from watch_prepare(kind: Bind): which positions of the manager follow which strategy, so every browser (and agent) sees it. No positions forgets the binding. No watching, no payment.

Input parameters:

- `chainId` (integer, required): The manager's chain (the typed data domain's chainId)
- `message` (object, required): `typedData.message` from watch_prepare, unchanged
- `signature` (string, required): The owner's EIP-712 signature over that typed data

### `prepare_set_operator` (~259 tokens)

Owner tx: allow or revoke an operator

Returns an UNSIGNED transaction {chainId, to, data, value} plus `simulation` — an eth_call of exactly it from `from` (ok, or the revert decoded by name) — `warnings` and `next`. This server signs nothing: the sender signs and sends it with their own wallet and pays the gas. Owner only. An operator may rebalance (allocate, recenter, move, claim, reinvest) inside the manager's pools and can never withdraw. To hand a manager to an operator agent, allow the address of the local envelop-mcp-lp server's operator wallet.

Input parameters:

- `allowed` (boolean, required): true adds the operator, false revokes it
- `chainId` (integer, required): EVM chain id: 8453 Base, 42161 Arbitrum, 130 Unichain (1 = Ethereum mainnet, your gas)
- `from` (string, required): The address that will send the transaction — the manager owner (ownerOf(1)). The simulation runs from it.
- `manager` (string, required): Manager NFT contract address
- `operator` (string, required): The operator address to allow or revoke (for an agent: the operator wallet of the local envelop-mcp-lp server)

### `prepare_deposit` (~271 tokens)

Owner tx: deposit into a manager

Returns an UNSIGNED transaction {chainId, to, data, value} plus `simulation` — an eth_call of exactly it from `from` (ok, or the revert decoded by name) — `warnings` and `next`. This server signs nothing: the sender signs and sends it with their own wallet and pays the gas. A plain transfer to the manager (an ERC-20 `transfer`, or a native value send) — managers do not pull, so there is no approve. Amount in raw base units. The funds land idle; an operator or the owner then allocates them into positions.

Input parameters:

- `amount` (string, required): Raw base units as a decimal string (USDC 1.5 = "1500000"), never a decimal
- `chainId` (integer, required): EVM chain id: 8453 Base, 42161 Arbitrum, 130 Unichain (1 = Ethereum mainnet, your gas)
- `from` (string, required): The wallet the funds come from — anyone may fund a manager, only the owner may take funds out
- `manager` (string, required): Manager NFT contract address
- `token` (string, required): Token to deposit; 0x0000000000000000000000000000000000000000 for the native coin

### `prepare_withdraw` (~240 tokens)

Owner tx: withdraw idle funds

Returns an UNSIGNED transaction {chainId, to, data, value} plus `simulation` — an eth_call of exactly it from `from` (ok, or the revert decoded by name) — `warnings` and `next`. This server signs nothing: the sender signs and sends it with their own wallet and pays the gas. Owner only. Moves idle balance (not in a position) out of the manager to `recipient`, one row per token, through the owner escape hatch `executeEncodedTxBatch`. Liquidity inside positions is withdrawn in the app's Withdraw page, which plans it against live prices.

Input parameters:

- `chainId` (integer, required): EVM chain id: 8453 Base, 42161 Arbitrum, 130 Unichain (1 = Ethereum mainnet, your gas)
- `from` (string, required): The address that will send the transaction — the manager owner (ownerOf(1)). The simulation runs from it.
- `items` (array, required): Idle balances to take out, one row per token
- `manager` (string, required): Manager NFT contract address
- `recipient` (string, required): Where the funds go

### `prepare_create_manager` (~422 tokens)

Tx: create a manager

Returns an UNSIGNED transaction {chainId, to, data, value} plus `simulation` — an eth_call of exactly it from `from` (ok, or the revert decoded by name) — `warnings` and `next`. This server signs nothing: the sender signs and sends it with their own wallet and pays the gas. LPManagerFactory.createManagerNondeterministic on Base, Arbitrum, Unichain or Ethereum; `from` pays its gas. To create without gas of your own on Base, Arbitrum or Unichain, use quote_create_manager → create_manager instead (Envelop's relayer, paid in USDC; mainnet has no relayer). Anyone may send it; the manager NFT goes to `owner`. Either `strategy` (a Think Tank id: its template fixes product and pools) or `product` + `pools`. The pool set is fixed forever; the chain's price oracle is wired in. The new address is the `proxy` of the factory's EnvelopV2Deployment event in the receipt.

Input parameters:

- `chainId` (integer, required): EVM chain id: 8453 Base, 42161 Arbitrum, 130 Unichain (1 = Ethereum mainnet, your gas)
- `from` (string, required): Who sends (and pays gas for) the transaction; any address — the factory is permissionless and the NFT still goes to `owner`
- `name` (string): Display name, up to 31 UTF-8 bytes
- `owner` (string, required): Who receives the manager NFT. Explicit on purpose: a smart account on one chain may not exist on another
- `pools` (array): Without `strategy`: the manager's pool set, 1–32, fixed forever at creation
- `product` (string): Without `strategy`: which manager
- `strategy` (string): A Think Tank strategy id (think-tank/<slug>) — its manager template supplies product and pools; chainId must be the strategy's chain

### `quote_create_manager` (~370 tokens)

Quote: create a manager, gas paid by Envelop's relayer

Free. Step 1 of having a manager created WITHOUT gas of your own on Base, Arbitrum or Unichain: Envelop's relayer sends LPManagerFactory.createManagerNondeterministic and the manager NFT goes to `owner` (explicit — never assumed to be the payer). Either `strategy` (a Think Tank id) or `product` + `pools`. Returns quoteId, the price in USDC (gas × 1.2 × fee + L1 fee, × 1.5, at least $0.10 — usually exactly $0.10), the networks to pay on (USDC on Base or Arbitrum), expiresAt (≈2 minutes), the relayer's address, balance and how many creations it has gas for on that chain, and payUrl. Refused, with nothing to pay, when the creation would revert or the relayer is out of gas. Next: create_manager(quoteId).

Input parameters:

- `chainId` (integer, required): Where the manager is created: 8453 Base, 42161 Arbitrum, 130 Unichain (Ethereum mainnet: prepare_create_manager, your own gas)
- `name` (string): Display name, up to 31 UTF-8 bytes
- `owner` (string, required): Who receives the manager NFT. Explicit on purpose: a smart account on one chain may not exist on another
- `pools` (array): Without `strategy`: the manager's pool set, 1–32, fixed forever at creation
- `product` (string): Without `strategy`: which manager
- `strategy` (string): A Think Tank strategy id (think-tank/<slug>) — its manager template supplies product and pools; chainId must be the strategy's chain

### `create_manager` (~179 tokens)

Create a manager (paid, x402)

Step 2: pay the quote and have the relayer create the manager. Costs the quoted USDC (usually $0.10, never above what quote_create_manager said without asking again). Without payment the result is an error whose structuredContent is the x402 PaymentRequired: an x402 MCP client retries with the payment in _meta["x402/payment"]; any other client POSTs to `payUrl` and pays its HTTP 402 with an x402 wallet. If gas rose since the quote a new PaymentRequired comes back and nothing is charged. One quote creates one manager; calling again returns the operation. Returns the operation: status (sent/done/failed), the manager address (from the factory's EnvelopV2Deployment event) once mined, the transaction.

Input parameters:

- `quoteId` (string, required): quoteId from quote_create_manager

### `get_operation` (~71 tokens)

A relayed creation's status

Free. The state of quoteId: quoted / expired before payment; paid, sent, done (with `manager`, its app link and the transaction) or failed (with the reason — a creation that fails after payment is refunded by hand).

Input parameters:

- `quoteId` (string, required): quoteId from quote_create_manager

### `relayer_status` (~93 tokens)

The relayer: address, balance, capacity

Free. Envelop's relayer address and, per chain (Base, Arbitrum, Unichain): its ETH balance, the typical cost of one creation in wei and USD, how many creations it has gas for (`capacity`) and `status` — ok, low (< 5), empty, paused or unavailable. Anyone may top the relayer up; it is the same snapshot the site footer shows.

## Diagnostics

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

## Score history

- 2026-11-21: 73
- 2026-11-20: 73
- 2026-11-19: 73
- 2026-11-18: 73
- 2026-11-17: 73
- 2026-11-16: 73
- 2026-11-15: 73
- 2026-11-14: 73
- 2026-11-13: 73
- 2026-11-12: 72
- 2026-11-11: 81
- 2026-11-10: 81
- 2026-11-09: 80
- 2026-11-08: 80
- 2026-11-07: 79
- 2026-11-06: 79
- 2026-11-05: 78
- 2026-11-04: 78
- 2026-11-03: 78
- 2026-11-02: 77
- 2026-11-01: 77
- 2026-10-31: 76
- 2026-10-30: 76
- 2026-10-29: 75
- 2026-10-28: 75
- 2026-10-27: 74
- 2026-10-26: 74
- 2026-10-25: 73
- 2026-10-24: 73
- 2026-10-23: 72

## Common questions

### What is the unisafe LP insight MCP server?

unisafe LP insight is an MCP server listed in the public MCP registry as is.envelop.unisafe/insight. Uniswap v4 LP managers for agents: history, strategies, Watcher, owner txs, create for USDC. This page covers its hosted endpoint (https://unisafe.envelop.is/mcp).

### Is the unisafe LP insight MCP server safe to use?

unisafe LP insight scores 73 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 unisafe LP insight MCP server expose?

unisafe LP insight exposes 23 tools: get_position_history, list_managers, list_operators, rank_pools, suggest_move, and 18 more. Their descriptions and schemas cost roughly 4,045 tokens of context every time the server is loaded.

### Does the unisafe LP insight MCP server require authentication?

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

### Is the unisafe LP insight MCP server still maintained?

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

### What did VerifyMCP test on the unisafe LP insight MCP server?

VerifyMCP ran 12 checks on unisafe LP insight, covering TLS certificate, Authorization, HSTS header, DNSSEC and 8 more. One item could not be completed, a gap on our side rather than a finding about unisafe LP insight: HTTPS. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- Remote endpoint: https://unisafe.envelop.is/mcp
- Website: https://unisafe.envelop.is/agents
- Changelog RSS feed: https://verifymcp.io/servers/is-envelop-unisafe-insight/unisafe.xml
- Changelog JSON feed: https://verifymcp.io/servers/is-envelop-unisafe-insight/unisafe/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/is-envelop-unisafe-insight/unisafe.json
- HTML version of this page: https://verifymcp.io/servers/is-envelop-unisafe-insight/unisafe
