{
  "notice": "bxzxxr MCP archive: a record of what public MCP servers declared when we listed them (we never call their tools). It is data, not a rating: nothing here says a server is safe, secure, verified or trustworthy, and a server can change after we looked. Secrets we detected are redacted; redacted tool lists are withheld and only their hash is shown.",
  "infrastructure": {
    "host": "api.usewrit.app",
    "site": "usewrit.app",
    "addresses": [
      {
        "address": "104.21.13.214",
        "endpoints": 3,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "name": "CLOUDFLARENET - Cloudflare, Inc.",
          "prefix": "104.21.0.0/19",
          "country": "US"
        }
      },
      {
        "address": "172.67.133.42",
        "endpoints": 3,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "name": "CLOUDFLARENET - Cloudflare, Inc.",
          "prefix": "172.67.128.0/20",
          "country": "US"
        }
      },
      {
        "address": "2606:4700:3033::6815:dd6",
        "endpoints": 3,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "name": "CLOUDFLARENET - Cloudflare, Inc.",
          "prefix": "2606:4700:3033::/48",
          "country": "US"
        }
      },
      {
        "address": "2606:4700:3031::ac43:852a",
        "endpoints": 3,
        "shared_infrastructure": false,
        "network": {
          "asn": 13335,
          "name": "CLOUDFLARENET - Cloudflare, Inc.",
          "prefix": "2606:4700:3031::/48",
          "country": "US"
        }
      }
    ],
    "addresses_recorded": true,
    "address_history": [
      {
        "addresses": [
          "104.21.13.214",
          "172.67.133.42",
          "2606:4700:3033::6815:dd6",
          "2606:4700:3031::ac43:852a"
        ],
        "first_seen": "2026-11-22T07:11:03.817Z",
        "last_seen": "2026-11-22T07:11:03.817Z",
        "checks": 1
      }
    ],
    "hosting": [
      {
        "value": "Cloudflare",
        "evidence": "Server header \"cloudflare\""
      }
    ],
    "software": [],
    "server_info": {
      "name": "Writ Cloud",
      "version": "1.0.0",
      "protocol_version": "2025-06-18"
    },
    "headers": {
      "server": "cloudflare",
      "strict-transport-security": "max-age=31536000; includeSubDomains; preload"
    },
    "auth": null
  },
  "related": {
    "same_address": {
      "total": 2,
      "sample": [
        {
          "id": "3845",
          "url": "https://pixever.app/mcp",
          "server_name": "app.pixever/mcp",
          "last_state": "listed",
          "last_checked_at": "2026-11-22T07:06:01.988Z"
        },
        {
          "id": "40843",
          "url": "https://ruleswatch.com/api/mcp",
          "server_name": "io.github.whosman/ruleswatch",
          "last_state": "listed",
          "last_checked_at": "2026-11-21T17:35:02.394Z"
        }
      ]
    },
    "same_site": {
      "total": 0,
      "sample": []
    },
    "same_tool_list": {
      "total": 0,
      "sample": []
    },
    "same_publisher": {
      "publisher": "app.usewrit",
      "total": 0,
      "sample": []
    },
    "same_repository": {
      "repository_url": "https://github.com/usewrit/writ-mcp",
      "total": 0,
      "sample": []
    },
    "note": "Shared addresses on big platforms (Cloudflare, Vercel and the like) put unrelated servers together; those are marked shared_infrastructure. A match is a pivot, not a link between operators."
  },
  "endpoint": {
    "id": "4227",
    "server_name": "app.usewrit/writ-cloud",
    "url": "https://api.usewrit.app/mcp",
    "host": "api.usewrit.app",
    "transport": "streamable-http",
    "last_checked_at": "2026-11-22T07:11:03.817Z",
    "last_state": "listed",
    "last_detail": null,
    "consecutive_failures": 0,
    "current_sha": "71182a7a1ea32bd505a9bda9bed8d731b4aa9f6f2a0645dfb39c9abaa3693c32",
    "first_listed_at": "2026-11-21T06:07:02.136Z",
    "created_at": "2026-11-21T04:55:04.987Z",
    "resolved_addresses": [
      "104.21.13.214",
      "172.67.133.42",
      "2606:4700:3033::6815:dd6",
      "2606:4700:3031::ac43:852a"
    ]
  },
  "server": {
    "name": "app.usewrit/writ-cloud",
    "title": "Writ Cloud",
    "description": "Read, crawl and act on websites, signed in as the user, and turn any site into an API.",
    "version": "1.0.0",
    "registry_status": "active",
    "repository_url": "https://github.com/usewrit/writ-mcp",
    "website_url": "https://usewrit.app",
    "published_at": "2026-10-10T13:19:03.186Z",
    "updated_at": "2026-10-10T13:19:03.186Z",
    "first_seen": "2026-11-21T04:55:04.366Z"
  },
  "other_endpoints": [],
  "intel": {
    "capabilities": [
      "controls-browser"
    ],
    "evm_addresses": [],
    "chains": [],
    "tokens": [],
    "computed_at": "2026-11-22T14:53:07.991Z"
  },
  "operator": null,
  "needs_sign_in": false,
  "reachability": {
    "window_days": 30,
    "checks": 2,
    "answered": 2,
    "answered_percent": 100,
    "avg_listing_latency_ms": 330,
    "first_check_in_window": "2026-11-21T06:07:02.136Z",
    "consecutive_failures_now": 0,
    "days": [
      {
        "day": "2026-11-21",
        "checks": 1,
        "answered": 1,
        "last_state": "listed"
      },
      {
        "day": "2026-11-22",
        "checks": 1,
        "answered": 1,
        "last_state": "listed"
      }
    ]
  },
  "tool_list": {
    "sha256": "71182a7a1ea32bd505a9bda9bed8d731b4aa9f6f2a0645dfb39c9abaa3693c32",
    "tools": 41,
    "resources": 1,
    "prompts": 0,
    "first_seen": "2026-11-21T06:07:02.459Z",
    "tool_names": [
      "writ_browser_use",
      "writ_record_website",
      "writ_website_to_api",
      "writ_discovery_status",
      "writ_browser_act",
      "writ_browser_context",
      "writ_browser_network",
      "writ_browser_compose",
      "writ_browser_save",
      "writ_browser_ask_user",
      "writ_browser_cancel",
      "writ_browser_sessions",
      "writ_personas",
      "writ_payment",
      "writ_devices",
      "writ_list_workflows",
      "writ_run_workflow",
      "writ_update_workflow",
      "writ_create_http_extraction",
      "writ_diagnose_http_workflow",
      "writ_pin_workflow_tool",
      "writ_workflow_data",
      "writ_search_data",
      "writ_export_data",
      "writ_workflow_runs",
      "writ_set_schedule",
      "writ_expose_workflow_api",
      "writ_crawl_site",
      "writ_saved_crawls",
      "writ_update_saved_crawl",
      "writ_run_saved_crawl",
      "writ_saved_crawl_data",
      "writ_scrape",
      "writ_crawl_status",
      "writ_crawl_files",
      "writ_create_automation",
      "writ_list_webhooks",
      "writ_create_monitor",
      "writ_wire_monitor",
      "writ_help",
      "writ_browser_live_view"
    ],
    "declared": {
      "tools": [
        {
          "name": "writ_browser_use",
          "title": "Open a browser",
          "description": "A REAL CLOUD BROWSER FOR A TASK ON A SITE: the user's signed-in account (a persona_id from writ_personas: the password stays sealed in Writ, and sessions never ask for a password), a click, form, submit or search inside an app, or a page a plain fetch cannot open (login wall, 403, CAPTCHA). Opens the browser and returns the first page; writ_browser_act drives it (Writ runs no model here). Recording is always on: writ_browser_save turns the session into a workflow that replays without a browser, writ_browser_cancel closes it (an open browser bills). The start answer carries the action vocabulary, the recording rules and, with a persona, the 2FA rules. NOT FOR: reading pages (writ_scrape). An API: writ_website_to_api opens this same browser, bound to a build.",
          "inputSchema": {
            "type": "object",
            "required": [
              "url"
            ],
            "properties": {
              "url": {
                "type": "string"
              },
              "goal": {
                "type": "string"
              },
              "auth_mode": {
                "enum": [
                  "reuse",
                  "fresh_login"
                ],
                "type": "string"
              },
              "fresh_exit": {
                "type": "boolean"
              },
              "persona_id": {
                "type": [
                  "integer",
                  "string"
                ]
              },
              "idempotency_key": {
                "type": "string"
              },
              "use_residential": {
                "type": "boolean",
                "description": "Residential exit (bot walls, another country). Omitted: Writ's residential list decides. Pair with residential_country."
              },
              "execution_target": {
                "type": "string",
                "description": "cloud | auto | local (the user's own desktop app)."
              },
              "residential_country": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Open a browser",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_record_website",
          "title": "Record a website task",
          "description": "Records a repeatable task on a site as a workflow (goal + start url): the same session as writ_browser_use, labelled with its goal, driven with writ_browser_act and saved with writ_browser_save. A goal that asks for an API opens as a writ_website_to_api build instead: the same browser, bound to the build.",
          "inputSchema": {
            "type": "object",
            "required": [
              "goal",
              "url"
            ],
            "properties": {
              "url": {
                "type": "string"
              },
              "goal": {
                "type": "string"
              },
              "device": {
                "type": "string"
              },
              "auth_mode": {
                "enum": [
                  "reuse",
                  "fresh_login"
                ],
                "type": "string"
              },
              "fresh_exit": {
                "type": "boolean"
              },
              "persona_id": {
                "type": [
                  "integer",
                  "string"
                ]
              },
              "skip_existing": {
                "type": "boolean"
              },
              "use_residential": {
                "type": "boolean",
                "description": "Residential exit (bot walls, another country). Omitted: Writ's residential list decides. Pair with residential_country."
              },
              "skip_marketplace": {
                "type": "boolean"
              },
              "residential_country": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Record a website task",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_website_to_api",
          "title": "Turn a website into an API",
          "description": "TURNS A WEBSITE INTO A CALLABLE API (named functions with inputs, returning JSON), built by the caller in a real browser. url = the page that already shows the rows (search results or a listing, not the home page); goal = the inputs and fields wanted. The call first proposes the user's matching saved workflows and marketplace APIs (skip_existing / skip_marketplace build fresh), then opens a cloud browser bound to the build: capture_network records the site's own calls, writ_browser_network reads them, api_call probes them; a failed probe is evidence, not the end. Functions: HTTP flows first (writ_browser_compose define_function `flow`; writ_help('http_flows')), single requests (from_index) mixed in, DOM extraction last. writ_browser_save, then run_example on two inputs.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "url": {
                "type": "string"
              },
              "goal": {
                "type": "string"
              },
              "device": {
                "type": "string"
              },
              "save_as": {
                "type": "string"
              },
              "build_id": {
                "type": "integer"
              },
              "anonymous": {
                "type": "boolean"
              },
              "persona_id": {
                "type": "integer"
              },
              "skip_existing": {
                "type": "boolean",
                "description": "Skip the proposal of the user's own matching workflows."
              },
              "idempotency_key": {
                "type": "string"
              },
              "use_residential": {
                "type": "boolean"
              },
              "execution_target": {
                "type": "string"
              },
              "skip_marketplace": {
                "type": "boolean",
                "description": "Skip the marketplace proposals."
              },
              "residential_country": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Turn a website into an API",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_discovery_status",
          "title": "Check an API build",
          "description": "Status of a website-to-API build (a guided one, or one started in the Writ app). wait=true is one held call (up to 75 s) that follows the build to its newest rung and returns when it is done or parked. Answers: succeeded (workflow_id, functions, run_example), failed, cancelled, or needs_guidance (the build is the caller's to finish with writ_website_to_api build_id=<id>; its map comes with it).",
          "inputSchema": {
            "type": "object",
            "required": [
              "build_id"
            ],
            "properties": {
              "wait": {
                "type": "boolean",
                "description": "One held call until done or parked."
              },
              "build_id": {
                "type": "integer"
              },
              "timeout_seconds": {
                "type": "integer",
                "description": "Ceiling for wait=true (up to 75)."
              }
            }
          },
          "annotations": {
            "title": "Check an API build",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_browser_act",
          "title": "Act in a browser session",
          "description": "Runs one batch of actions on an open session and returns the fresh page. Each action is an object, e.g. {\"action\":\"click\",\"selector\":\"#go\"}. DRIVE: navigate, click, fill, type_text, select, check, hover, submit, press_key, scroll, back, wait, wait_for. SEE: query_dom, find_text, read_text, count, get_attributes, inspect, list_candidates, get_dom, get_screenshot. NETWORK: capture_network, get_request, rotate_exit. CODE: evaluate_js, search_scripts, read_script. RECORD: extract {variable,script}, api_call (a flow is built step by step with writ_browser_compose add_flow_step), login_post, probe_write, confirm_write. 2FA: twofa {challenge_method}. A value written {{name}} with its real value in `inputs` becomes a workflow input. Each action's arguments: the session's start answer, or writ_help('writ_browser_act').",
          "inputSchema": {
            "type": "object",
            "required": [
              "session_id",
              "actions"
            ],
            "properties": {
              "inputs": {
                "type": "object"
              },
              "actions": {
                "type": "array",
                "items": {
                  "type": "object"
                },
                "description": "Ordered action objects, e.g. [{\"action\":\"click\",\"selector\":\"#login\"}]."
              },
              "max_chars": {
                "type": "integer",
                "description": "Clip of the returned page (default 40000)."
              },
              "session_id": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Act in a browser session",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_browser_context",
          "title": "Read a browser session",
          "description": "Re-reads an open session: section=page (url, fields, buttons, cleaned DOM), lists (the page's repeating rows with a live-tested define_function payload for writ_browser_compose), map (the evidence of the build the session is bound to).",
          "inputSchema": {
            "type": "object",
            "required": [
              "session_id"
            ],
            "properties": {
              "offset": {
                "type": "integer",
                "minimum": 0
              },
              "section": {
                "enum": [
                  "page",
                  "lists",
                  "map",
                  "explorer",
                  "concierge_api"
                ],
                "type": "string",
                "description": "page (default) | lists | map | explorer | concierge_api."
              },
              "max_chars": {
                "type": "integer"
              },
              "session_id": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Read a browser session",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_browser_network",
          "title": "Read a session's network calls",
          "description": "Searches (operation=search, query, method) or reads in full (operation=detail, index) the backend requests the page made after capture_network: the site's real API. writ_browser_act api_call probes one with other values (a `flow`: several requests); an index feeds writ_browser_compose define_function from_index.",
          "inputSchema": {
            "type": "object",
            "required": [
              "session_id"
            ],
            "properties": {
              "index": {
                "type": "integer",
                "minimum": 0,
                "description": "detail: which call."
              },
              "query": {
                "type": "string",
                "description": "Substring filter."
              },
              "method": {
                "type": "string",
                "description": "HTTP method filter."
              },
              "offset": {
                "type": "integer",
                "minimum": 0
              },
              "max_chars": {
                "type": "integer"
              },
              "operation": {
                "enum": [
                  "search",
                  "detail"
                ],
                "type": "string",
                "description": "search (default) | detail."
              },
              "session_id": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Read a session's network calls",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_browser_compose",
          "title": "Compose a workflow in a session",
          "description": "Authors the workflow in an open session beyond a recording: named API functions (define_function with a `flow`, preferred in an API build, or a captured call's index or a lists payload; live-tested as defined; compile_function for an authenticated request), set_inputs, add_steps, test_function, remove_function, remove_step, list. A flow is built in small calls: define_function with its first request, then add_flow_step {function, step, at?} per step, each tested and answered with the step list; a set step's value is read as {ref:'vars.<name>'}. Shapes: writ_help('writ_browser_compose').",
          "inputSchema": {
            "type": "object",
            "required": [
              "session_id",
              "operation"
            ],
            "properties": {
              "payload": {
                "type": "object",
                "description": "The operation's arguments; add_flow_step: {function, step, at?}, remove_flow_step: {function, at}."
              },
              "operation": {
                "enum": [
                  "list",
                  "define_function",
                  "compile_function",
                  "test_function",
                  "remove_function",
                  "add_flow_step",
                  "replace_flow_step",
                  "remove_flow_step",
                  "add_steps",
                  "remove_step",
                  "set_inputs"
                ],
                "type": "string",
                "description": "The action; add_flow_step, replace_flow_step and remove_flow_step change one step of a function's flow."
              },
              "session_id": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Compose a workflow in a session",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_browser_save",
          "title": "Save a session as a workflow",
          "description": "Saves the open session as a replayable workflow and closes the browser, in the place its browser ran: the user's desktop library or Writ Cloud. Composed functions become callable API functions, declared inputs become its parameters. The answer carries the steps, the inputs and a run_example; the workflow runs at zero AI cost through writ_run_workflow. A save that references something no run could resolve is refused with the reasons, and the browser stays open.",
          "inputSchema": {
            "type": "object",
            "required": [
              "session_id"
            ],
            "properties": {
              "name": {
                "type": "string"
              },
              "listing": {
                "type": "object",
                "description": "Its Marketplace title, summary, tags, category and intent: people-facing, English, no build status."
              },
              "save_to": {
                "enum": [
                  "desktop",
                  "cloud",
                  "both"
                ],
                "type": "string"
              },
              "keep_open": {
                "type": "boolean"
              },
              "session_id": {
                "type": "string"
              },
              "description": {
                "type": "string"
              },
              "allow_no_data": {
                "type": "boolean",
                "description": "Save a workflow that returns no data, on purpose."
              },
              "contribute_to_catalog": {
                "type": "boolean"
              }
            }
          },
          "annotations": {
            "title": "Save a session as a workflow",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_browser_ask_user",
          "title": "Ask the user to step in",
          "description": "Hands an open session to the Writ user: kind='captcha' (they complete a security check in the live browser), 'twofa' (they supply the one-time code and Writ types it; the code never reaches this conversation), 'sign_in' (they sign in on the live page; no persona applies) or 'question' (their text answer). The call that opens the ask returns at once with user_link + tell_user to relay; later calls hold up to 60 s and answer answered, waiting_for_user (the same call again) or expired. Their answer is kept if your turn ends first.",
          "inputSchema": {
            "type": "object",
            "required": [
              "session_id"
            ],
            "properties": {
              "kind": {
                "enum": [
                  "captcha",
                  "question",
                  "twofa",
                  "sign_in"
                ],
                "type": "string",
                "description": "captcha | twofa | sign_in | question."
              },
              "question": {
                "type": "string",
                "description": "kind='question': one short sentence."
              },
              "session_id": {
                "type": "string"
              },
              "wait_seconds": {
                "type": "integer",
                "description": "Hold up to this long (1-60)."
              }
            }
          },
          "annotations": {
            "title": "Ask the user to step in",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_browser_cancel",
          "title": "Close a browser session",
          "description": "Closes an open browser session (an open cloud browser bills until it is closed). Unsaved work that did more than visit pages is auto-saved first and the reply names it; discard=true keeps nothing.",
          "inputSchema": {
            "type": "object",
            "required": [
              "session_id"
            ],
            "properties": {
              "discard": {
                "type": "boolean",
                "description": "Throw away unsaved steps instead of auto-saving."
              },
              "session_id": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Close a browser session",
            "readOnlyHint": false,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_browser_sessions",
          "title": "List open browser sessions",
          "description": "Lists the account's open cloud browser sessions (each resumable by its session_id).",
          "inputSchema": {
            "type": "object",
            "properties": {
              "limit": {
                "type": "integer"
              },
              "include_closed": {
                "type": "boolean"
              }
            }
          },
          "annotations": {
            "title": "List open browser sessions",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_personas",
          "title": "Use the user's saved sign-ins",
          "description": "The user's own accounts on websites (personas): how Writ signs in as them. No password passes through this tool or the conversation, and its answers never ask for one: credentials are typed only into a Writ window. action='list' domain=<site> shows the personas usable there; with none it answers persona_needed: a tell_user for the user, a create_url (a small Writ window with only the sign-in form, pre-filled for the site) and a link_id. action='wait' link_id=<id> is one held call that answers when the user saves it, with its persona_id. Also get, request (a link for another account), sign_in (refresh the session) and record_login. A persona_id works on writ_scrape, writ_crawl_site, writ_browser_use and writ_run_workflow; a desktop persona ('device:...') signs in on that desktop, from its own vault.",
          "inputSchema": {
            "type": "object",
            "required": [
              "action"
            ],
            "properties": {
              "why": {
                "type": "string",
                "description": "request: one line the user sees in the window."
              },
              "wait": {
                "type": "boolean"
              },
              "force": {
                "type": "boolean"
              },
              "action": {
                "enum": [
                  "list",
                  "get",
                  "request",
                  "wait",
                  "sign_in",
                  "record_login"
                ],
                "type": "string",
                "description": "list (default) | get | request | wait | sign_in | record_login."
              },
              "device": {
                "type": "string"
              },
              "domain": {
                "type": "string",
                "description": "list: personas usable on this site. request: the site."
              },
              "link_id": {
                "type": "string",
                "description": "wait: the link_id of a persona_needed / request answer."
              },
              "login_url": {
                "type": "string"
              },
              "persona_id": {
                "type": "integer"
              },
              "include_runs": {
                "type": "boolean"
              },
              "execution_target": {
                "enum": [
                  "cloud"
                ],
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Use the user's saved sign-ins",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_payment",
          "title": "Pay with a card the user approves",
          "description": "Pays on a site with one of the user's cards; card numbers never reach this conversation. request (site, max_amount, purpose) returns a tell_user and an open_url where the user approves; wait (grant_id or confirmation_id); checkout pauses at the order button for the user's confirmation, then Writ places the order; fill; list (card handles only). Details: writ_help('writ_payment').",
          "inputSchema": {
            "type": "object",
            "required": [
              "action"
            ],
            "properties": {
              "site": {
                "type": "string",
                "description": "request: the store's domain."
              },
              "steps": {
                "type": "array",
                "items": {
                  "type": "object"
                }
              },
              "action": {
                "enum": [
                  "request",
                  "wait",
                  "checkout",
                  "fill",
                  "list"
                ],
                "type": "string",
                "description": "request | wait | checkout | fill | list."
              },
              "fields": {
                "type": "object"
              },
              "purpose": {
                "type": "string",
                "description": "One line the user reads."
              },
              "session": {
                "type": "string",
                "description": "The browser session on the checkout page."
              },
              "summary": {
                "type": "string"
              },
              "currency": {
                "type": "string"
              },
              "grant_id": {
                "type": "string"
              },
              "max_amount": {
                "type": "number",
                "description": "The most it may charge."
              },
              "automation_id": {
                "type": "integer"
              },
              "total_selector": {
                "type": "string"
              },
              "commit_selector": {
                "type": "string",
                "description": "checkout: the place-order button."
              },
              "confirmation_id": {
                "type": "string"
              },
              "payment_method_id": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Pay with a card the user approves",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_devices",
          "title": "Choose a linked desktop",
          "description": "The user's linked Writ desktops: list, use (scope this connection to one: runs, browsers, personas and monitors then target it), clear, monitors, datasets.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "action": {
                "enum": [
                  "list",
                  "use",
                  "clear",
                  "monitors",
                  "datasets"
                ],
                "type": "string",
                "description": "list (default) | use | clear | monitors | datasets."
              },
              "device": {
                "type": "string",
                "description": "use: the desktop's agent_id or name."
              }
            }
          },
          "annotations": {
            "title": "Choose a linked desktop",
            "readOnlyHint": false,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_list_workflows",
          "title": "List saved workflows",
          "description": "Lists the workflows saved in the Writ account; each runs on demand without live browsing. Returns id, name, declared inputs (with `input_rules`: the values and format an input accepts), schedule, whether it is pinned as its own run_<name> tool, and, for an API with several functions, their names (`functions`, `write_functions`): call one with function_name.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "search": {
                "type": "string",
                "description": "Name/description filter, e.g. a site."
              }
            }
          },
          "annotations": {
            "title": "List saved workflows",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_run_workflow",
          "title": "Run a saved workflow",
          "description": "Runs a saved workflow by workflow_id or name and returns its extracted data (it waits by default). The answer's `data` is what the run returned and `records_path` names its records; pass `output` with only the fields the question needs (fields: ['price', 'data.date as date']) for a far smaller answer. Inputs go as top-level fields or under `inputs`; function_name runs one function of a multi-function API (with the sign-in it needs). max_age reuses a recent result at no cost. A write function previews with mutation_mode='dry_run'. Runs sign in as the workflow's persona or persona_id; no password is ever passed. Venue, network, files and output shape: writ_help('writ_run_workflow').",
          "inputSchema": {
            "type": "object",
            "properties": {
              "wait": {
                "type": "boolean"
              },
              "files": {
                "type": "object"
              },
              "device": {
                "type": "string"
              },
              "inputs": {
                "type": "object",
                "description": "Run inputs (top-level fields work too)."
              },
              "output": {
                "type": "object"
              },
              "max_age": {
                "type": "integer",
                "minimum": 0,
                "description": "Reuse a result younger than this many seconds (free). 0 = fresh."
              },
              "workflow": {
                "type": "string",
                "description": "Workflow name (or workflow_id)."
              },
              "persona_id": {
                "type": [
                  "integer",
                  "string"
                ],
                "description": "Run as this saved identity."
              },
              "workflow_id": {
                "type": [
                  "integer",
                  "string"
                ],
                "description": "A number, or 'local:<id>' (a workflow on the user's desktop)."
              },
              "function_name": {
                "type": "string",
                "description": "One function of a multi-function workflow; writ_list_workflows names them (`functions`)."
              },
              "mutation_mode": {
                "enum": [
                  "live",
                  "dry_run",
                  "private_test"
                ],
                "type": "string",
                "description": "live (default) | dry_run (preview, nothing sent) | private_test."
              },
              "function_names": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "idempotency_key": {
                "type": "string"
              },
              "timeout_seconds": {
                "type": "integer"
              },
              "use_residential": {
                "type": "boolean"
              },
              "execution_target": {
                "type": "string",
                "description": "cloud | auto | local (the user's own desktop app)."
              },
              "residential_country": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Run a saved workflow",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_update_workflow",
          "title": "Edit a saved workflow",
          "description": "Inspects or edits a saved workflow: an outline, one function's source, targeted function or step edits, a settings patch. copy_to keeps a linked copy on Writ Cloud or the user's desktop. Every option: writ_help('writ_update_workflow').",
          "inputSchema": {
            "type": "object",
            "properties": {
              "path": {
                "type": "string"
              },
              "limit": {
                "type": "integer",
                "maximum": 100,
                "minimum": 1
              },
              "patch": {
                "type": "object",
                "description": "Settings and metadata to change; {\"name\": \"New name\"} renames it."
              },
              "device": {
                "type": "string"
              },
              "offset": {
                "type": "integer",
                "minimum": 0
              },
              "copy_to": {
                "enum": [
                  "cloud",
                  "desktop"
                ],
                "type": "string"
              },
              "section": {
                "enum": [
                  "source",
                  "flow",
                  "contract"
                ],
                "type": "string"
              },
              "step_id": {
                "type": "string"
              },
              "verbose": {
                "type": "boolean"
              },
              "operator": {
                "type": "string"
              },
              "workflow": {
                "type": "string",
                "description": "Name or id; local:<n> for a desktop workflow."
              },
              "max_chars": {
                "type": "integer",
                "maximum": 20000,
                "minimum": 1000
              },
              "workflow_id": {
                "type": "integer"
              },
              "step_updates": {
                "type": "array",
                "items": {
                  "type": "object"
                },
                "description": "[{index, patch}] merged into those recorded steps."
              },
              "function_name": {
                "type": "string"
              },
              "input_updates": {
                "type": "array",
                "items": {
                  "type": "object"
                },
                "maxItems": 50,
                "minItems": 1
              },
              "replace_steps": {
                "type": "array",
                "items": {
                  "type": "object"
                }
              },
              "validate_only": {
                "type": "boolean",
                "description": "true previews and validates; nothing is saved."
              },
              "function_updates": {
                "type": "array",
                "items": {
                  "type": "object"
                },
                "maxItems": 50,
                "minItems": 1,
                "description": "[{function_name, patch|json_edits|script_edits}] (add /config/flow/steps/- appends a step); add:{step} adds a function."
              },
              "regenerate_skill": {
                "type": "boolean"
              },
              "expected_updated_at": {
                "type": "string"
              },
              "confirm_listing_change": {
                "type": "boolean"
              }
            }
          },
          "annotations": {
            "title": "Edit a saved workflow",
            "readOnlyHint": false,
            "openWorldHint": false,
            "idempotentHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_create_http_extraction",
          "title": "Build an HTTP extraction",
          "description": "Drafts or revises a multi-request browserless HTTP extraction (loops, GraphQL, cursor pagination) from captured requests and a plain-language goal. Every option: writ_help('writ_create_http_extraction').",
          "inputSchema": {
            "type": "object",
            "required": [
              "goal"
            ],
            "properties": {
              "goal": {
                "type": "string"
              },
              "apply": {
                "type": "boolean",
                "description": "false (default) drafts; true writes."
              },
              "workflow": {
                "type": "string"
              },
              "step_index": {
                "type": "integer"
              },
              "workflow_id": {
                "type": "integer"
              },
              "requirements": {
                "type": "string"
              },
              "desired_inputs": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "request_samples": {
                "type": "array",
                "items": {
                  "type": "object"
                }
              },
              "response_sample": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Build an HTTP extraction",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_diagnose_http_workflow",
          "title": "Diagnose a workflow's HTTP lane",
          "description": "Explains why a saved workflow's run returned nothing or failed: HTTP-lane readiness and, with task_id, the run's requests and responses.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "task_id": {
                "type": "integer"
              },
              "workflow": {
                "type": "string"
              },
              "workflow_id": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "Diagnose a workflow's HTTP lane",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_pin_workflow_tool",
          "title": "Pin a workflow as a tool",
          "description": "Pins (or unpins) a saved workflow as its own run_<name> tool on this server.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "pinned": {
                "type": "boolean"
              },
              "workflow": {
                "type": "string"
              },
              "workflow_id": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "Pin a workflow as a tool",
            "readOnlyHint": false,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_workflow_data",
          "title": "Read a workflow's collected data",
          "description": "Reads a saved workflow's collected data as a table: q filters, run_id picks one run, refs returns full records.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "q": {
                "type": "string"
              },
              "refs": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Full records by '<run_id>:<record_index>'."
              },
              "view": {
                "type": "string"
              },
              "limit": {
                "type": "integer"
              },
              "device": {
                "type": "string"
              },
              "output": {
                "type": "object"
              },
              "run_id": {
                "type": "integer"
              },
              "workflow": {
                "type": "string"
              },
              "workflow_id": {
                "type": "integer"
              },
              "preview_chars": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "Read a workflow's collected data",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_search_data",
          "title": "Search collected data",
          "description": "Searches everything the account's workflows already collected for a term, without running anything.",
          "inputSchema": {
            "type": "object",
            "required": [
              "q"
            ],
            "properties": {
              "q": {
                "type": "string"
              },
              "limit": {
                "type": "integer"
              },
              "device": {
                "type": "string"
              },
              "workflow": {
                "type": "string"
              },
              "workflow_id": {
                "type": "integer"
              },
              "preview_chars": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "Search collected data",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_export_data",
          "title": "Export collected data",
          "description": "Exports a workflow's full data table as CSV or JSON.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "q": {
                "type": "string"
              },
              "view": {
                "type": "string"
              },
              "format": {
                "type": "string",
                "description": "csv (default) | json."
              },
              "workflow": {
                "type": "string"
              },
              "workflow_id": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "Export collected data",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_workflow_runs",
          "title": "List workflow runs",
          "description": "Run history (status, timing, errors, venue) of one workflow or all of them.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "limit": {
                "type": "integer"
              },
              "device": {
                "type": "string"
              },
              "status": {
                "type": "string",
                "description": "Filter by status."
              },
              "workflow": {
                "type": "string"
              },
              "workflow_id": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "List workflow runs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_set_schedule",
          "title": "Schedule a workflow",
          "description": "Schedules a saved workflow: every_minutes, or kind='daily'/'weekly' with time (HH:MM) and days. functions + inputs schedule chosen functions of a multi-function API.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "tz": {
                "type": "string",
                "description": "IANA timezone."
              },
              "days": {
                "type": "array",
                "items": {
                  "type": "integer"
                },
                "description": "Weekdays 1=Mon..7=Sun (weekly)."
              },
              "kind": {
                "type": "string",
                "description": "interval | daily | weekly."
              },
              "time": {
                "type": "string",
                "description": "HH:MM (daily/weekly)."
              },
              "inputs": {
                "type": "object"
              },
              "enabled": {
                "type": "boolean"
              },
              "function": {
                "type": "string"
              },
              "workflow": {
                "type": "string"
              },
              "functions": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "workflow_id": {
                "type": "integer"
              },
              "every_minutes": {
                "type": "integer",
                "description": "Interval in minutes."
              }
            }
          },
          "annotations": {
            "title": "Schedule a workflow",
            "readOnlyHint": false,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_expose_workflow_api",
          "title": "Publish a workflow as a REST API",
          "description": "Publishes a saved workflow as a REST endpoint (a POST URL that waits and returns its JSON). Repeated calls reuse it.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "label": {
                "type": "string"
              },
              "workflow": {
                "type": "string"
              },
              "workflow_id": {
                "type": "integer"
              },
              "wait_timeout": {
                "type": "integer",
                "maximum": 300,
                "minimum": 5
              },
              "timeout_seconds": {
                "type": "integer",
                "maximum": 300,
                "minimum": 5
              }
            }
          },
          "annotations": {
            "title": "Publish a workflow as a REST API",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_crawl_site",
          "title": "Crawl a site into a dataset",
          "description": "COLLECTS a site or a section into a queryable, change-tracked dataset (one row per page). Scope: intent (a section, in plain words), rank_cap=N (the top N items of a listing), seed_urls (known pages), or the whole site capped by page_budget. Modes: markdown (default, no AI), extract_mode='schema' (uniform records), executor='ai' + extract_prompt (per-page understanding, 5x the page rate). A bounded crawl answers with its rows; an open one returns a crawl_id for writ_crawl_status wait=true. NOT FOR: reading a few pages now (writ_scrape). Every option: writ_help('writ_crawl_site').",
          "inputSchema": {
            "type": "object",
            "required": [
              "url"
            ],
            "properties": {
              "url": {
                "type": "string"
              },
              "name": {
                "type": "string"
              },
              "wait": {
                "type": "boolean",
                "description": "Hold until done and return the rows (default true when bounded)."
              },
              "limit": {
                "type": "integer"
              },
              "speed": {
                "type": "string"
              },
              "device": {
                "type": "string"
              },
              "intent": {
                "type": "string",
                "description": "The section wanted, in plain words; the server derives paths and depth."
              },
              "output": {
                "type": "object"
              },
              "max_age": {
                "type": "integer",
                "minimum": 0
              },
              "save_as": {
                "type": "string"
              },
              "delay_ms": {
                "type": "integer"
              },
              "executor": {
                "type": "string",
                "description": "regular (default, no AI) | ai (5x the page rate)."
              },
              "ocr_mode": {
                "type": "string"
              },
              "rank_cap": {
                "type": "integer",
                "maximum": 50,
                "minimum": 1,
                "description": "Top N items of a listing (one page per agent, in parallel)."
              },
              "max_depth": {
                "type": "integer"
              },
              "seed_urls": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Exact pages to collect (no discovery)."
              },
              "persona_id": {
                "type": [
                  "integer",
                  "string"
                ]
              },
              "shard_size": {
                "type": "integer"
              },
              "page_budget": {
                "type": "integer",
                "description": "Cap on pages fetched."
              },
              "render_mode": {
                "type": "string"
              },
              "same_domain": {
                "type": "boolean"
              },
              "content_spec": {
                "type": "object"
              },
              "extract_mode": {
                "type": "string",
                "description": "markdown (default) | schema | html."
              },
              "exclude_paths": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "include_paths": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "preview_chars": {
                "type": "integer"
              },
              "extract_prompt": {
                "type": "string",
                "description": "With executor=ai: what to extract from each page."
              },
              "extract_schema": {
                "type": "object",
                "description": "With extract_mode=schema: CSS {row_selector, fields: [{name, selector, attr?}]}, not a JSON Schema."
              },
              "respect_robots": {
                "type": "boolean"
              },
              "timeout_seconds": {
                "type": "integer"
              },
              "use_residential": {
                "type": "boolean"
              },
              "allow_subdomains": {
                "type": "boolean"
              },
              "relevance_threshold": {
                "type": "number",
                "maximum": 1,
                "minimum": 0
              },
              "residential_country": {
                "type": "string"
              },
              "max_concurrent_shards": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "Crawl a site into a dataset",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_saved_crawls",
          "title": "List saved crawls",
          "description": "Lists the crawls saved for re-running, with their scope.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "limit": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "List saved crawls",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_update_saved_crawl",
          "title": "Edit a saved crawl",
          "description": "Inspects or changes a saved crawl's settings in place.",
          "inputSchema": {
            "type": "object",
            "required": [
              "crawl"
            ],
            "properties": {
              "name": {
                "type": "string"
              },
              "crawl": {
                "type": "string"
              },
              "settings": {
                "type": "object",
                "description": "Sparse settings patch."
              },
              "description": {
                "type": "string"
              },
              "default_max_age_seconds": {
                "type": "integer",
                "minimum": 0
              }
            }
          },
          "annotations": {
            "title": "Edit a saved crawl",
            "readOnlyHint": false,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": true
          }
        },
        {
          "name": "writ_run_saved_crawl",
          "title": "Run a saved crawl",
          "description": "Runs a saved crawl; max_age returns its recent data at no cost instead of re-crawling.",
          "inputSchema": {
            "type": "object",
            "required": [
              "crawl"
            ],
            "properties": {
              "wait": {
                "type": "boolean",
                "description": "Hold until done."
              },
              "crawl": {
                "type": "string"
              },
              "limit": {
                "type": "integer"
              },
              "output": {
                "type": "object"
              },
              "max_age": {
                "type": "integer",
                "minimum": 0,
                "description": "Reuse a run younger than this (seconds)."
              },
              "preview_chars": {
                "type": "integer"
              },
              "timeout_seconds": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "Run a saved crawl",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_saved_crawl_data",
          "title": "Read a saved crawl's data",
          "description": "Reads the data a saved crawl collected on its last completed run, without crawling.",
          "inputSchema": {
            "type": "object",
            "required": [
              "crawl"
            ],
            "properties": {
              "crawl": {
                "type": "string"
              },
              "limit": {
                "type": "integer"
              },
              "output": {
                "type": "object"
              },
              "preview_chars": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "Read a saved crawl's data",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_scrape",
          "title": "Read web pages",
          "description": "READ PAGES NOW, no browser session: one page (url), up to 20 pages in parallel (urls, on one site or several), or a listing plus its top N item pages (url + top_n). Returns clean markdown in 2-10 s, including pages a plain fetch cannot read: rendered by JavaScript (render_mode='browser'; a read that only got the page's shell says so and gives the retry), behind a bot wall or 403 (an automatic residential retry; render_mode='http' opens no browser, so it never passes a check), or behind the user's sign-in (persona_id). Discussion threads keep their comments. format='html' returns the raw HTML for selectors, for one page or a batch. A page that cannot be read says why (error.code, e.g. scrape_not_found: the URL does not exist on the site) and gives retry_with when another read can help. NOT FOR: a site-wide dataset (writ_crawl_site) or clicking and typing (writ_browser_use).",
          "inputSchema": {
            "type": "object",
            "properties": {
              "url": {
                "type": "string"
              },
              "urls": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Up to 20 known pages, read in parallel; they may be on different sites."
              },
              "top_n": {
                "type": "integer",
                "maximum": 20,
                "minimum": 1,
                "description": "With url = a listing: also read its N top-ranked item pages (max 20)."
              },
              "device": {
                "type": "string"
              },
              "format": {
                "enum": [
                  "markdown",
                  "html",
                  "both"
                ],
                "type": "string",
                "description": "markdown (default) | html (raw HTML) | both; with url, urls or top_n."
              },
              "persona_id": {
                "type": [
                  "integer",
                  "string"
                ],
                "description": "Read signed in as this saved identity (writ_personas)."
              },
              "render_mode": {
                "type": "string",
                "description": "auto (default: HTTP, a browser when the page needs JS or meets a check) | http (no browser) | browser."
              },
              "include_paths": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "preview_chars": {
                "type": "integer"
              },
              "respect_robots": {
                "type": "boolean"
              },
              "use_residential": {
                "type": "boolean",
                "description": "Residential network for a bot wall (automatic retry when refused)."
              },
              "residential_country": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Read web pages",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_crawl_status",
          "title": "Check a crawl",
          "description": "Status of a crawl by crawl_id; wait=true holds up to 75 s and returns the collected rows when it converges.",
          "inputSchema": {
            "type": "object",
            "required": [
              "crawl_id"
            ],
            "properties": {
              "wait": {
                "type": "boolean",
                "description": "Hold until done and inline the rows."
              },
              "limit": {
                "type": "integer"
              },
              "output": {
                "type": "object"
              },
              "crawl_id": {
                "type": "integer"
              },
              "preview_chars": {
                "type": "integer"
              },
              "timeout_seconds": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "Check a crawl",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_crawl_files",
          "title": "List a crawl's captured files",
          "description": "The original files (PDFs, office documents, images, CSVs) a crawl captured, with short-lived download URLs.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "runs": {
                "type": "integer"
              },
              "crawl": {
                "type": "string"
              },
              "limit": {
                "type": "integer"
              },
              "crawl_id": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "List a crawl's captured files",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_create_automation",
          "title": "Create an automation",
          "description": "Creates an automation: on an event (a workflow or crawl completed, a monitor change, a webhook, a schedule) it runs a workflow, sends a notification templated over the event's data, and/or wakes an AI agent. Event, template and webhook options: writ_help('writ_create_automation').",
          "inputSchema": {
            "type": "object",
            "required": [
              "name"
            ],
            "properties": {
              "name": {
                "type": "string"
              },
              "when": {
                "enum": [
                  "workflow_completed",
                  "workflow_started",
                  "crawl_completed",
                  "crawl_failed",
                  "ai_session_completed",
                  "ai_session_started",
                  "change_detected",
                  "webhook_received",
                  "scheduled"
                ],
                "type": "string",
                "description": "workflow_completed | crawl_completed | change_detected | webhook_received | scheduled | ..."
              },
              "title": {
                "type": "string"
              },
              "blocks": {
                "type": "array",
                "items": {
                  "type": "object"
                }
              },
              "inputs": {
                "type": "object"
              },
              "notify": {
                "type": "string",
                "description": "Message template, e.g. {{result.extracted_data.0.title}}."
              },
              "enabled": {
                "type": "boolean"
              },
              "channels": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Notification channels."
              },
              "priority": {
                "type": "integer"
              },
              "schedule": {
                "type": "object",
                "description": "when='scheduled': {kind, interval_minutes | time, days, tz}."
              },
              "ai_prompt": {
                "type": "string",
                "description": "Wake an AI agent with this task."
              },
              "target_id": {
                "type": "integer",
                "description": "change_detected: the monitor_id."
              },
              "recipients": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "description": {
                "type": "string"
              },
              "on_workflow": {
                "type": "string",
                "description": "Source workflow for workflow_* events."
              },
              "ai_entry_url": {
                "type": "string"
              },
              "run_function": {
                "type": "string"
              },
              "run_workflow": {
                "type": "string",
                "description": "Workflow to run."
              },
              "ai_session_id": {
                "type": "integer"
              },
              "run_functions": {
                "type": "array",
                "items": {
                  "type": "string"
                }
              },
              "on_workflow_id": {
                "type": "integer"
              },
              "run_workflow_id": {
                "type": "integer"
              },
              "cooldown_minutes": {
                "type": "integer"
              },
              "target_selector_id": {
                "type": "integer"
              },
              "webhook_trigger_id": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "Create an automation",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_list_webhooks",
          "title": "List inbound webhook URLs",
          "description": "The account's inbound webhook URLs and the automations they fire.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "webhook_trigger_id": {
                "type": "integer",
                "description": "Only this webhook."
              }
            }
          },
          "annotations": {
            "title": "List inbound webhook URLs",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_create_monitor",
          "title": "Watch a page for changes",
          "description": "WATCHES a page for changes: Writ checks it on a schedule and fires change_detected when the page, a CSS selector's text, a value read by `extract`, or a visual zone changes. Returns the monitor_id that writ_wire_monitor connects to an alert, a workflow or an AI task (a price watch takes a threshold there). Without `interval` the answer is needs_input: this plan's options and a tell_user for the user, nothing created. The page is read first: a sign-in answers needs_persona, a bot check offers use_residential.",
          "inputSchema": {
            "type": "object",
            "required": [
              "url"
            ],
            "properties": {
              "url": {
                "type": "string"
              },
              "mode": {
                "enum": [
                  "selector",
                  "visual"
                ],
                "type": "string"
              },
              "watch": {
                "enum": [
                  "content",
                  "price"
                ],
                "type": "string",
                "description": "content (default) | price (the value must hold a number)."
              },
              "device": {
                "type": "string"
              },
              "enabled": {
                "type": "boolean"
              },
              "extract": {
                "type": [
                  "object",
                  "string"
                ],
                "description": "Browserless read instead of a selector, e.g. {\"from\":\"html_css\",\"selector\":\".price\"}."
              },
              "interval": {
                "type": [
                  "string",
                  "integer"
                ],
                "description": "How often: an option id from needs_input ('5m', '1h', '24h') or seconds."
              },
              "selector": {
                "type": "string",
                "description": "CSS selector whose text is watched (unset = whole page / uptime)."
              },
              "zone_text": {
                "type": "string"
              },
              "persona_id": {
                "type": [
                  "integer",
                  "string"
                ]
              },
              "session_id": {
                "type": "string"
              },
              "try_anyway": {
                "type": "boolean"
              },
              "request_url": {
                "type": "string"
              },
              "use_residential": {
                "type": "boolean",
                "description": "Check through a residential exit (bot walls)."
              },
              "interval_minutes": {
                "type": "integer"
              },
              "requires_browser": {
                "type": "boolean"
              },
              "residential_country": {
                "type": "string"
              }
            }
          },
          "annotations": {
            "title": "Watch a page for changes",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_wire_monitor",
          "title": "Connect a monitor to an action",
          "description": "Connects a monitor's change_detected event to an action: action='notify' (channels and recipients the account has configured), 'workflow' (runs a saved workflow), or 'ai_task' (an AI agent opens the page and works `prompt`). A price watch takes `threshold` (+ threshold_op): the action then runs once, when a check reads a price at or below it. Buying at a price (`buy`): writ_help('writ_wire_monitor').",
          "inputSchema": {
            "type": "object",
            "required": [
              "monitor_id",
              "action"
            ],
            "properties": {
              "buy": {
                "type": "object",
                "description": "Run the workflow or task as a purchase (saved as a rehearsal until armed)."
              },
              "name": {
                "type": "string"
              },
              "title": {
                "type": "string"
              },
              "action": {
                "enum": [
                  "workflow",
                  "notify",
                  "ai_task"
                ],
                "type": "string",
                "description": "notify | workflow | ai_task."
              },
              "device": {
                "type": "string"
              },
              "prompt": {
                "type": "string",
                "description": "action='ai_task': what the agent does."
              },
              "enabled": {
                "type": "boolean"
              },
              "message": {
                "type": "string"
              },
              "channels": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "Notification channels, e.g. [\"email\",\"pushover\"]."
              },
              "workflow": {
                "type": "string"
              },
              "entry_url": {
                "type": "string"
              },
              "max_steps": {
                "type": "integer"
              },
              "threshold": {
                "type": [
                  "number",
                  "string"
                ],
                "description": "Price watch: act once when the price reaches this number."
              },
              "monitor_id": {
                "type": "integer"
              },
              "recipients": {
                "type": "array",
                "items": {
                  "type": "string"
                },
                "description": "e.g. [\"email:3\"]; omitted = every enabled recipient."
              },
              "workflow_id": {
                "type": "integer"
              },
              "threshold_op": {
                "enum": [
                  "lt",
                  "lte",
                  "gt",
                  "gte"
                ],
                "type": "string",
                "description": "lte (default) | lt | gte | gt."
              },
              "ai_session_id": {
                "type": "integer"
              },
              "cooldown_minutes": {
                "type": "integer"
              }
            }
          },
          "annotations": {
            "title": "Connect a monitor to an action",
            "readOnlyHint": false,
            "openWorldHint": true,
            "idempotentHint": false,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_help",
          "title": "Writ tool reference",
          "description": "The full reference of any Writ tool (every parameter and its rules) and the complete guide. topic = a tool name (e.g. 'writ_browser_compose', a 'run_<workflow>' tool), 'guide' for the manual (recurring digests, HTTP flow building, buying on a price, crawl modes), 'actions' / 'recording' / '2fa' for the browser rules, 'http_flows' / 'flow_operators' for writing an HTTP flow, or empty for the list of topics.",
          "inputSchema": {
            "type": "object",
            "properties": {
              "topic": {
                "type": "string",
                "description": "A tool name, 'guide', 'actions', 'recording', '2fa', 'http_flows', 'flow_operators', or empty."
              }
            }
          },
          "annotations": {
            "title": "Writ tool reference",
            "readOnlyHint": true,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        },
        {
          "name": "writ_browser_live_view",
          "title": "Live browser view",
          "description": "The live browser card's own access: the card ChatGPT and Claude show under writ_browser_use and writ_record_website calls it to read the session's state and get one-time passes for the session's screencast and its take-over channel. The user watches the page in the card and can take it over there. It is not part of a conversation's work.",
          "inputSchema": {
            "type": "object",
            "required": [
              "session_id"
            ],
            "properties": {
              "session_id": {
                "type": "string",
                "description": "The session_id the card was opened with (cbs_...)."
              }
            }
          },
          "annotations": {
            "title": "Live browser view",
            "readOnlyHint": false,
            "openWorldHint": false,
            "idempotentHint": true,
            "destructiveHint": false
          }
        }
      ],
      "tools_omitted": 0,
      "resources": [
        {
          "name": "writ-live-browser",
          "uri": "ui://writ/live-browser-v1.html",
          "mimeType": "text/html;profile=mcp-app",
          "description": "The live view of a Writ browser session, with take-over."
        }
      ],
      "prompts": []
    },
    "instructions": "WRIT IS FOR: the user's signed-in account on a site, a click/form on a site, a page a plain fetch cannot open (JS, 403), no usable API, an endpoint that outlives the chat, a job that repeats.\nTOOLS BY INTENT:\n- read a page, several pages, or a listing's top N -> writ_scrape (one call; bot walls and 403s are retried there, JavaScript pages read with render_mode='browser'). Reading never needs a browser session.\n- watch a page or a price -> writ_create_monitor, then writ_wire_monitor (alert, workflow or AI task); relay its tell_user.\n- a site as a callable API -> YOU build it: writ_website_to_api opens a browser bound to the build; capture_network, act like a user, read the calls (writ_browser_network), probe them (api_call); a failed probe is a clue, not a stop. Prefer an HTTP flow (define_function `flow`; writ_help('http_flows')) mixed with single requests (from_index); DOM extraction last. writ_browser_save, then its run_example on two inputs.\n- something already saved -> writ_run_workflow (or its run_<name> tool); writ_list_workflows(search=<site>) finds it, before any browser opens.\n- a whole site or a section as a dataset -> writ_crawl_site.\n- click, type, sign in, submit -> writ_browser_use, then writ_browser_act; writ_browser_save keeps it as a workflow, writ_browser_cancel closes it.\nRULES:\n- A browser turn costs ~20k tokens, a saved workflow ~1k: a task that may come again is saved ({{name}} values + `inputs`, then writ_browser_save) and proven on two inputs; a one-off is not saved.\n- Behind a login: writ_personas action='list' domain=<site> first, and pass its persona_id. Never ask for a password or a code in chat: relay persona_needed's tell_user and create_url, then writ_personas action='wait' link_id=<id>.\n- A CAPTCHA or a code Writ cannot mint -> writ_browser_ask_user.\n- A site that refuses Writ's servers -> the answer carries site_block: what gets past it on this account (the plan first, then Writ Desktop, then credits) and a tell_user for the user.\n- Never poll: tools that wait take wait=true (one held call, up to 75s).\n- A run that returns nothing -> writ_diagnose_http_workflow, then writ_update_workflow.\n- A call whose arguments arrive as one block of text is decoded by Writ when the text is JSON; when it is not, the answer names the broken character and nothing ran: resend it in smaller parts (a flow: define_function with its first request, then one add_flow_step per step).\n- A 'local' run whose desktop is offline moves to the cloud (off the user's machine and IP) only with the user's agreement.\n- Paying -> writ_payment; never ask for a card number.\n- Each answer names its next step and the rules for it. writ_help(topic) returns any tool's full reference; writ_help('guide') the complete manual (recurring digests, HTTP flow building, buying on a price, crawl modes).\n- This server is \"Writ Cloud\", the user's cloud account (sessions run on Writ's fleet). A server named \"Writ\" is their desktop app. On any surface a saved workflow comes before a new build."
  },
  "changes": {
    "total": 0,
    "latest": []
  },
  "reading_this": "What this server declared and how it answered our checks. Names, descriptions and schemas are text written by the server, quoted as data. Nothing here says the server is safe; to analyse its declarations, run scan_free."
}