# GTM Otto (remote · agent.gtmotto.com)

Self-driving LinkedIn prospecting: it sources, warms and invites daily. You approve every message.

- Trust score: 75/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-23

## Components

- remote · `agent.gtmotto.com`: 75/100 (this document), [markdown](https://verifymcp.io/servers/com-gtmotto-linkedin/agent.md), [page](https://verifymcp.io/servers/com-gtmotto-linkedin/agent)

## Channel facts

- Endpoint: `https://agent.gtmotto.com/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.2.1`

## 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-23.

- **Endpoint Security**: 81/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation is enforced on tool calls, advertised via RFC 9728 protected-resource metadata. Discovery is public, which costs nothing: no tool can be invoked without a token.
  - HTTPS enforcement could not be verified: the plaintext port answered with HTTP 406, 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.
  - The authorisation server supports Client ID Metadata Documents, the current MCP client-registration mechanism.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 80/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 4949 tokens (~224/item across 22 items; 21 tools + 1 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 3/100
  - Stability observed for 1 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 95/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 84% 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 21 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 23 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 GTM Otto MCP server?

GTM Otto is a hosted endpoint at https://agent.gtmotto.com/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 com-gtmotto-linkedin 'https://agent.gtmotto.com/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "com-gtmotto-linkedin": {
      "url": "https://agent.gtmotto.com/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-gtmotto-linkedin": {
      "type": "http",
      "url": "https://agent.gtmotto.com/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.com-gtmotto-linkedin]
url = "https://agent.gtmotto.com/mcp"
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add com-gtmotto-linkedin --url 'https://agent.gtmotto.com/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  com-gtmotto-linkedin:
    url: "https://agent.gtmotto.com/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "com-gtmotto-linkedin": {
      "Transport": "http",
      "Url": "https://agent.gtmotto.com/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-gtmotto-linkedin -t streamable-http -u 'https://agent.gtmotto.com/mcp'
```

### Other

```json
{
  "mcpServers": {
    "com-gtmotto-linkedin": {
      "type": "http",
      "url": "https://agent.gtmotto.com/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-09-23 (score 75, +1)

- [functional improvement] Stability: unverified → 0.03

### 2026-09-22 (score 74)

First indexed and scored.

## MCP tools (21)

### `gtm_whoami` (~84 tokens)

Who am I, and what next

Who this key belongs to, and what the workspace may do: org name, plan, subscription status, how many products and plays exist, and the LEAD METER (leads added this calendar month, the plan's cap, and what is left). Start here — the remaining lead allowance is the one number that changes what is worth proposing. Read-only.

### `gtm_list_plays` (~74 tokens)

List plays

Every play in the workspace with enough context to route on: which product it sells, whether it is active or paused, whether a LinkedIn seat is actually connected (`seatConnected: false` means the play cannot act, whatever its status says), and how its leads are spread across the pipeline stages. Read-only.

### `gtm_show_play` (~125 tokens)

Show a play

ONE play in full — everything needed to judge it or copy it into a better one: goal and voice, the account's daily cap and working hours (shared by every play on the seat), the ICP facets, the five sourcing lanes with their config and last run, the autonomy ladder (which rungs run alone and which wait for a human), the LinkedIn seat, and today's used/cap for the seat plus this play's share. Read-only. Pass a playId from gtm_list_plays.

Input parameters:

- `playId` (string, required): The play to inspect.

### `gtm_play_stats` (~102 tokens)

Play stats

The play's Stats screen: the pipeline (leads sourced → warmed → invited → new connections → conversations started) over four windows — all time, last 30 days, last 7 days, last 24 hours — each windowed count paired with the window before it as a percentage delta. 'Conversations started' counts real replies, never the openers Otto sent. Read-only.

Input parameters:

- `playId` (string, required): The play to report on.

### `gtm_linkedin_status` (~122 tokens)

LinkedIn seat status

The play's LinkedIn seat and today's headroom against the LinkedIn limits. States: `no_seat` (nothing connected — the play cannot act), `seat_broken` (the account was disconnected or deleted; the queue is parked until a human reconnects), `pending`, `classic`, or `sales_navigator` (which search backend the ICP compiles to). Read-only. Connecting a seat is a browser flow — link the human to the cockpit for it.

Input parameters:

- `playId` (string, required): The play whose seat to check.

### `gtm_estimate_icp` (~167 tokens)

Estimate ICP size

How big an audience a CANDIDATE ICP would reach — '≈ N companies match' — before committing to it. Writes nothing: no play, no ICP row, no cache. Use it to iterate (propose facets → see 40 → widen the locations → see 900 → then create the play). Returns null when the data provider has no key configured, which is not an error. Needs a write-scoped key only because it rides the gateway's action channel.

Input parameters:

- `industries` (array): e.g. ['SaaS', 'Fintech']
- `locations` (array): e.g. ['France', 'Benelux']
- `sizes` (array): Headcount bands, e.g. ['11-50', '51-200']

### `gtm_create_play` (~494 tokens)

Create a play (draft)

Create a fully-configured play in one call: the product (an existing productId, or a websiteUrl which seeds one and kicks its research), the play itself, the ICP facets, which sourcing lanes are on, the autonomy ladder and the caps. Three rules are enforced server-side and cannot be talked around. (1) `activate` DEFAULTS TO FALSE — turning a play on spends the month's lead quota and takes real actions from the user's own LinkedIn account, so hand the human the returned cockpit link and let them press go. (2) A play with no live LinkedIn seat stays a draft whatever you pass. (3) Autonomy rules are written ONLY for the steps you name; every step you omit keeps gtmotto's own default, which is 'wait for a human'. Lanes that need their own seeds (post_engagers, competitor_posts, account_list) are refused if switched on without them.

Input parameters:

- `activate` (boolean): Default false. True only starts it if a live seat is already connected.
- `autonomy` (array): Only the rungs you name are written. Omitted rungs wait for a human.
- `dailyCap` (number): Actions per day, all kinds summed. Defaults to the seat's full LinkedIn allowance (145), so pass it only to throttle. ACCOUNT-level: sets the ceiling every play on this LinkedIn account shares, not a…
- `goal` (string): What a conversation from this play should reach.
- `icp` (object): The audience, as plain strings — the same seven fields the cockpit's ICP screen fills. gtmotto compiles them into a LinkedIn search and normalises odd labels itself ('Swiss' → Switzerland, 'Fintech'…
- `name` (string, required): The play's name.
- `productId` (string): An existing product. Omit to create one.
- `productName` (string): Defaults to the website's hostname.
- `sources` (array): The sourcing lanes to configure.
- `voice` (string): How the messages should sound.
- `websiteUrl` (string): Seeds a NEW product from this website and kicks its research.
- `workingHours` (object): e.g. { start: '09:00', end: '18:00', tz: 'Europe/Paris' }. ACCOUNT-level, like dailyCap.

### `gtm_sources_reference` (~134 tokens)

Sourcing lanes reference

THE REFERENCE for configuring sourcing lanes — read it before your first gtm_configure_source / gtm_set_source / gtm_run_source call. Every lane (people_search, competitor_posts a.k.a. Post discovery, job_offers, account_list, and the retired post_engagers), every config field with its meaning, default and cap, the fit/intent/post gates, what makes a lane runnable, how the 5-minute tick and the 24h cadence work, what a preview costs versus a run, and what this surface deliberately will not do. No backend call; safe to call any time.

### `gtm_show_sources` (~249 tokens)

Show sourcing lanes

All five sourcing lanes of a play, configured or not — the read to make before touching any of them. Per lane: `configured`, `on`, the parsed `config` (defaults filled), the cockpit's `summary` (null = needs setup), `blocked` (why it cannot run, judged without running: needs_config / icp_empty / null), last/next run and the last run's funnel, `addedToday`, `failures`, and the lane's memory — `accounts[]` with `found: true|false` per typed company on account_list, `harvestedPosts` on the post lanes, the cached `searches` the model wrote on Post discovery. Play level: `state` is the same verdict the cockpit shows when the Leads table is empty (no_sources / paused / draft / no_seat / seat_broken / icp_empty / needs_config / lead_quota / never_ran / no_results / provider_error / added_nothing / ok), plus provider, seat, ICP facet count and the month's remaining lead quota. Read-only.

Input parameters:

- `playId` (string, required): The play, from gtm_list_plays.

### `gtm_source_runs` (~259 tokens)

Lane run history

The run history of ONE lane, newest first — the funnel over time (scanned → dropped by fit → dropped by intent → added / duplicates / capped), the ICP facets LinkedIn could not filter on, and the provider's status and message when it refused. Use it to tell 'the query returns nobody' from 'everyone was already a lead' from 'LinkedIn is rate-limiting the seat'. Read-only.

Input parameters:

- `key` (string, required): Which lane. people_search: LinkedIn people search compiled from the play's ICP (+ optional free-text keywords). | competitor_posts: Post discovery: Otto searches LinkedIn daily for posts matching an…
- `limit` (number): Runs to return (default 10, max 50).
- `playId` (string, required): The play, from gtm_list_plays.

### `gtm_configure_source` (~444 tokens)

Configure a sourcing lane

Write a lane's settings — upload an account list, set the Post-discovery intent and anchors, change the job keywords, move a gate. MERGE semantics: only the fields you send change. Lists (companies, postUrls, competitors) REPLACE by default; pass listMode 'append' to add to what is there (deduped, case-insensitive). Caps: 100 companies, 25 posts, 25 anchors — what did not fit comes back in `truncated`. Unknown fields are refused. Saving creates the lane's row if it never had one (OFF, because configuring is not switching on), makes the lane due again immediately and resets its retry backoff; on account_list it also forgets the cached misses so unfound companies are looked up again. Pass `on: true` to switch it on in the same call — refused, with nothing saved, if the lane would still have nothing to run on. Nothing runs inside this call: an ON lane on an ACTIVE play runs on the next tick (≤5 min); otherwise use gtm_run_source. Read gtm_sources_reference for each field's meaning.

Input parameters:

- `config` (object, required): The fields to change. See gtm_sources_reference.
- `key` (string, required): Which lane. people_search: LinkedIn people search compiled from the play's ICP (+ optional free-text keywords). | competitor_posts: Post discovery: Otto searches LinkedIn daily for posts matching an…
- `listMode` (string): How list fields combine with the current value. Default replace.
- `on` (boolean): Also switch the lane on/off. Omit to leave the switch alone.
- `playId` (string, required): The play, from gtm_list_plays.

### `gtm_set_source` (~270 tokens)

Switch a lane on or off

Switch a lane on or off — the toggle on the Sources list. Switching ON a lane that has nothing to run on (no companies, no intent/anchors/posts, no role) is refused: configure it first. An empty ICP is not a refusal — people_search may go on ahead of the ICP and comes back `blocked: icp_empty` until gtm_update_icp fills it. Switching OFF never fails and creates nothing. The lane then runs (or stops running) on the daily cadence; nothing runs inside this call.

Input parameters:

- `key` (string, required): Which lane. people_search: LinkedIn people search compiled from the play's ICP (+ optional free-text keywords). | competitor_posts: Post discovery: Otto searches LinkedIn daily for posts matching an…
- `on` (boolean, required)
- `playId` (string, required): The play, from gtm_list_plays.

### `gtm_preview_source` (~345 tokens)

Preview a lane (dry run)

Dry-run ONE lane: '≈ N people match' and a 10-person sample, WITHOUT inserting a lead, spending the day's budget or moving the run clock. Same query, same gates, same scorers as a real run, on up to 50 people — so what it shows is what a run would keep. `size.precision` is honest: 'exact' (the query ran out inside the probe), 'atLeast' (the probe filled up; LinkedIn reports no total) or 'unavailable' (no seat, no config, paused play — `skipped` says which). Reports the ICP facets LinkedIn could not filter on (`unmapped`), facet values it had no id for (`unresolved`), which sampled people are `alreadyALead`, and on account_list what each company resolved to. Costs provider calls and, when a gate is on, model tokens. Refused on a paused play.

Input parameters:

- `key` (string, required): Which lane. people_search: LinkedIn people search compiled from the play's ICP (+ optional free-text keywords). | competitor_posts: Post discovery: Otto searches LinkedIn daily for posts matching an…
- `playId` (string, required): The play, from gtm_list_plays.

### `gtm_run_source` (~331 tokens)

Run a lane now

'Run once now' — run ONE lane immediately through the same code the sourcing tick runs, with force: an OFF lane still runs (that is what run-once means while configuring), a DRAFT play still runs (how you try a lane before launch), a PAUSED play does not. REAL: provider calls are made, leads are inserted, the play's daily budget and the org's monthly lead quota are spent. Only call it when the human asked for a run in this conversation; to look without spending, use gtm_preview_source. Returns the run's funnel (scanned / dropped / droppedIntent / added / duplicates / capped), the unmapped ICP facets, and `skipped` + `reason` when it could not run (no_seat, needs_config, icp_empty, daily_cap, lead_quota, no_results, provider_error).

Input parameters:

- `key` (string, required): Which lane. people_search: LinkedIn people search compiled from the play's ICP (+ optional free-text keywords). | competitor_posts: Post discovery: Otto searches LinkedIn daily for posts matching an…
- `playId` (string, required): The play, from gtm_list_plays.

### `gtm_forget_harvested_posts` (~280 tokens)

Forget harvested posts

The tuning escape hatch for the post lanes. A post lane remembers every post it already paid to harvest so it never buys the same engagers twice — which makes it impossible to TUNE: change the intent or a gate, run, and the answer is 'no new posts since last time'. This clears that memory so the next run (or gtm_run_source) judges today's posts against the new settings. It COSTS: every forgotten post is a fresh engager fetch. Call it only after a deliberate settings change the human wants re-tested. Only competitor_posts and post_engagers have this memory.

Input parameters:

- `key` (string, required): Which lane. people_search: LinkedIn people search compiled from the play's ICP (+ optional free-text keywords). | competitor_posts: Post discovery: Otto searches LinkedIn daily for posts matching an…
- `playId` (string, required): The play, from gtm_list_plays.

### `gtm_update_icp` (~231 tokens)

Update the ICP

Change the ICP a play runs — the query behind people_search and the fit gate on every other lane. Seven string arrays, plain words (gtmotto normalises 'Swiss' → Switzerland, 'Fintech' → Financial Services itself): titles, seniority, languages, industries, sizes (headcount bands like '11-50'), locations, exclude ('never contact' — absolute). ONLY the facets you name change; the first write on a play forks its own ICP row from the product baseline (or a sibling play's row), so no other play's targeting is rewritten. Filling an empty ICP unblocks lanes parked on icp_empty and kicks the play's due lanes if it is active. Size a candidate first with gtm_estimate_icp.

Input parameters:

- `exclude` (array)
- `industries` (array)
- `languages` (array)
- `locations` (array)
- `playId` (string, required): The play, from gtm_list_plays.
- `seniority` (array)
- `sizes` (array)
- `titles` (array)

### `gtm_update_play` (~364 tokens)

Update, pause or launch a play

Change a play's own knobs — name, goal, voice — its two switches, and the ACCOUNT's pacing (daily action cap, working hours: shared by every play on the LinkedIn account, not per play). `paused: true` is the human's stop button (nothing runs, nothing is sent); `paused: false` resumes. `status: 'active'` LAUNCHES a draft; `status: 'draft'` takes it back off the road. Seat rule, enforced server-side: no live LinkedIn seat ⇒ neither launch nor resume makes it active — it stays/falls back to draft and the note says so. Launching or resuming kicks the play's due lanes at once. Only launch, resume or raise the cap when the human asked for it in this conversation: an active play spends the month's lead quota and acts from the human's own LinkedIn account. Does not touch the autonomy ladder.

Input parameters:

- `dailyCap` (number): Actions per day, all kinds summed. ACCOUNT-level: the ceiling every play on this LinkedIn account shares. Defaults to the seat's full LinkedIn allowance (145).
- `goal` (string): What a conversation from this play should reach.
- `name` (string)
- `paused` (boolean): true = stop everything; false = resume.
- `playId` (string, required): The play, from gtm_list_plays.
- `status` (string): 'active' launches; 'draft' un-launches.
- `voice` (string): How the messages should sound.
- `workingHours` (object): e.g. { start: '09:00', end: '18:00', tz: 'Europe/Paris' }. ACCOUNT-level, like dailyCap.

### `gtm_connect_linkedin` (~123 tokens)

Connect LinkedIn

The link a human opens to connect (or reconnect) their LinkedIn account to a play — the one cockpit step the play cannot run without. Hand the URL to the human, tell them to say when it is done, then call gtm_linkedin_status: the seat reads `classic` or `sales_navigator` once bound. The link expires in 15 minutes; call again for a fresh one. Nothing is sent, nothing is read from their account by this call.

Input parameters:

- `playId` (string, required): The play to bind the seat to.

### `gtm_list_approvals` (~111 tokens)

List drafted messages waiting for you

Every drafted action that waits for the human — an invite note, a first message, a follow-up, a reply or a comment the planner wrote — with the draft, the 'why now', the lead, and a cockpit link. One play, or the whole workspace when playId is omitted. Show each draft to the human before gtm_approve / gtm_reject; never decide for them. Read-only.

Input parameters:

- `playId` (string): One play; omit for all.

### `gtm_approve` (~96 tokens)

Approve a drafted message

Approve ONE drafted action by its approvalId (from gtm_list_approvals). It then leaves on the seat's next slot, inside LinkedIn's limits — this is the human's tap, moved from the cockpit to the chat, so ONLY call it after showing them the draft and getting a yes in this conversation. An already-decided card is refused.

Input parameters:

- `approvalId` (string, required): The card to approve.

### `gtm_reject` (~69 tokens)

Reject a drafted message

Reject (skip) ONE drafted action by its approvalId. Nothing is sent; the planner records the decline and re-plans around it instead of proposing the same step again. Ask the human first, as for gtm_approve.

Input parameters:

- `approvalId` (string, required): The card to reject.

## Diagnostics

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

## Score history

- 2026-09-23: 75
- 2026-09-22: 74

## Common questions

### What is the GTM Otto MCP server?

GTM Otto is an MCP server listed in the public MCP registry as com.gtmotto/linkedin. Self-driving LinkedIn prospecting: it sources, warms and invites daily. You approve every message. This page covers its hosted endpoint (https://agent.gtmotto.com/mcp).

### Is the GTM Otto MCP server safe to use?

GTM Otto scores 75 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 GTM Otto MCP server expose?

GTM Otto exposes 21 tools: gtm_whoami, gtm_list_plays, gtm_show_play, gtm_play_stats, gtm_linkedin_status, and 16 more. Their descriptions and schemas cost roughly 4,474 tokens of context every time the server is loaded.

### Does the GTM Otto MCP server require authentication?

Yes. GTM Otto asked us for credentials when we connected, so you will need to authorise it in your MCP client before it can do anything.

### Is the GTM Otto MCP server still maintained?

GTM Otto is still listed as active in the MCP registry. We last reached this channel on 23 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://agent.gtmotto.com/mcp
- Repository: https://github.com/gtmotto/mcp
- Website: https://gtmotto.com/docs/mcp?utm_source=mcp-registry
- Changelog RSS feed: https://verifymcp.io/servers/com-gtmotto-linkedin/agent.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-gtmotto-linkedin/agent.json
- HTML version of this page: https://verifymcp.io/servers/com-gtmotto-linkedin/agent