Scopeweb

Find domain names for an idea. Returns candidate names across every ending, each with the state we can defend: sellable, restricted, not ours to sell, taken, or not checked. Pass the concept, not a domain.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "A word or an idea, for example \"calm inbox\"."
    }
  },
  "required": [
    "query"
  ]
}

Everything we hold about one domain: whether it is registered, what it costs to claim AND what it renews at, and where each number came from. Pass a domain name as the id, for example "atlas.io".

{
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "A domain name."
    }
  },
  "required": [
    "id"
  ]
}

Use this when the user wants a page, site or landing draft for a name and there is nothing to edit yet. Store a draft website in the user's Scopeweb portfolio. Returns a persistent draft_id and a live preview_url. Drafts survive across conversations — use list_drafts in future sessions to resume work. Content is screened on every version; a flagged draft still returns normally here but its preview serves 451.

{
  "type": "object",
  "properties": {
    "name_hint": {
      "type": "string",
      "description": "Working name for the project"
    },
    "description": {
      "type": "string",
      "description": "One paragraph on what this is"
    },
    "files": {
      "type": "array",
      "description": "Site files. index.html required for a browsable preview.",
      "items": {
        "type": "object",
        "properties": {
          "path": {
            "type": "string"
          },
          "content": {
            "type": "string"
          }
        },
        "required": [
          "path",
          "content"
        ]
      }
    }
  },
  "required": [
    "files"
  ]
}

Use this when a draft already exists and the user asks to change its copy, sections or layout. Call get_draft first if you do not have the current text. Update files in an existing draft. Acts as a patch: files you send are written as a new version, files you omit are carried forward unchanged. Previous versions are retained immutably. Returns the new version and preview_url.

{
  "type": "object",
  "properties": {
    "draft_id": {
      "type": "string"
    },
    "files": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "path": {
            "type": "string"
          },
          "content": {
            "type": "string"
          }
        },
        "required": [
          "path",
          "content"
        ]
      }
    }
  },
  "required": [
    "draft_id",
    "files"
  ]
}

List all drafts in the user's Scopeweb portfolio with status, preview URLs and timestamps. Read-only. Cannot spend money. Call this at the start of a session to see existing work.

{
  "type": "object",
  "properties": {}
}

Use this before editing a draft you did not create in this conversation, so you are changing the text that actually exists rather than what you remember. Get a draft's metadata and file list, or a single file's content by passing path. Read-only. Cannot spend money. Use to resume work on a draft from a previous conversation.

{
  "type": "object",
  "properties": {
    "draft_id": {
      "type": "string"
    },
    "path": {
      "type": "string",
      "description": "Optional: return this file's content"
    }
  },
  "required": [
    "draft_id"
  ]
}

Use this when the user claims a domain is theirs and you are about to act on that claim. Ownership asserted in chat is not ownership; this is how it gets proven. Prove the user owns a domain via a DNS TXT challenge. action 'start' returns the TXT record to publish; action 'check' verifies it. Verification is required before a domain appears in list_domains. A failed DNS lookup returns an error, never 'not owned'.

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string"
    },
    "action": {
      "type": "string",
      "enum": [
        "start",
        "check"
      ],
      "description": "Defaults to 'start'."
    }
  },
  "required": [
    "domain"
  ]
}

Use this at the start of any portfolio, renewal or 'what do I own' question, before assuming which names the user holds. List the user's domain inventory: every domain with a verification challenge issued or completed, plus cached liveness, classification, title and expiry. Read-only. Cannot spend money. Includes scan_age_ms so a stale verdict is never mistaken for a fresh one. Use before suggesting the user buy anything.

{
  "type": "object",
  "properties": {}
}

★ START HERE when the user is choosing or inventing a name: it returns candidate names across a namespace. 'suggest names', 'help me name X', 'what should we call it', 'find me a domain for Y'. Give it a CONCEPT (a word or short phrase) and it generates and ranks candidates around it, classified by what is actually free. Read-only. Cannot spend money. (Renamed from browse_namespace on 2026-09-09: the old name described the mechanism, so assistants looking for a way to SUGGEST NAMES never matched it and invented candidates from their own heads instead.) Use scan_namespace instead when you already have an explicit list. Follow this with score_name to rank, and check_live LAST as the purchase gate. Re-querying the same scan_id walks deeper into the namespace and converges over about 3 calls. Unregistered does not mean purchasable: reserved and premium names answer the registry the same way. Only a registrar quote settles a price. PRICES ARE IDENTICAL FOR ALL BUYERS REGARDLESS OF BUDGET. A budget changes which candidates are recommended and how they are ordered; it never changes what anything costs.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "A word, name or idea, e.g. 'stowed'"
    },
    "tlds": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Defaults to com/io/ai/app/dev/co."
    },
    "limit": {
      "type": "number",
      "description": "Candidates per page, max 50 (default 25)"
    },
    "offset": {
      "type": "number",
      "description": "Walk deeper into the expansion"
    },
    "scan_id": {
      "type": "string",
      "description": "Resume a previous browse; replaces query/tlds"
    }
  }
}

{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "description": "Candidate names with availability where known."
    },
    "query": {
      "type": "string"
    },
    "scan_id": {
      "type": "string",
      "description": "Re-query this to walk deeper into the namespace."
    },
    "unprobed": {
      "type": "integer",
      "description": "Candidates whose availability was NOT checked. Never read as free."
    }
  },
  "required": [
    "results",
    "query",
    "scan_id"
  ]
}

Use this when the user is choosing between names, or asks whether a name is any good. Not for deciding availability, which is check_live. Grade candidate names on measurable properties of the string: length, syllables, pronounceability (the radio test), presence in a published English word list, edit distance to major brands, hyphens/digits, and TLD perception. Read-only. Cannot spend money. Every component returns its score, weight and basis so the number can be audited rather than trusted. Severe properties CAP the total instead of being averaged away — a name one edit from a major brand cannot score well however short it is. EXPLICITLY NOT a search-ranking prediction: exact-match-domain SEO value has been largely dead since Google's 2012 EMD update and nothing here forecasts how a name will rank. NOT a trademark search: brand_collision is string similarity to a published list, not legal clearance. Components that cannot be measured (zone rarity, trademark) are returned as unavailable with reasons and never estimated.

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string",
      "description": "A single domain, e.g. 'forge.com'"
    },
    "domains": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Up to 10 domains; returned ranked best-first"
    }
  }
}

{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "description": "Scored names, highest first, each showing its working."
    },
    "score_version": {
      "type": "integer"
    }
  },
  "required": [
    "results"
  ]
}

Classify an explicit list of candidate domains (max 25). Read-only. Cannot spend money. Use suggest_names instead when you have a concept rather than a list. Returns registered, resolves, serves, parked, classification and liveness for each.

{
  "type": "object",
  "properties": {
    "candidates": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Full domain names, max 25."
    }
  },
  "required": [
    "candidates"
  ]
}

⛔ THE LAST GATE, NOT THE FIRST STEP. Use this to CONFIRM a name immediately before acting on it, after suggest_names has generated candidates and score_name has ranked them. It answers only 'is this registered', and it will answer just as confidently for a list you invented as for one this service helped you build -- so a clean result here says nothing about whether the name is any good, or whether a better one sits next to it. If none of the names you pass have been seen by suggest_names or scan_namespace, the response says so and points you back. Use this immediately before you recommend buying anything, and any time an earlier answer said 'unknown', 'pending' or 'unprobed'. Those are never registration claims. Real-time authoritative registration check for up to 10 domains via RDAP. Read-only. Cannot spend money. This is the final gate before recommending a purchase — never rely on cached or older scan results for buying decisions. It answers whether a registration EXISTS, not whether the name can be bought or at what price: reserved and premium names return 404 here too. Registration-only: it does not fetch the site, so it returns 'registered' rather than 'active' or 'dormant'.

{
  "type": "object",
  "properties": {
    "domains": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "domains"
  ]
}

{
  "type": "object",
  "properties": {
    "results": {
      "type": "array",
      "description": "One row per domain asked about, with its verdict and evidence grade."
    }
  },
  "required": [
    "results"
  ]
}

Use this when the user asks what is wrong with a site they already own, or wants a name they hold assessed rather than a new one found. Fetch a live domain's observable surface: HTTP status, redirect target, title, meta description, h1 headings and tech hints. Read-only. Cannot spend money. Use to compare what is actually deployed against a spec, or to check whether a domain serves anything at all.

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string"
    }
  },
  "required": [
    "domain"
  ]
}

Use this when the user states a spending limit for a project. It records their ceiling; it never authorises a purchase. Set a monthly or yearly budget for a project, in cents. Records a number you chose. Cannot spend money and cannot buy anything. The response comes back with the project's CURRENT CARRY and HEADROOM already computed, because a budget with no carry beside it is a number rather than information. Headroom is flagged `partial` whenever the project contains a domain whose renewal price is unknown — a renewal we cannot price is counted as unknown, NEVER as zero, so headroom is an upper bound in that case and real headroom is lower.PRICES ARE IDENTICAL FOR ALL BUYERS REGARDLESS OF BUDGET. A budget changes what is recommended and how results are ordered; it never changes what anything costs.

{
  "type": "object",
  "properties": {
    "project_id": {
      "type": "string"
    },
    "period": {
      "type": "string",
      "enum": [
        "monthly",
        "yearly"
      ]
    },
    "amount_cents": {
      "type": "integer"
    }
  },
  "required": [
    "project_id",
    "period",
    "amount_cents"
  ]
}

Use this before recommending anything with a price, so the numbers you quote are this account's real ones rather than list prices. The fiduciary readout for a project: the budget, per-domain renewal costs, total known carry, how many domains have UNKNOWN renewal costs, and the remaining headroom. Read-only. Cannot spend money. Read `carry_unknown_count` before quoting headroom to anyone: domains held at another registrar renew at that registrar's price list, which we cannot see, so their cost is reported as unknown with `reason: foreign_registrar_pricing` — never guessed, never zero. Where we can price a transfer to us, it appears as `alternative.transfer_in_price` and is explicitly NOT their renewal price. When `partial` is true, headroom is an UPPER BOUND and the true figure is lower.

{
  "type": "object",
  "properties": {
    "project_id": {
      "type": "string"
    }
  },
  "required": [
    "project_id"
  ]
}

Use this to understand how something works before explaining it. Do NOT use it to decide anything: registry policy and registration status come from the dedicated tools, and they win. Semantic search over a small curated corpus: this system's own documentation and methodology, ICANN policy, and per-registry policy documents. Read-only. Cannot spend money. Returns passages with the source, its URL, and what that source may be cited FOR. THIS IS RETRIEVAL, NOT AUTHORITY. A vector search always returns its nearest neighbour, so it always looks confident; nearness is not correctness, and a passage being returned is not evidence that it answers you. Use it to understand how something works. Do NOT use it to decide anything: registry policy comes from GET /tld/:tld/policy, which carries per-field citations and marks unverified fields as unknown, and registration status comes from check_live via RDAP/WHOIS. If those two disagree with a passage here, they win.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string"
    },
    "top_k": {
      "type": "integer"
    }
  },
  "required": [
    "query"
  ]
}

Use this when the user asks what a tier costs or bumps into a limit, so the answer is this account's actual plan rather than a guess. Show the available plans with what each includes, plus the caller's current tier and any allowance they have used. Read-only. Cannot spend money — it displays pricing and cannot start, change or cancel a subscription. Call this when a refusal names it as the recovery: an allowance is exhausted and the user is deciding what to do about it. PLANS GATE DEPTH, NEVER TRUTH — the registration verdict, its rdap_source and a domain's price are identical on every tier, and the response lists exactly what does not vary. Paying buys more of the picture, never a different answer about reality, so never present an upgrade as a way to get a better verdict.

{
  "type": "object",
  "properties": {}
}

Use this when the user has chosen a name and wants the real price. It returns a confirm_url for the human to complete. It is NOT a purchase and you cannot make one. Get a real price for a name you believe is unregistered. Reads prices only. Cannot spend money — there is deliberately no tool in this server that can complete a purchase. Re-runs the authoritative gate first: a name that is registered, or whose status cannot be authoritatively determined, is never quoted. Returns total_cents, renewal_cents, an expiry, and a confirm_url. THE CONFIRM URL IS NOT A PURCHASE — it opens a page where a human must type the domain to authorise the charge. There is deliberately no tool to complete an order. An agent using this surface has no verb that spends, so nothing here needs obeying. Premium names are quoted at their real price or refused; they are never sold at the TLD base rate. An expired quote is re-quoted, never honoured.PRICES ARE IDENTICAL FOR ALL BUYERS REGARDLESS OF BUDGET — passing a project_id adds budget CONTEXT (does it fit, what is left after) and never changes the number.

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string",
      "description": "The name to price, e.g. 'stoff.fit'."
    },
    "project_id": {
      "type": "string",
      "description": "Optional. Adds budget CONTEXT to the answer (does it fit, what is left after). It never changes the price."
    }
  },
  "required": [
    "domain"
  ]
}

{
  "type": "object",
  "properties": {
    "domain": {
      "type": "string"
    },
    "quotable": {
      "type": "boolean",
      "description": "False means we will not sell it; read message and what_to_do."
    },
    "confirm_url": {
      "type": "string",
      "description": "A page where a HUMAN completes the purchase. Not a purchase."
    },
    "quote_id": {
      "type": "string"
    },
    "annual_commitment_cents": {
      "type": "integer",
      "description": "What it costs to KEEP, every year."
    },
    "quote_expires_at": {
      "type": "integer"
    },
    "contract": {
      "type": "string",
      "description": "Who may spend. An agent may not."
    },
    "message": {
      "type": "string"
    },
    "what_to_do": {
      "type": "string"
    }
  },
  "required": [
    "domain",
    "quotable"
  ]
}