One request to every machine interface a domain exposes.

One request to every machine interface a domain exposes.

NessGate is the open, neutral resolver for the agentic web. Give it a domain and it reads whatever that domain already publishes (ARD, A2A, llms.txt, API catalogs, and more) and returns one normalized answer, with a link back to each source so an agent can verify. It can also assess how ready each published endpoint is to connect to — and, given your client's capabilities, return a concrete connection plan (API). One call instead of ten.

`yourdomain.com`→`ARD` `A2A` `llms.txt` `API`→`one answer`

Resolve any domain — see the machine-readable resources the domain publishes:

Resolve

For domain owners

There is nothing to register and no NessGate file to add. Publish the standard files AI already looks for (`llms.txt`, an ARD catalog, an agent card, an API catalog) on your own domain, and NessGate reads them automatically. Your domain always stays the authority; NessGate stores no discovered domain or resource data.

Not sure what AI can see on your site today? Check your domain — it's free, reads only public files, and stores no domain data. The guide walks through adding whatever you're missing.

The reverse direction — describing what an incoming automated caller declares and can prove — is the experimental @nessgate/inspectpackage (0.x): tiered, provenanced facts, no decisions, no scores.

NessGate is neutral infrastructure: free forever, no accounts, and it never sells ranking or placement — because there is none.

For AI agents & developers

One request, no keys, no auth, open CORS. Works whether or not the domain has ever heard of NessGate — it reads what the domain already publishes.

`GET https://nessgate.com/discover/{domain}`Copy

curl JavaScript Python

curl https://nessgate.com/discover/example.com
→ { "resources": [ { "source": "ard-catalog",
      "type": "application/json",
      "url": "https://example.com/ai-info.json",
      "sourceUrl": "https://example.com/.well-known/ard.json" } ], … }

const { resources } = await
  (await fetch("https://nessgate.com/discover/example.com")).json();

import requests
resources = requests.get(
  "https://nessgate.com/discover/example.com").json()["resources"]

Prefer MCP? The same lookups are tools (`discover_domain`, `connect_domain`, `check_readiness`) at `/mcp`. Or run the resolver yourself — an embeddable, dependency-free library (preview) that fetches domains directly with no dependency on nessgate.com:

import { resolve } from "https://nessgate.com/resolver.mjs";
const { resources } = await resolve("example.com");

Or install it from npm:

npm i @nessgate/resolver

View on GitHub ↗ · View on npm ↗

API reference · Specification · OpenAPI · Charter · llms.txt

One domain. Many standards. One trustworthy discovery interface.

Companies keep publishing as they already do

No new format to adopt. NessGate reads the standards a domain already supports (ARD, A2A, llms.txt, API catalogs, and more) in their canonical locations. A new standard is just a new adapter, never a competitor.

Developers integrate once

One request per domain instead of maintaining a separate discovery implementation for every standard. Agents stop probing ten locations and guessing which answer is official — NessGate does it and keeps up with the ecosystem so you don't have to.

Consistent results, with evidence

One normalized answer, each record labeled by how far it was verified and linked back to its source so an agent can check against the domain directly. Open protocol, no lock-in, the domain always stays the authority — plus ongoing compatibility as standards evolve.