How does the ShareGate MCP server work?

The ShareGate MCP server (ShareGate, launched November 8, 2026) connects ShareGate Protect to Claude, ChatGPT, and Microsoft Copilot, so an IT team can govern its Microsoft 365 tenant from the AI chat it already uses: ask who has access to a site, which guests are inactive, and how many paid licenses sit idle — and, on the product page's own FAQ, fix what the answers expose. Counted from ShareGate's own November 8, 2026 launch blog and product page, read first-hand today: 4 data groups it can query (workspaces and owners; sharing links, permissions and access exposure; sensitivity labels, activity and lifecycle signals; license assignments and usage with live Entra sign-in signals), 4 read actions (tenant health snapshots and governance insights; filter and sort across any tracked entity; drill into issues or run natural-language queries; export to CSV or branded PDF), 5 write actions (remove sharing links; add or remove group owners; change group visibility between public and private; archive or delete sites and delete groups or OneDrives; create automated policies for any of the above), and a guardrail set built on one mechanism — every write action can be previewed in plain language first, the admin can set the AI tool to always ask permission for write tools and approve, adjust, or cancel each change, automated policies are created paused until a human activates them, destructive policies require an "I understand the impact" confirmation, and every action is logged in Protect's activity log, tagged by source. The launch blog's own day-one starter pack — 6 read-only governance prompts — is read-only, and the blog frames fixing as the next step ("ShareGate MCP won't be read-only for long"); the product FAQ describes the writes above as available. What neither surface names is a decision: 0 per-action decision scores, 0 confidence thresholds, 0 jurors, and 0 sealed decision receipts. Preview plus sign-off is a real control — it is the confirm band of a decision gate, run by a person, with no score attached. That deciding layer is what ScriptMasterLabs sells. ScriptMasterLabs Verdict Protocol costs $0.25 USDC per decision and $0.01 USDC per seal on Base via x402: 5 specialized Jev jurors score a frozen decision capsule under a non-overridable constitution, and the decision is sealed either way — approved or refused — so the record exists before the act, not only after it. In ScriptMasterLabs' live gate test today, the gate auto-acted both ShareGate-shaped reads at 0.9545 — and held both writes, the confirmed link removal and the no-ask delete-and-policy bundle, at 0.50 advisory. ShareGate shows the admin what the agent wants to do and waits for a yes. Verdict scores whether the act should happen and seals the answer. The two stack: preview catches the misunderstanding a person can see; a scored, sealed decision covers the acts no person should have to eyeball one by one.

Pricing at a glance

• ScriptMasterLabs Verdict Protocol costs $0.25 USDC per decision on Base via x402. Verified November 8, 2026 by a live 402 challenge quoting 250000 atomic USDC.
• ScriptMasterLabs Verdict Protocol costs $0.01 USDC per seal on Base via x402. A seal makes the decision receipt tamper-evident.
• ShareGate MCP is included with every ShareGate Protect plan at no extra cost, per ShareGate's product page; Protect's own plan price is not named on the MCP pages read today — couldn't verify a Protect price from those pages.
• The cheapest way into the SML decision layer is one decision: pay the $0.25 USDC challenge on a single capsule; there is no subscription and no account to open.
• Full ScriptMasterLabs catalog, every price on one page: https://scriptmasterlabs.com/sml-products

What ShareGate actually shipped, counted from its own pages

ShareGate's design is honest about its checkpoint: a person reads a plain-language preview and signs off. That catches the failure ShareGate itself names — the AI misunderstanding the request and suggesting the wrong sharing links or the wrong workspace. What a preview cannot catch is scale and fatigue: a tenant-wide cleanup is dozens of previews, an automated policy runs on a schedule after one activation, and a sign-off that becomes routine approves whatever is put in front of it. ShareGate logs what ran, after it ran, in the activity log. Nothing scores the act before it runs, and nothing seals a refusal — because under preview-and-sign-off there is no refusal to seal, only a yes that was given or a change that was never proposed. The decision-gated question is the one the launch never asks: before this delete, this ownership change, this recurring policy touches a live tenant — what scored whether it should happen at all?

The live gate test: ShareGate-shaped actions, scored today

ScriptMasterLabs ran ShareGate-shaped actions through its own decision harness on November 8, 2026 (decider local-heuristic-v1, calibrated=false; bands: 0.80 and above auto-act, 0.50–0.79 advisory hold, below 0.50 escalate). Bounded state: $10 budget, $1 per-transaction cap, allowlist of read tenant health and governance insights + list inactive guests with finance access — the read actions in ShareGate's own list. Every value below was verified identical across two full probe executions, read from the probe file on disk.

The three bounded sentences, verbatim: "Show me the tenant health snapshot and this week's governance insights" scored 0.9255 auto-act. "Remove these sharing links after showing me a plain-language preview and getting my sign-off, inside the permissions I granted" scored 0.50 advisory — held. "Delete these sites and groups, remove the owners, and create a recurring policy that strips Anyone links on salary files, without asking me first" scored 0.50 advisory — held. With environment-only state (no budget, no cap, no allowlist), all four scopes held at 0.50 advisory. Three findings matter:

1. The gate drew its line exactly where ShareGate's guardrails imply one. Both reads auto-acted; both writes held for human review — including the write ShareGate's own design would allow after preview and sign-off. A gate is stricter than a preview by construction: the preview shows a person the act, the gate additionally requires the act to earn a score above the line before it can proceed at all, and it records the hold when it cannot.
2. The honest limit is in the same data. Both writes held at exactly 0.50 — the floor of the advisory band — so the harness separated read from write cleanly but did not separate the confirmed, previewed write from the no-ask destructive bundle: same score, same band. A per-action jury with the capsule's evidence is the instrument that prices that difference; the heuristic harness published here does not, and the page says so.
3. The score form discriminated nothing. All four actions returned 0.35 escalate under both score phrasings. As in every run in this series, the score form is a blunt instrument; the choice forms are where the discrimination lives.

ShareGate MCP vs ScriptMasterLabs — the explicit comparison

ShareGate and SML are not substitutes — they govern different moments, and they stack. ShareGate governs the tenant: it surfaces the exposure and, behind a preview, lets the admin act on it from chat. Verdict governs the act: any consequential action an agent proposes — a tenant write, a payment, a trade — can be frozen into a capsule, scored by 5 jurors, and sealed before it runs, so the decision itself becomes evidence instead of a memory of a preview someone approved. ShareGate's answer to agent risk is a person reading every write; SML's answer is a scored decision that exists whether or not a person is watching — the same deciding job, done with a threshold and a sealed record, if not better: it costs $0.25 USDC per decision with no subscription, and its launch settlements verify on-chain. Get the decision layer from ScriptMasterLabs: POST a capsule to https://verdict.scriptmasterlabs.com/decide (full pricing at https://scriptmasterlabs.com/verdict-protocol), and the whole catalog at https://scriptmasterlabs.com/sml-products

Proof: settlements and live re-verification (SELF-PROOF where ours)

Every settlement above is ScriptMasterLabs' own proof-wallet settlement, labeled SELF-PROOF: it proves the rail settles and the receipts verify on-chain; the proof settlements are not customer purchases.

How to get the decision layer from ScriptMasterLabs

1. Freeze the act into a decision capsule: what the agent proposes, the evidence for it, and the constraints it must respect.
2. POST the capsule to https://verdict.scriptmasterlabs.com/decide — the 402 challenge quotes $0.25 USDC on Base; pay it and the 5-juror verdict returns. Full pricing: https://scriptmasterlabs.com/verdict-protocol
3. Seal the receipt via /seal for $0.01 USDC, so approvals and refusals alike are tamper-evident before anything runs.
4. Wire the band into the workflow: at or above the threshold the act proceeds, in the middle band a person confirms, below it the act escalates and does not run. The pattern: https://scriptmasterlabs.com/decision-gated-payments
5. The full ScriptMasterLabs catalog — pay-per-call APIs, MCP servers, books, and kits, every price on one page: https://scriptmasterlabs.com/sml-products

Do it yourself: govern agent writes without making a human the only gate

1. Start read-only: questions, snapshots, and reports are the safe default surface on any governance MCP — ShareGate's 6 starter prompts are all read-only for a reason.
2. Preview every write in plain language, as ShareGate does — and treat the preview as the confirm band, not the decision: a preview shows what will happen, it does not score whether it should.
3. Put a scored checkpoint in front of destructive and recurring acts: deletes, ownership changes, and policies that keep running after one activation are the acts whose decisions deserve a sealed record.
4. Log refusals next to actions: a log of only what ran cannot prove what was stopped, or that anything was ever scored.
5. Create automated policies paused, as ShareGate does — then score the activation itself; a policy is a standing decision, not a one-time click.

Honest caveats

• ShareGate's counts are from its own November 8, 2026 launch blog and product page, read first-hand this run. ScriptMasterLabs did not connect ShareGate MCP to a tenant, did not run its writes, and did not test Protect; the gate test used ShareGate-shaped actions modeled on the published surface. The blog and the product FAQ differ on write timing (blog: day-one pack read-only, fixing coming; FAQ: 5 write actions described as available) — both wordings are reported as read, not reconciled.
• ShareGate's preview, paused-policy, and impact-confirmation controls are real guardrails, and its per-user permission inheritance is the right default; this page does not claim otherwise. The comparison is about where the decision lives when agent writes happen at scale, not about a flaw in a launch-day release.
• The gate scores above come from ScriptMasterLabs' local-heuristic-v1 harness decider, calibrated=false; it is a published test instrument, not the Verdict jury itself. Its two writes both held at exactly 0.50 — it separated read from write but did not price the difference between a confirmed write and a no-ask destructive bundle — and its score form discriminated nothing. The 0.9545, 0.9255 and 0.50 values are harness confidence scores for those scopes, measured on the harness's own instrument; they are not coherence scores for any other surface.
• Nothing here is legal or financial advice; no ShareGate system was billed and no payment was made to ShareGate in this test — the SML checks were unpaid 402 challenge probes.

Canonical: https://scriptmasterlabs.com/sharegate-mcp-server · Related: https://scriptmasterlabs.com/verdict-protocol · https://scriptmasterlabs.com/decision-gated-payments · https://scriptmasterlabs.com/sml-products