How do you compare two companies' tech stacks?

Best move: run identical detection on both domains, then diff by layer, not by a flat list.

Why it works: a comparison is fair only when both sides pass through the same detector at the same depth. Then every difference in the output traces to the sites, not the scanner.

Key takeaways

• A valid comparison runs one detection method on both domains. Mixing tools invents differences that come from the scanner, not the sites.
• Diff by layer (tech, infrastructure, firmographics, AI-readiness, security), not by a flat feature list. A framework gap and a hosting gap mean different things.
• The AI-readiness layer separates two companies that look identical on a surface tech scan.
• Confidence and how_detected ride with every detection, so the diff shows which gaps are certain and which are guesses.
• Bassethound returns each domain’s five-layer dossier from the same tool, so both sides use identical detection.

How do you make the comparison fair?

A fair comparison holds the method constant. Run the same detector on both domains, at the same profile, close together in time. Scan one site with BuiltWith and the other with Wappalyzer and half of what you call a difference is the two tools disagreeing about category names, version parsing, and confidence thresholds. Hold the profile constant too. A fast scan on one domain against a deep scan on the other compares detection depth, not architecture. Timing matters at the margins. CDNs, certificates, and DNS records rotate, so a scan a week apart can show drift that is calendar, not stack. The cleanest comparison is one tool, one profile, two domains, one sitting. Then every difference in the output points back to the sites, not the setup. Bassethound runs the same five-layer pass on any domain you hand it, no key required, so the target you chose is the only variable left.

Which layers separate two companies?

Surface tech rarely separates competitors. Two SaaS companies in the same category both run React, both sit behind a CDN, both load an analytics tag. The tech-stack layer converges because the popular choices are popular. The layers that diverge sit lower. Infrastructure tells you who self-hosts and who leans on a managed edge, which email provider each trusts, whether SPF, DKIM, and DMARC are all present or half-configured. Firmographics tells you scale and vertical. AI-readiness tells you who ships. Security tells you who hardened their headers and who kept the defaults. Diff by layer and the story separates: two identical front ends, one carrying a Pinecone client and an Anthropic SDK, the other running a support-chat widget over an empty llms.txt. That difference predicts the next twelve months, and a flat feature list buries it under forty shared cookies. Comparing lists tells you what two companies have in common. Comparing layers tells you where they are going.

How do you diff the AI stack?

The AI layer is where a comparison earns its keep, and where every single-layer competitor goes quiet. Line up six signal groups for each domain: model providers (Anthropic, OpenAI, Gemini, Cohere, Mistral), AI SDKs (Anthropic SDK, OpenAI SDK, Vercel AI SDK), orchestration (LangChain, LlamaIndex, Haystack, CrewAI), vector stores (Pinecone, Weaviate, Qdrant, Chroma, Milvus), LLM observability (Helicone, LangSmith, Langfuse), and surface signals (llms.txt classified standard vs technical, MCP endpoints, .well-known AI files). Score each side by how many distinct groups it hits, out of six, and read the verdict: shipping, experimenting, or none. Now the diff is concrete. A company at shipping with a vector store and observability is running AI in production. A company at experimenting with only an llms.txt and a chat widget is testing the water. Two firms that read as twins on the homepage split here. Be honest about the floor: a proxied backend can hide a model call, so a none verdict means no signal found, not no AI. The dossier says which of the two you are looking at.

What does a comparison miss, and how do you know?

Every crawl-based comparison has a blind spot, and the fair thing is to name it on both sides. A static fetch reads what the HTML and loaded scripts reveal. Components that run fully server-side, sit behind a reverse proxy, or initialize only after login never touch the wire you can see, so a stack can look thinner than it is. The trap in a two-way comparison is asymmetry: if one site server-renders its SDK imports and the other proxies everything, the crawl flatters the first and starves the second, and the diff lies. Two defenses. First, optional JS rendering, which pulls in client-only initialization that static HTML misses. Second, and this is the part competitors skip, report the gaps. Bassethound marks what it could not reach on each domain, so an absent detection reads as not found, not not there. When you compare, you weigh a confirmed present against a confirmed absent differently than against an unknown. A diff that hides its own uncertainty is worse than no diff at all.

How do you run the comparison with one MCP tool?

Point your agent at the Bassethound MCP endpoint (mcp.bassethound.ai/mcp), then call the single tool twice, once per domain, at the same profile: sniff_domain(“company-a.com”, “standard”), then sniff_domain(“company-b.com”, “standard”). Each call returns a self-contained five-layer dossier (tech, infrastructure, firmographics, AI-readiness, security) plus a fused summary with primary_stack, ai_readiness, security_grade, and an icp_signal. Your agent diffs the two objects field by field. Because both dossiers came from the same detector at the same depth, the diff is structural, not tool noise. The free tier is keyless and rate-limited, so a two-domain comparison needs no key. For a teardown across a whole competitor set, loop the calls and collect the summaries. Stateless is the feature here: no session and no state carried between calls, so a comparison you run today reproduces if you run it again next quarter. When you want more, the paid tier over OAuth raises depth and volume, and deep adds Wayback first-seen history, which lets you compare not just current stacks but when each company adopted what.

Bassethound perspective

A tech-stack comparison that stops at frameworks compares two companies’ pasts. BuiltWith will confirm both run React and a CDN and call it a teardown. That diff was interesting in 2015. The axis that separates two competitors now is the AI stack, and a single-layer tool is blind to it by construction, because it was built to name front-end tech, not to fingerprint a vector store or a model provider three hops down the request chain. Here is the conviction a competitor would dispute: the useful half of a stack comparison is the half their tool cannot see. Two firms that read as identical on surface tech split the moment you diff model providers, orchestration, and observability. One is shipping, one is talking. You cannot assemble that comparison by scanning each layer with a different tool, because five tools disagree with each other and you spend the teardown reconciling their categories instead of reading the sites. One detector, five correlated layers, both domains, same pass. Digby sniffs both, then shows you where they diverge.

Sources

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