How do I profile a domain from my own agent?

Best move: add the remote endpoint to your agent’s MCP config, then call sniff_domain(domain, profile) in a normal turn.

Why it works: the endpoint speaks MCP, so any host with tool support reaches it. The tool is keyless and stateless, so you provision nothing and clean up nothing.

Key takeaways

• Profiling a domain from your agent means connecting to mcp.bassethound.ai/mcp and calling sniff_domain(domain, profile).
• One call returns five correlated layers: tech stack, infrastructure, firmographics, AI-readiness, and security.
• The free tier is rate-limited and needs no key of yours. Paid plans raise depth and volume.
• The profile argument sets depth: fast (deterministic, about 1 to 3 seconds), standard (default, adds AI stack and firmographics), deep (adds security grade and Wayback history).
• The server is stateless and read-only: every call is self-contained, and nothing carries from one call into the next.

How do I connect my agent to the endpoint?

Point the host at the remote server. In Claude Code, add it as an MCP server with the URL https://mcp.bassethound.ai/mcp. In Cursor or Claude Desktop, drop the same URL into the mcpServers block of the host config. ChatGPT and other hosts with remote MCP support take the URL directly. You install no SDK and import no client library, because the server runs on our side and your agent reaches it over the protocol. The free tier needs no key, so the config is one line. When the host connects, it lists the server’s tools and finds one: sniff_domain. If your agent misses the tool, restart the host so it re-reads the config, then check that the URL ends in /mcp. Higher depth and volume run through OAuth on the paid tier, so a paid host authenticates once and reuses the session across calls. From there, your agent invokes the tool in a normal turn, the same way it calls any tool you gave it.

What do I pass to sniff_domain?

Two arguments. domain is the target, a bare hostname like stripe.com with no scheme and no path. profile is the depth: fast, standard, or deep. Omit profile and the server runs standard. Your agent can pass a domain it pulled from a CRM row, a lead list, an email address it just parsed, or the page it is reading. The call returns one JSON dossier: a top-level summary (primary_stack, ai_readiness, security_grade, icp_signal) above the five layers (tech stack, infrastructure, firmographics, AI-readiness, security). Each detection inside a layer carries category, confidence, how_detected, and evidence, so your agent weighs a signal instead of taking it on faith. The whole dossier comes back in one turn, so your agent reasons over correlated fields without a second round trip to stitch results together. Pass one domain per call. To profile several, loop the call inside the rate limit.

Which profile should my agent request?

Match depth to the job. fast is deterministic and keyless, about 1 to 3 seconds. It reads tech stack and infrastructure without follow-on probes, which fits high-volume triage where you need only the shape of a domain. standard is the default. It adds the AI-readiness fingerprint and firmographics, the layers most enrichment work wants. deep adds follow-on probes, the security header grade, and Wayback first-seen history, the profile for a single account you are about to act on. An agent scoring a list of 500 domains calls fast or standard and keeps moving. An agent researching one target before it drafts outreach calls deep and reads the evidence. Breadth wants the cheap profile. A decision wants the deep one. You can also start at standard, read the icp_signal, and re-call deep on the hot ones alone. That two-pass pattern spends the expensive probes where they change what your agent does next.

How is this different from calling five separate MCP servers?

You could wire up a tech-stack MCP, an infra MCP, a firmographics MCP, and two more. Five connections, five calls, five schemas, and then your agent joins the results itself. That join is the hard part and the expensive part, and it is where correlation dies. sniff_domain returns the layers already fused: the TLS cert sits next to the CDN that serves it, the model provider sits next to the vector store in the same object, and bassethound computes the icp_signal from all five layers at once. One rate limit, one schema, one turn. An agent can fan out across five tools on its own. It cannot cheaply rebuild correlation from five independent responses that were never built to line up. It would have to normalize hostnames, reconcile timing, and guess which infra record belongs to which detection. You skip all of that. The fused dossier is what makes the signal usable inside one reasoning step.

What can the dossier miss?

Be honest with your agent about the limits. bassethound runs a static crawl plus an optional JS render. Components that live server-side, sit behind a gateway, or load deep inside a client bundle can slip past a single pass. A vector store called from a backend your crawl never touches will not surface in the dossier. The tool reports these gaps instead of papering over them: each detection carries confidence and how_detected, and the AI-readiness score counts only the signal groups it saw. Read a none verdict as nothing detected in this crawl, not proof the company ships no AI. For a hard target, request the deep profile so the follow-on probes run, then read the evidence fields before your agent acts. A high-confidence detection is a strong positive. A null is weak evidence of absence. Build your agent’s logic around that asymmetry, and the dossier holds up even where a crawl cannot see everything.

Bassethound perspective

Needing no key of yours beats bring-your-own-key because we own the crawl. Most enrichment APIs make you bring a key, since they resell someone else’s corpus and have to meter your access to it. We run the crawl ourselves, so the free tier needs no key of yours and carries a daily limit. That changes what your agent can do. A keyless tool drops into any host in one config line, with no secret to provision, rotate, or leak, and your agent calls it mid-turn the way it calls a calculator. The second bet is that the investigation lives inside the request. A stored-row lookup hands you the last time someone indexed a domain. sniff_domain runs a live crawl, correlates it across five layers, and computes the answer at call time. The dossier reflects a live read of the domain, cached for up to 24 hours. Competitors sell you a corpus and a key. We sell you one call that does the work, computed the moment you ask.

Sources

• Model Context Protocol: https://modelcontextprotocol.io
• Model Context Protocol specification: https://modelcontextprotocol.io/specification
• Anthropic documentation: https://docs.anthropic.com
• OpenAI platform documentation: https://platform.openai.com