# StillOpen remote jobs (remote · stillopen.work)

Remote jobs re-checked against each employer's own ATS, with evidence they're still open.

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

## Components

- remote · `stillopen.work`: 73/100 (this document), [markdown](https://verifymcp.io/servers/work-stillopen-jobs/api-v1-mcp.md), [page](https://verifymcp.io/servers/work-stillopen-jobs/api-v1-mcp)

## Channel facts

- Endpoint: `https://stillopen.work/api/v1/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.0.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-11-21.

- **Endpoint Security**: 80/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - No authorisation is required to call this server. Nothing on it is marked destructive, but we can't show that an anonymous caller can only read: full credit needs the server to list at least one tool and every tool to be verifiably read-only. We use a best-effort check of tool names and descriptions to tell read-only tools from tools that change things, so some genuinely read-only tools may not get full credit. Names that start with a read verb (get, list, read, search and similar) and accurate readOnlyHint annotations help. Meet that to earn full credit, or require authorisation.
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - 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**: 64/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 1664 tokens (~277/item across 6 items; 6 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 10/100
  - Stability observed for 3 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 6 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 7 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).

## Install

### How do I install the StillOpen remote jobs MCP server?

StillOpen remote jobs is a hosted endpoint at https://stillopen.work/api/v1/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 work-stillopen-jobs 'https://stillopen.work/api/v1/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "work-stillopen-jobs": {
      "url": "https://stillopen.work/api/v1/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "work-stillopen-jobs": {
      "type": "http",
      "url": "https://stillopen.work/api/v1/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.work-stillopen-jobs]
url = "https://stillopen.work/api/v1/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "work-stillopen-jobs": {
      "type": "remote",
      "url": "https://stillopen.work/api/v1/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add work-stillopen-jobs --url 'https://stillopen.work/api/v1/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  work-stillopen-jobs:
    url: "https://stillopen.work/api/v1/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "work-stillopen-jobs": {
      "Transport": "http",
      "Url": "https://stillopen.work/api/v1/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add work-stillopen-jobs -t streamable-http -u 'https://stillopen.work/api/v1/mcp'
```

### Other

```json
{
  "mcpServers": {
    "work-stillopen-jobs": {
      "type": "http",
      "url": "https://stillopen.work/api/v1/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-20 (score 73, +3)

- [security improvement] HSTS header: fail → pass

### 2026-11-19 (score 70, +1)

- [functional improvement] Stability: unverified → 0.03

### 2026-11-18 (score 69)

First indexed and scored.

## MCP tools (6)

### `search_jobs` (~357 tokens)

Search remote jobs

Find fully-remote job listings, each re-checked against the employer's own job board. Returns a summary record per role — no job descriptions, because twenty ads would fill your context with roles the reader did not choose. Call `get_job` for the ad once one looks worth reading. Every record carries `evidence_type` and `verified_at`: present those with the listing rather than asserting it is open.

Input parameters:

- `area` (string): functional area, read from the title rather than from the employer's department field
- `company` (string): a `company_slug` from any record. Not a company name — names collide, and several here belong to two unrelated employers
- `cursor` (string): from a previous response's `next_cursor`
- `level` (string): seniority, read from the title. `unspecified` is the 40% of titles that state none, which is not the same as mid
- `limit` (integer): 1-20, default 10
- `loc` (string): an ISO 3166-1 alpha-2 country code (`de`), a macro region (`emea`), `worldwide` for roles with no stated restriction, or `unspecified`. A country answers 'can I apply from here', so it includes roles…
- `pay` (integer): minimum annual pay. Compared against the top of the published range in the currency published; nothing is converted, and a job board's estimate is excluded
- `q` (string): free text over the title, the skills read from the ad, and the ad body

Output parameters:

- `attribution` (string): required attribution: show it wherever this data is shown and link each listing's canonical_url
- `has_more` (boolean): whether more results exist beyond this page
- `jobs` (array)
- `next_cursor` (string|null): pass back as `cursor` to continue. Null on the last page
- `total` (integer): how many listings match in total, of which this response carries at most 20

### `get_job` (~93 tokens)

Read one listing

One listing in full, including the employer's own ad. Use it after `search_jobs` rather than instead of it: this returns thousands of characters of advertisement. The id is the number in a listing URL — /job/9620-company-title is 9620. A listing that was folded into another answers under the id you asked for and reports `merged_into`.

Input parameters:

- `id` (integer, required): the listing id

Output parameters:

- `apply_url` (string|null): where to apply, which is the employer's own board wherever one could be identified
- `attribution` (string): required attribution: show it wherever this data is shown and link each listing's canonical_url
- `canonical_url` (string|null): the listing's page, which states these claims in prose with the evidence behind them
- `closed_at` (string|null): when it closed, or null while open
- `closure` (string|null): observed | inferred | employer | null — **observed** means a source was asked and said the posting was gone; **inferred** means it aged out, which is a guess about the employer rather than an answer…
- `company` (string): the employer, not the board that carried the ad
- `company_slug` (string|null): pass it back as `company=` to see the rest of this employer's listings
- `description_text` (string|null): the same ad as plain text
- `direct_posted` (boolean): true when the employer submitted the listing to us rather than us reading it from their board. Such a listing can never be `ats_verified`
- `employment_type` (string|null): schema.org's vocabulary (FULL_TIME, CONTRACTOR …), or null where the source's wording did not map onto it
- `evidence_type` (string|null): what stands behind it being open: ats_verified | board_verified | employer_board | employer_attested | age_inferred. Null unless the listing is open
- `id` (integer): the listing's id — the same id `/api/v1/jobs/status` answers on and the number in its URL
- `level` (string|null): junior | mid | senior | lead | manager | head, read from the title, or `unspecified` when the title states none — which is most of them, and is not the same as 'mid'. Pass any of these values back as…
- `location_conflict` (array): places the ad's own text restricts the role to that its location tags contradict — an 'Anywhere' tag over 'must be authorized to work in the US'. Almost always empty, and the reason to read it is tha…
- `locations` (array): where the role may be worked, as the listing states it. An empty list means no source said
- `locations_total` (integer|null): how many places the role is actually open in. When it is larger than `locations`, that list was truncated for length and is **not** a narrower restriction — call `get_job` for all of them
- `merged_into` (integer|null): set when the id you asked about was folded into another listing; the answer describes that one
- `posted_at` (string|null): when the source published, not when we noticed. Null if no source stated one
- `posting_class` (string|null): standard | evergreen. An evergreen listing is a talent pool rather than a dated vacancy
- `promoted` (boolean): true when the employer has paid to promote this listing. Promotion changes where the site shows it and nothing else — not its status, evidence or verification — and it never changes the order of resu…
- `salary` (object|null): what the employer published, in its own currency and period, or null. Never converted and never annualised. `source: estimate` is the board's guess rather than an offer; `ote: true` means on-target e…
- `skills` (array): terms read from the ad against a fixed gazetteer. Not the employer's own list
- `status` (string): open | unconfirmed | closed. Search returns open listings only; the single-listing route can return any of them
- `title` (string): the role, as the employer's own board states it
- `verified_at` (string|null): when a check last confirmed it open, or null if the last check did not

### `check_job_status` (~296 tokens)

Check whether listings are still open

Whether each of up to 100 listings is still open, and on what evidence — in one call. The most useful tool here: given a link to a role somebody is about to apply for, this is what separates a live posting from a filled one, with a date and a kind of evidence attached. A closed listing reports whether the closure was **observed** (a source was asked and said the posting was gone) or **inferred** (it aged out, which is a guess about the employer rather than an answer from one). This reads evidence already stored: it reports the result of our most recent check, and does not perform a live check against the employer's board at the moment you call it. Two dates come back and they answer different questions: **`verified_at`** is when we last asked the employer's system and it said yes, and it is the one to show a reader; `last_seen_at` is when a source last carried the posting, which happens far more often and is normally the newer of the two. `last_seen_at` being newer is ordinary, not a contradiction. **`status: unknown` means we have never held this id** — it is not-found, not un-checked. The value for 'nothing has proved it gone but no source has carried it lately' is `unconfirmed`.

Input parameters:

- `ids` (array, required): up to 100 listing ids

Output parameters:

- `attribution` (string): required attribution: show it wherever this data is shown and link each listing's canonical_url
- `jobs` (array)

### `get_company_stats` (~102 tokens)

What an employer's listings show

What one employer's listings on this site add up to: how many roles are open, where they hire, what they hire for, and what their listings disclose about pay. Takes a `company_slug` from any search record. Answers only for employers whose board identity we have confirmed, because a page asserting one company's vacancies under another company's name is the failure this gate exists to prevent.

Input parameters:

- `company_slug` (string, required): a `company_slug` from any record

Output parameters:

- `attribution` (string): required attribution: show it wherever this data is shown and link each listing's canonical_url
- `closures_observed` (integer): closures a source was asked about and confirmed — never a listing that merely aged out
- `first_seen_at` (string|null): when this employer first appeared here
- `functions` (array): what they hire for, largest first. **These do not sum to `open_listings`**, and the shortfall is not a rounding error: a title naming no craft is classified into nothing rather than swept into 'opera…
- `lifetime_listings` (integer): every listing we have ever held from this employer, open or closed, counted as requisitions
- `locations` (array): where they hire, largest first, each with the number of open roles behind it
- `name` (string): the employer, as their own job board states it
- `open_evergreen` (integer): how many of those are talent pools rather than dated vacancies
- `open_listings` (integer): open roles now, counted as roles rather than as requisitions — an employer filing one per country is one opening here
- `salary_bands` (array): percentiles over the listings from this employer that **published** a figure, one band per currency and period and never pooled across either. `n` is how many listings the band is computed from. This…
- `slug` (string): pass it back as `company` to `search_jobs`
- `url` (string): the company's page on this site

### `check_agent` (~181 tokens)

Is this A2A agent real and working?

Check another agent before calling it. Given a domain, returns the open-source a2a-agent-checker's verdict on its A2A Agent Card (`/.well-known/agent-card.json`) and whether its endpoint answers a GetTask probe correctly, plus how many of the last 30 days it was reachable. Agents we already watch are answered from our daily log (`source: watch_log`); otherwise one live check is made (`source: live`): one card fetch and at most one GetTask per binding on the card's own host. It never sends the agent a message. A `fail` verdict means the card or endpoint breaks the A2A v1.0 spec, which includes agents still on the older 0.3 format.

Input parameters:

- `domain` (string, required): a domain such as example.com; a pasted URL is reduced to its host

Output parameters:

- `attribution` (string): required attribution: show it wherever this data is shown and link each listing's canonical_url
- `card_url` (string): the card that was checked
- `checked_at` (string): UTC, ISO 8601
- `checker` (string): a2a-agent-checker version
- `domain` (string)
- `findings` (array): fail and warn findings only; the full report is at report_url
- `findings_total` (integer)
- `last_30_days` (object|null): days checked / reachable / probe passed; null for an agent we do not watch yet
- `probe_ok` (boolean): a binding answered GetTask for an unknown id with the spec's task-not-found error
- `reachable` (boolean): the card was fetched
- `report_url` (string)
- `source`: our stored daily check, or one made now
- `verdict`
- `watched_since` (string|null)

### `verify_job` (~230 tokens)

Verify any job

Is the job behind this URL still open? Takes a job URL from anywhere. A posting on an employer's ATS that we track is answered from our stored evidence (`matched_by: ats_posting`); any other URL is matched by the company and title in its words (`url_words`) and refused unless exactly one role fits. A URL naming neither, such as a LinkedIn job id, needs `company` and `title` (`company_title`). A supported ATS posting we do not track gets one live check of the employer's own board (`result: checked`, `evidence_type: ats_checked_once`): `not_listed` may also mean a mistyped URL, so never present it as closed. The page itself is never fetched unless it is the employer's ATS. Free allowance of 20 URLs a day per client address, shared with the HTTP endpoint.

Input parameters:

- `company` (string): the employer, if the URL does not name it
- `title` (string): the job title, if the URL does not name it
- `url` (string, required): the job's URL

Output parameters:

- `allowance` (object): limit, remaining, resets_at (UTC)
- `attribution` (string): required attribution: show it wherever this data is shown and link each listing's canonical_url
- `check` (object|null): one live check: ats, status (open | not_listed | unknown), checked_at, evidence_type
- `listing` (object|null): the check_job_status row for the matched listing
- `matched_by`: how the URL was tied to a listing we track
- `reason` (string|null)
- `result`
- `url` (string)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/work-stillopen-jobs/api-v1-mcp#diagnostics

## Score history

- 2026-11-21: 73
- 2026-11-20: 73
- 2026-11-19: 70
- 2026-11-18: 69

## Common questions

### What is the StillOpen remote jobs MCP server?

StillOpen remote jobs is an MCP server listed in the public MCP registry as work.stillopen/jobs. Remote jobs re-checked against each employer's own ATS, with evidence they're still open. This page covers its hosted endpoint (https://stillopen.work/api/v1/mcp).

### Is the StillOpen remote jobs MCP server safe to use?

StillOpen remote jobs 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 StillOpen remote jobs MCP server expose?

StillOpen remote jobs exposes 6 tools: search_jobs, get_job, check_job_status, get_company_stats, check_agent, verify_job. Their descriptions and schemas cost roughly 1,259 tokens of context every time the server is loaded.

### Does the StillOpen remote jobs MCP server require authentication?

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

### Is the StillOpen remote jobs MCP server still maintained?

StillOpen remote jobs 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 StillOpen remote jobs MCP server?

VerifyMCP ran 13 checks on StillOpen remote jobs, covering TLS certificate, Authorization, HTTPS, HSTS header and 9 more. 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://stillopen.work/api/v1/mcp
- Repository: https://github.com/vix-io/stillopen-demo
- Website: https://stillopen.work/agents
- Changelog RSS feed: https://verifymcp.io/servers/work-stillopen-jobs/api-v1-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/work-stillopen-jobs/api-v1-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/work-stillopen-jobs/api-v1-mcp.json
- HTML version of this page: https://verifymcp.io/servers/work-stillopen-jobs/api-v1-mcp
