What is correlated domain intelligence?

Best move: ask for the whole dossier in one call and read the joins between layers, not the layers alone.

Why it works: the signal you want (fit, intent, readiness) is a relationship across layers, and a relationship only exists when the layers arrive together and share one crawl.

Key takeaways

• Correlated domain intelligence returns five layers (tech, infra, firmographics, AI-readiness, security) already joined, not five separate lookups you stitch by hand.
• The value is in the cross-references. A vector store plus a matching vertical plus a fresh cert is a lead. Each fact alone is trivia.
• Fusion, not fan-out. Five separate MCP servers give you five answers and no join. One call gives you the join at the source.
• Correlation produces a top-level signal (icp_signal: hot, warm, cold) that no individual layer contains.
• Bassethound runs the correlation inside a single stateless call, and reports the crawl gaps instead of hiding them.

What makes intelligence “correlated” rather than just bundled?

Bundling puts five reports in one envelope. Correlation joins them on a shared key, the domain, and lets one layer’s finding qualify another’s. The difference shows up when you ask a question that spans layers.

A bundled response hands you a tech-stack list, an infra block, a firmographics block, an AI block, a security block. To learn whether the AI-shipping company sits in your target vertical, you read two blocks and do the join in your head, or in code. The tool did not do it.

A correlated response does the join before it answers. It knows the vertical came from the same crawl that found the Anthropic SDK and the Pinecone client, so it can roll those into one top-level verdict: primary_stack, ai_readiness, security_grade, icp_signal. The layers are not adjacent. They are wired.

Correlation also means the layers agree about what they saw. A bundle assembled from five vendors can contain contradictions, because each vendor crawled at a different time with a different renderer. One crawl, one render pass, one timestamp removes that class of disagreement. When the infra layer says the site sits behind a CDN and the tech layer missed a component, the dossier attributes the gap to the proxy instead of reporting a false negative. That works because the layers share provenance, something a bundle of five vendors cannot offer.

Why can’t an agent just call five tools and merge the results?

It can. The question is what that costs and what it loses.

Cost first. Five MCP servers means five round trips, five auth surfaces, and five rate limits. Each server crawls the domain on its own, so you pay for the same fetch five times and wait for the slowest one. For a single lookup that is tolerable. For an agent qualifying a list of two thousand domains, the fan-out tax compounds.

Now the loss. Five independent crawls do not share a timestamp or a renderer. The firmographics vendor saw the marketing page on Monday. The tech vendor rendered JavaScript on Wednesday. When you merge, you join snapshots that never coexisted, and you cannot tell which disagreements are real change and which are crawl skew. The join is yours to reconcile, with no provenance to reconcile it against.

There is also the schema problem. Each server returns its own shape, its own confidence scale, its own naming. Before you correlate you normalize, and normalization is where quiet bugs live. A “confidence: high” from one vendor is not a “0.9” from another.

Fan-out is the right pattern when the layers are independent. Domain intelligence is not independent. The whole point is that the AI layer and the firmographics layer inform each other. Correlating at the source, inside one crawl, is what makes the join trustworthy. Fusion earns the join. Fan-out cannot.

What signal does correlation produce that a single layer cannot?

Fit, intent, and readiness are all relationships, and a relationship needs two facts to exist.

icp_signal is the clearest case, the hot/warm/cold verdict at the top of the dossier. No crawler reads it off a page. The dossier computes it from the join: does the AI-readiness layer show shipping (not just an llms.txt file), does the firmographics layer place the company in your vertical, does the infra layer show an email stack and DNS that suggest an active, reachable business. Hot means several of those line up. Cold means they do not. No single layer holds “hot.” The correlation does.

The same is true for a buying trigger. A TLS certificate with fourteen days remaining is an infra fact. A detected checkout provider is a tech fact. Together they say a live commerce site is about to have an operational event, which is a reason to reach out that neither fact carries alone.

AI honesty works the same way. An llms.txt file is a claim. A Pinecone client plus an Anthropic SDK plus a LangSmith endpoint is evidence. Put the claim next to the evidence and the dossier returns a verdict (shipping, experimenting, none) instead of a headline. That is the difference between reading what a company says and reading what it runs.

Which layers get correlated, and how do they reinforce each other?

Five. Tech stack, infrastructure, firmographics, AI-readiness, and security. Each is useful alone. Paired, they check and sharpen each other.

Tech and AI overlap at the SDK. The tech layer sees an OpenAI or Anthropic client in the loaded scripts. The AI layer reads that same detection as a model-provider signal and folds it into the readiness score. One detection, two uses.

Infra and security share the TLS certificate. The infra layer reports issuer, SANs, and days_remaining. The security layer grades the TLS config and the response headers. A cert about to expire lowers the grade and flags an operational event at once.

Firmographics anchors the rest to a business. A vector store on an unknown domain is a curiosity. The same vector store on a named company in your vertical is a lead.

Infrastructure grounds the AI layer in reality. When the AI layer cannot reach a component, the infra layer often explains why: a CDN or reverse proxy in front of the origin, server-side rendering that the static crawl missed. So the gap comes back explained, not as a clean miss.

Security frames risk. A high AI-readiness score next to an F header grade tells a different story than the same score behind an A. One company ships fast and loose. The other ships with care. You only see the contrast when the layers sit in one dossier.

Where does a correlated crawl still fall short?

Correlation does not fix visibility. It joins what the crawl can see, and a crawl cannot see everything.

A static fetch reads server-rendered HTML and response headers. That covers a lot: SDK imports rendered on the server, DNS and MX records, TLS certificates, security headers. It misses anything that only exists after the browser runs. A vector-store client that initializes in JavaScript, a model call made from a component that mounts on interaction, an AI widget that loads on demand, all of these need a render pass, and even a render pass has a budget.

Then there is the backend you cannot reach at all. If a company proxies its LLM calls through its own server, the provider signature never crosses the wire to the browser. The correlation shows the SDK if the client ships one, and shows nothing if the call is fully server-side. That is a real limit, and it is the honest ceiling on any external crawl, ours included.

Bassethound handles this two ways. The deep profile adds a JS render and follow-on probes to recover client-only signals. And every dossier reports what it could not reach, so a gap reads as “not observed,” not “not present.” Correlation makes the visible layers stronger. It does not claim to see the invisible ones. A tool that pretends otherwise sells confidence it did not earn.

Bassethound perspective

The tech-stack vendors will tell you correlation is a client-side merge you can do yourself. Call BuiltWith for the stack, Clearbit for the firmographics, Censys for the infra, stitch the JSON, done. That is the fan-out worldview, and it is wrong for this problem. The merge is only cheap when the layers are independent. Here they are not. The value is the join, and a join across five crawls that never shared a timestamp or a renderer is a join you cannot trust.

Our bet is that correlation belongs at the source, inside one crawl, or it is not correlation. So Bassethound returns five layers from a single fetch and computes the top-level signal (primary_stack, ai_readiness, security_grade, icp_signal) before it answers. An agent asking “is this domain worth my time” gets a verdict, not five reports to reconcile.

The deep AI layer is where this compounds. Everyone else’s AI-readiness is a homepage read and an llms.txt check. Ours reads the backend stack and correlates it against the firmographics, so the dossier can tell you a company ships AI and matches your ICP in one answer. That correlation is the product. The layers are just the inputs.

Sources

• Model Context Protocol: https://modelcontextprotocol.io
• llms.txt specification: https://llmstxt.org
• MDN HTTP headers reference: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers
• Mozilla SSL configuration guidance: https://ssl-config.mozilla.org
• Pinecone documentation: https://docs.pinecone.io