Hound: a keyless, self-hosted MCP server for agent web research

The problem Hound targets: agents that stall on the first bot wall

An agent that can only issue a plain HTTP request gets a useful answer on static documentation and nothing else. Login walls, JavaScript-rendered pages and Cloudflare interstitials all return a 200 with content that is not the article. The agent then either reports the wall as the page or invents a summary from the error markup. Hound's README frames the same prompt running against three tools, with Hound doing search, fetch and crawl locally while the others stop at the parts they do not implement. The stated audience is the agent itself rather than a human researcher: the README says you install it once and the agent calls it whenever it needs the web. That distinction matters for the interface. The server ships six tool definitions in roughly 2.9K tokens, and it injects a one-time instructions block at connect time so the agent has the mental model and the known limits before its first call. If you are building an agent that only ever reads one well-behaved docs site, Hound is more machinery than the task needs.

Six tools, one warm browser, and structured fields instead of error strings

The architecture described in the README is a single local process holding a warm browser session. The fetch path is split into three modules: fetcher.py for primp-based HTTP, browser.py for a patchright-based browser, and extractor.py combining trafilatura with markdownify. Scrapling was removed in 12.1.2 and replaced by these in-house modules, which the release notes describe as a smaller install with fewer transitive dependencies and a faster cold start. Routing decides whether a request goes out over HTTP or through the browser, and the browser is reused rather than launched per call. Every response carries fields the agent can branch on: content_ok, next_action, summary, page_type, content_age_days and is_stale, source_type and is_official, relevance_score, and fetch_relevance. Hard blocks such as 404, bot detection or auth walls return clean errors rather than content that looks like a successful fetch. That is the most consequential design choice in the project. An agent that receives an empty string with a 200 status will summarise nothing and call it an answer; an agent that receives content_ok false with a next_action has something to act on. The extraction layer is Trafilatura, which is tuned for article text and will drop navigation and boilerplate. That is usually what you want for prose and often wrong for a page whose value is a table, a spec sheet or a pricing grid, where the extractor can return a thin or empty body even though the fetch succeeded.

The stealth layer: what it patches and what that implies

The browser engine described in 12.1.2 auto-detects a system Chrome install, applies four fingerprint profiles, and patches at the JavaScript layer: the HeadlessChrome user agent is corrected, navigator.webdriver is set to undefined, canvas noise is added, and the permissions API is adjusted. Behaviour simulation uses Bezier mouse curves and natural scrolling, and there is a Cloudflare Turnstile solver that drives human-like mouse movement. The README claims passes on bot.sannysoft.com and bypasses Turnstile on CanadianInsider, which it describes as the hardest site in a 31-site benchmark, plus Medium, StackOverflow, NowSecure and Glassdoor with DataDome. Those are the project's own numbers from its own benchmark, and I have not reproduced them. Treat the site list as a starting point for your own checks rather than a guarantee. The honest reading is that this is an arms race with a maintenance cost attached: every patch in that list exists because a detector changed, and the same detectors will change again. A self-hosted scraper that defeats bot walls also puts the request in your name from your IP, which is a different risk posture from routing through a paid scraping API that absorbs the blocking.

Install paths: the extra that decides what you actually get

The README gives two commands for the full install: pip install hound-mcp[all] followed by playwright install chromium. The [all] extra is what pulls fetch, crawl, keyless search, PDF, OCR and neural reranking. The lean install, pip install hound-mcp, pulls no browser dependencies at all. That split has a real consequence the README states plainly: on platforms without Playwright, such as Termux and aarch64, Hound runs in HTTP-only mode with graceful degradation. So the install command you pick determines whether you have a browser engine or a plain HTTP client, and the difference is exactly the bot-wall case the project exists for. After install, the CLI is the operational surface: hound -v reports version and update status, hound -u updates, hound --doctor runs a health check with fix advice, and hound --rollback undoes the last update. If the launcher breaks, the README points to python ~/.hound/repair.py. Configuration is otherwise empty by design: the README says point any MCP client at the hound command with no arguments, no keys and no env vars. Optional keys exist for search providers. hound keys add registers a Serper, Tavily, Exa, Firecrawl or TinyFish key, and the CLI supports hound keys add/list/test/remove/clear. Keys become the primary search source with stacking across multiple keys per provider and rotation on rate limit, falling back to the keyless local engines when they are exhausted. Docker is supported through a multi-stage Dockerfile and a compose file with shm_size 1gb, a non-root user and a healthcheck, contributed by a named outside contributor.

Where the design strains: search quality, extraction, and platform gaps

The keyless search path is the weakest part of the pitch and the README is candid about why the BYOK option exists. When you supply no keys, search runs on local engines that the project does not name or characterise in the material I have. When you supply keys, the ordering inverts and the local engines become the fallback. That means the zero-cost claim and the search-quality claim pull against each other: the version of Hound with the best search is the version with third-party keys and their rate limits. The intent-aware fan-out described in 12.1.2 detects query intent across comparison, howto, research, code, reference, news and factual, generates query variants across diversity engines, and ranks on six signals including cross-variant consensus and a cap of two results per domain. That is a reasonable design, and it is also a heuristic stack with no published evaluation in the material. The second strain is extraction. Trafilatura optimises for article prose, and a page whose answer lives in a table or a JSON blob will come back thin. The third is the platform gap: no Playwright means no stealth engine, which means the bot-wall case is unsupported on exactly the environments where you might want a small footprint. Finally, the browser is a warm shared session. That is what keeps cold start under a second, and it also means one misbehaving page can affect the process the agent depends on. The error-detection and session-cleanup fixes in 12.1.2 read as responses to that class of failure.

Compared with a hosted scraping API and with a plain HTTP fetch tool

The obvious alternative is a hosted scraping or search API such as Firecrawl, Tavily, Exa or Serper. The difference is not feature parity, it is where the work happens and who pays for it. A hosted API takes your request, runs it on infrastructure tuned for blocking, and returns extracted text, billed per call. Hound runs the browser on your machine, sends the request from your IP, and costs nothing per call. You trade an invoice and someone else's block-evasion team for local CPU, local disk from the Chromium download, and the maintenance of a stealth layer that has to keep up with detectors. Hound's own BYOK feature acknowledges this: you can point it at those same providers when you want their index, which makes it a router over both models rather than a pure replacement. The second alternative is a lighter MCP fetch server that does HTTP plus readability extraction and nothing else. Those are simpler, install cleanly anywhere Python runs, and are the right choice if your pages are static and your agent never hits a wall. Hound earns its complexity only when the wall is the common case.

Maintenance, update mechanics, and the MIT licence

The release cadence visible in the repository is fast: v12.3.1, v12.4.0 and v12.4.1 all landed on 2026-07-24, with the two 12.4 releases covering smart proxy rotation and crawl proxy rotation. Fast iteration on a stealth layer is expected, and it also means the surface you pin is the surface you have to re-verify after an update. The project has built for that. hound -u is described as brick-proof and self-healing, hound --rollback undoes the last update, and hound --doctor diagnoses. That is a more careful update story than most self-hosted scrapers offer, and it is worth using rather than installing once and ignoring. The licence is MIT, which permits commercial and private use, modification and redistribution with the copyright notice and permission notice retained. Nothing in the material suggests a dual licence, a hosted tier with different terms, or a contributor agreement that would change that. This is a description of the licence text, not legal advice; if you are redistributing Hound inside a product, read the LICENSE file in the repository yourself. The practical maintenance cost is the Chromium dependency, which you re-download and keep current alongside the package.

Editorial conclusion

Adopt Hound if your agent needs to read pages that a plain HTTP GET returns as a bot wall, and if you are willing to run a Chromium instance on the same machine as the agent. Do not adopt it if your deployment cannot install Playwright or if you need a hosted endpoint with an SLA, since Hound is a local process and the README itself lists graceful degradation to HTTP-only mode on platforms without Playwright. Before trusting it, run hound --doctor and confirm the browser engine starts, then check whether the lean install you chose actually includes the search and PDF extras you expect.

Official sources

1. dondai1234/master-fetch on GitHub
2. License: MIT
3. Project website
4. README
5. Releases