What does the sniff_domain tool return?

Best move: read the top-level summary first, then drill into whichever of the five layers you need to justify the call.

Why it works: sniff_domain returns the summary and the five layers together, already correlated, so you branch on one field and audit the evidence behind it without a second call.

Key takeaways

• sniff_domain returns one correlated dossier with five layers: tech stack, infrastructure, firmographics, AI-readiness, and security.
• A top-level summary fuses those layers into primary_stack, an ai_readiness score and verdict, a security_grade, and an icp_signal of hot, warm, or cold.
• The ai_readiness score counts distinct backend signal groups hit, over six, capped at 1.0, with a verdict of shipping, experimenting, or none.
• The profile argument (fast, standard, deep) sets depth and latency without changing the response shape.
• Every detection carries category, confidence, how_detected, and evidence, and the tool marks gaps rather than guessing past them.

What is in the top-level summary?

The summary is the part an agent reads first. It fuses the five layers into four fields you can branch on without parsing the full dossier. primary_stack names the dominant framework or CMS driving the site. ai_readiness carries a score from 0 to 1.0 and a verdict of shipping, experimenting, or none. security_grade is a letter, A through F. icp_signal collapses the whole picture into hot, warm, or cold, so a routing agent scores a lead in one field read.

The summary is a projection, not a replacement. Every claim in it traces back to a specific detection in a layer below, each with its own confidence and evidence. You get the headline for fast branching and the trail for when you need to defend the call to a human or a downstream system. Nothing in the summary is invented above what the layers found. If a signal was weak, the confidence field on the underlying detection says so, and the summary inherits that limit rather than laundering it into a clean answer.

What do the five layers contain?

Layer one is the tech stack: frameworks, CMS, analytics, widgets, payments, ecommerce. Each detection carries a category, version, confidence, how_detected, and evidence. This is the commoditized layer, mirrored cheaply, not the headline.

Layer two is infrastructure: IP, ASN, hosting org, CDN, nameservers, MX records, email provider, DNS TXT vendors, the SPF, DKIM, and DMARC booleans, and the TLS certificate (issuer, SANs, expiry, days_remaining).

Layer three is firmographics: company name, vertical, description, contacts, social profiles, structured data.

Layer four is AI-readiness, the differentiator: model providers, AI SDKs, orchestration frameworks, vector stores, LLM observability, AI widgets, llms.txt, MCP endpoints, and .well-known AI files.

Layer five is security: a header grade from A to F across HSTS, CSP, X-Content-Type-Options, X-Frame-Options, Referrer-Policy, and Permissions-Policy, plus a TLS grade.

They arrive together, correlated, in one response. That correlation is the point. Reading that a site runs a given framework and an Anthropic SDK and a Pinecone client in the same dossier tells you something no single layer does on its own.

How is the ai_readiness score computed?

The score counts distinct signal groups hit, over six, capped at 1.0. The groups are model providers, AI SDKs, orchestration, vector stores, LLM observability, and AI surface (widgets, llms.txt, MCP endpoints, .well-known files). Hit four of six and you score 0.67. Hit all six and you cap at 1.0.

The verdict translates the score into a decision. shipping means the backend fingerprints line up: an SDK loading, a vector store client initializing, an observability endpoint in the network calls. experimenting means surface signals without backend depth, a llms.txt file and a chat widget but no orchestration underneath. none means neither.

This is the axis most tools read shallow. A homepage scan plus a llms.txt check tells you a company wrote about AI. It does not tell you they run it. sniff_domain fingerprints the client libraries and API hostnames that only appear when an application calls a model or a vector store. Backend infrastructure is expensive to stand up and pointless to fake, which makes it the honest signal.

What changes across the fast, standard, and deep profiles?

The profile argument sets depth and latency. fast is deterministic and keyless, roughly one to three seconds. It returns tech stack, infrastructure, and security from a single crawl pass, no follow-on probes.

standard is the default. It adds the AI stack and firmographics, so the ai_readiness layer and the company data fill in. This is the profile most agents want: enough depth to score an ICP, still quick enough for an inline call.

deep adds follow-on probes, the full security grade, and Wayback first-seen history, so you can see when a technology first appeared on the domain. It costs more time and hits more endpoints.

The shape of the response stays stable across profiles. A field a lighter profile did not probe is absent or marked unresolved, not faked. You can start on fast for a cheap triage and escalate to deep only for the domains worth the latency. The profile is a dial on cost and confidence, not a different tool.

What does sniff_domain not return?

Anything it did not observe. Bassethound builds the dossier from a static crawl plus optional JavaScript render. A component that runs fully server-side, or sits behind a proxy, can leave no client-side trail, and sniff_domain cannot see what never reaches the response. It reports these gaps rather than guessing past them.

Detection is signature matching, so a stack that ships no recognizable client code, custom-built with no named library, reads as absent. That is a true negative on evidence, not proof the technology is missing. The confidence fields tell you how strong each call is.

The tool is stateless and read-only. It carries nothing from one call to the next, runs no historical tracking of its own beyond the deep-profile Wayback lookup, and returns no data it did not observe in that request. Every call is self-contained. If you want a time series, you call again and diff. The dossier is a snapshot of what the front end loads and calls right now, with the evidence attached so you can check the work.

Bassethound perspective

Most enrichment is fan-out. You call one API for the tech stack, another for the infrastructure, a third for firmographics, and you glue the results yourself. That glue is the expensive part, and it is where the signal lives. Knowing a site runs Next.js is cheap. Knowing it runs Next.js and an Anthropic SDK and a Pinecone client, correlated in one response, tells you something no single layer does.

Fusion is the moat, not fan-out. An agent can wire up five separate MCP servers, but it cannot cheaply reconstruct the correlation between their answers, and correlation is what turns detections into a verdict. sniff_domain returns the five layers already joined, with a summary that projects them into fields you branch on and evidence you can audit.

We are honest about the edges. A static crawl misses fully server-side components, and the dossier says so. We would rather return a marked gap than a confident guess. The bet is narrow: one keyless call, five correlated layers, deep on the AI axis everyone else reads shallow.

Sources

• Model Context Protocol: https://modelcontextprotocol.io
• llms.txt specification: https://llmstxt.org
• MDN HTTP security headers: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers
• Mozilla SSL Configuration Generator: https://ssl-config.mozilla.org