Profiles: Fast, Standard, Deep
What's the difference between the fast, standard, and deep profiles?
Fast returns a deterministic read of tech stack and infrastructure in one to three seconds, keyless. Standard, the default, adds the AI stack and firmographics. Deep adds follow-on probes, a security grade, and Wayback first-seen history for the technologies it finds.
Best move: start with standard. Drop to fast when you need speed at scale, reach for deep when a domain is worth a closer look.
Why it works: each profile runs more investigation inside the same request. Fast does deterministic lookups. Standard fingerprints the AI stack. Deep chases what the first pass found.
Key takeaways
- Fast is deterministic: DNS, TLS, HTTP headers, and one static HTML pass, no JavaScript render, done in one to three seconds, keyless.
- Standard is the default. It adds the AI-readiness layer and firmographics on top of everything fast returns.
- Deep adds a security grade (headers A to F plus TLS), follow-on probes, and Wayback first-seen history.
- Every profile returns one correlated dossier. The profile sets how deep the investigation runs, not which tool you call.
- Latency tracks depth. Run fast for volume, standard to qualify, deep for one high-value target.
What does the fast profile return, and when is it enough?
Fast runs deterministic lookups only. DNS records, the TLS certificate, HTTP response headers, and a single static HTML pass. From those it builds two layers: the tech stack (frameworks, CMS, analytics, payments, ecommerce widgets) and infrastructure (IP, ASN, hosting org, CDN, nameservers, MX, email provider, SPF/DKIM/DMARC booleans, cert issuer and expiry). It does not render JavaScript, chase follow-on requests, or fingerprint the AI stack. So it lands in one to three seconds and needs no key.
Fast is enough when you are scoring a list, not studying a company. If you are ranking ten thousand domains by whether they run Shopify, sit behind Cloudflare, or enforce DMARC, fast answers that domain by domain, at volume. It is also the right call when you only need the infrastructure layer: who hosts this, what CDN, is email auth valid. Fast will not tell you whether the company ships AI, who works there, or how its security headers grade. For those, you climb.
What does standard add on top of fast?
Standard is the default profile because of the AI-readiness layer. On top of everything fast returns, standard fingerprints the backend AI stack: model providers (Anthropic, OpenAI, Gemini, Cohere, Mistral), AI SDKs, orchestration frameworks (LangChain, LlamaIndex, CrewAI), vector stores (Pinecone, Weaviate, Qdrant, Chroma, Milvus), LLM observability (Helicone, LangSmith, Langfuse), AI widgets, llms.txt, MCP endpoints, and .well-known AI files. It scores those into an ai_readiness value and a verdict: shipping, experimenting, or none.
Standard also adds firmographics: company name, vertical, description, contacts, social profiles, structured data. Its render fires JavaScript when the signals call for it, which is why standard costs more time than fast. This is the profile that turns a domain into an ICP signal. Fast tells you the plumbing. Standard tells you whether the company builds with AI and who they are. If you are qualifying a lead or routing an account, standard is the floor.
What does deep add, and what is a follow-on probe?
Deep starts from standard and keeps investigating. Three additions. First, a security grade. Deep scores the header layer A to F across HSTS, CSP, X-Content-Type-Options, X-Frame-Options, Referrer-Policy, and Permissions-Policy, then adds a TLS grade. Second, Wayback first-seen history, which dates when a detected technology first appeared so you can tell a recent AI adopter from a long-standing one. Third, follow-on probes.
A follow-on probe is the agentic part. When the first pass finds a lead (an llms.txt reference, an MCP endpoint, a .well-known path, an SDK hint), deep chases it with a second request instead of stopping at the mention. Investigation happens inside one call. The dossier fans out from what it already found, correlates the result, and returns it together. Deep costs the most latency because it does the most work. Use it on a domain that earned the attention: a target account, a competitor, a partner you are diligencing. Do not run deep across a raw ten-thousand-row list.
How do the profiles differ in latency, keys, and cost?
Depth sets latency. Fast is one to three seconds because it does deterministic lookups and one static pass. Standard costs more because it renders JavaScript and fingerprints the AI stack. Deep costs the most because it runs follow-on probes and pulls history. You pay time for depth.
Keys track tier, not profile. The free tier is keyless, rate-limited, and runs over the same remote MCP endpoint at mcp.bassethound.ai/mcp. The paid tier authenticates by OAuth for higher depth and volume. You do not bring your own model key at any profile, because Bassethound owns the crawl. The structural difference from bring-your-own-key enrichment is where the work happens: server-side, stateless, read-only, one self-contained call. Pick the profile per call. Batch on fast, qualify on standard, diligence on deep.
Bassethound perspective
Most enrichment products make you choose a tool per layer. One vendor for tech stack, another for infrastructure, a third for firmographics, a fourth that claims AI-readiness by reading the homepage, a fifth for security headers. Then you correlate the five yourself, key by key, and hope the crawls agree. We reject that. Fast, standard, and deep are not three products stapled together. They are one dossier at three depths of investigation, correlated before you see it. The deep AI-stack layer is the part nobody else runs well, because reading llms.txt and a homepage banner is not fingerprinting a backend. A vector store client and a named model endpoint are. Be honest about the edge: a static crawl plus optional render can miss a fully server-side or proxied component, and the dossier says so per detection rather than guessing. The profile you pick is how hard you want Digby to sniff, not which five vendors you reconcile afterward. That is the whole point of one call over five.
Sources
- Model Context Protocol: https://modelcontextprotocol.io
- llms.txt specification: https://llmstxt.org
- Mozilla SSL configuration generator: https://ssl-config.mozilla.org
- MDN HTTP security headers: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers
Frequently asked questions
Which profile is the default?
Standard. It returns the deterministic base layers plus the AI stack and firmographics, which is the useful floor for qualifying a domain. Drop to fast for volume, climb to deep for a single high-value target.
Does the fast profile use a key?
No. Fast is keyless, rate-limited, over the same remote MCP endpoint as the other profiles. No profile makes you bring your own model key, because Bassethound owns the crawl.
Why is deep slower?
Deep runs follow-on probes and pulls Wayback history. When the first pass finds a lead, deep chases it with another request instead of stopping at the mention. More investigation, more latency.
Can I run deep across a large list?
You can, but you should not. Deep is built for a domain worth a closer look. For a raw list, run fast or standard and reserve deep for the rows that qualify.
What can no profile detect?
A fully server-side or proxied component that never touches the client. A static crawl plus optional render cannot see it. Every profile reports that gap per detection rather than guessing.