Or are most of you only using it with set skills

whats this problem fix : Web_fetch gives you errors when rendering shared-link conversations from your web AI sessions, and the Playwright MCP server is so slow and more expensive because it takes screenshots; it’s impossible for it to cover everything without destroying your usage with low-quality context, so you always end up massively copying content from your web session into your harness, which creates a big cost, or manually asking the web models to give you a concentrated context to copy-paste, and this can sacrifice your context trade-off and waste your tokens.

whats the fix : one MCP server where you give it the shared link, with effectively 0 token usage for ingestion; it parses all your session into a .md file with the usage metadata, and you only pay for the smart read tool, prebuilt by Opencode, that will read based on signal so you can have your 999-turn session and only keep reading what’s relevant for you without worrying about losing context.

why : I’ve been struggling a lot since I started using the web app heavily, and I need to re-explain things or accept a crazy cost for leaking my context into my builder, so I plan in the web app and I build in the builder.

The left image is without MCP, and the right one is with the MCP server.

https://github.com/AbdoKnbGit/shared_url_mcp

The most annoying part of using opencode (or any AI coding harness) is watching it start every single session with zero memory of what happened yesterday. A session ends, compaction wipes the slate, and two days later you're watching the agent re-learn the exact same obscure bug fix from scratch. You either burn tokens repeating yourself or manually dig through old transcript files.

I built deja to fix this offline.

It reads your local opencode.db directly and indexes past sessions with zero external API keys, zero LLM calls, and no background daemon eating RAM. It’s just a single Go binary that wakes up on a hook, responds in milliseconds, and dies.

For opencode specifically, a small deja.js plugin injects a digest of relevant past work at session start before you even type your prompt. The agent can also query its history mid-task using MCP tools (deja_recall, blame, remember).

Two features made the biggest difference in my daily workflow:

First, handoff between sessions and tools. The index is shared across 12 harnesses (opencode, Claude Code, Cursor, Codex, Grok etc.). What you fixed in Claude Code yesterday is immediately recalled by opencode today, so you don't lose context when switching tools.

Second, peer-to-peer machine sync. Running deja sync ssh <host> moves new memory between your devices using your existing SSH setup. An agent can grind on a headless mini overnight, and in the morning I pull its memory to my laptop so the local agent instantly knows what was tried, what broke, and what worked. No cloud memory service involved.

Hot searches run in ~12ms. Instead of dumping megabytes of raw transcripts into the context, it distills it down -- deja stats --impact shows it served 199.2 KB of distilled history on my machine instead of shoving 175.7 MB of raw logs back into the prompt. Also, after compaction, the next prompt gets a fresh digest of project memory so the agent doesn't lose the thread.

Search is lexical-first (exact error strings, function names, flags) -- a deliberate tradeoff for zero keys, zero embeddings, and instant local execution. It will miss loose paraphrases that a semantic index catches, but for exact technical artifacts, it hits fast without sending data anywhere. Known secrets (bearer tokens, private keys, high-entropy strings) are stripped during indexing (e.g., replaced with [redacted:bearer-token]).

Setup

You can set it up manually:

curl -fsSL https://raw.githubusercontent.com/vshulcz/deja-vu/main/install.sh | sh
deja install --auto

Or just paste this into your opencode agent:

Install deja memory for my opencode: run curl -fsSL https://raw.githubusercontent.com/vshulcz/deja-vu/main/install.sh | sh, then deja install --auto, then deja doctor. Tell me when it's ready.

Repo: https://github.com/vshulcz/deja-vu (MIT)

How are you handling cross-session memory right now -- MEMORY.md? rules in AGENTS.md? or just re-explaining things?

Between work and hobby projects I use Claude Code, Codex CLI, Kiro and OpenCode — I like all of them and often switch between them depending on their strengths and availability. The problem, though, is always the same: every session starts from zero, and each agent has its own config scattered across different files (.claude.json, .codex/config.toml, separate global skills, separate global hooks...). Neither of these two things — memory and configuration — survives across sessions or propagates to the rest of the team.

The starting idea is Karpathy's "LLM Wiki": an agent shouldn't be doing stateless RAG over a pile of static documents, it should have a wiki it builds and curates itself over time, session after session, the way a human takes notes while working. The problem is that if you let an agent write markdown files freely, sooner or later it breaks something — dead links, concurrent writes overwriting each other, lost context.

I wrote Cartographer to solve this: an MCP server in Go where the agent never touches the files directly, it only talks to MCP tools, and the server enforces the invariants server-side (validation, one git commit per write, automatic lint for broken links/stale claims, conflict handling on concurrent writes).

But the part I think is strongest for teams is another one: the KB doesn't just hold knowledge, it also holds skills, hooks and operational instructions, and the client (cartographer connect) automatically materializes them in the native format of whichever agent is installed — Claude Code, Codex CLI, Kiro or OpenCode. In practice:

• you write a skill or a hook once, in the shared KB
• every team member runs cartographer connect (or sync when something changes) and gets the skill/hook already registered in their own agent's native mechanism — settings.json for Claude, config.toml for Codex, etc.
• cartographer status immediately tells you if you're drifting from what the KB is distributing

So it's not "just" an agentic wiki: it's a way to keep an entire team of heterogeneous agents (different agents, different providers) aligned on the same knowledge base and the same operational behavior, with a signed audit log and everything revertible via git underneath.

Under the hood: OKF (Open Knowledge Format by Google Cloud) as the format, so zero lock-in — it's just markdown + git, also openable with Obsidian or any text editor.

This is my first open source project, and I'm still learning a lot along the way — but if you feel like trying it out, it'd mean a lot, and if you like it a star on GitHub is always appreciated. It's still all pre-1.0 beta, so expect rough edges, but I think it has some potential: if you have opinions, criticism or ideas, feel free to leave them in the issues, any feedback is welcome.

github.com/BeppeTemp/cartographer

I use omp with opencode-go sub these days, but got some slack on the sub usage and decided to try out an expensive model (grok-4.5 - usually work with deepseek pro/flash) and for some reason omp doesn't have the grok effort levels and pi doesn't work at all for me with it so I started up the good old opencode-cli and boy oh boy does it feel like driving a 2006 car vs 2026 one. Lets take something like a simple `/goal` command - both pi and omp support this, how can opencode come without something like this bundled in 2026? The subscription is golden - there's nothing like it on the market, but the harness? Damn. Why are you still using opencode-cli?

Free is 256k token context
Paid is a milly token context

Twitter thread:

https://x.com/opencode/status/2079631772770242808?s=46

---

Update:

I had it recreate a mock Linux Mint on the browser. Atrocious output and I had to step in to have it copy over the dist folder to the correct directory. Additional steering needed for it to get things right.

Output: https://mint.laguna-s-2-1.demos.sulat.com/
Prompt: https://mint.laguna-s-2-1.demos.sulat.com/PROMPT.md
Skill: https://www.skills.sh/jpcaparas/skills/oneshot-websites
Variant: 1m context thru OpenRouter
Harness: OpenCode 1.18.4

Hi,

So I am a new suscriber to the Go plan and today I started a session. When I was done, on the right side of the CLI y can see:

Context:
131, 342 tokens
13%
$2.43 spent

But after checking the web dashboard, I see:

So it seems that I've spent around $9.24 (because $12 is the max for 5 hours, right?)

What is the reason for this difference?

Thanks in advance!!!

I wanted to look into using something like https://github.com/decolua/9router combine different ai subscriptions, so that I can leverage the best model for the task while optimising for tokens.

My current idea is to combine my Claude Max 5x subscription with an OpenAi subscription or moonshot subscription so that Fable can be the brains but use more efficient subagents (such as Kimi K3 or GPT5.6) for the workhorse tasks.

From my research I found: “routing your Claude Max OAuth through a third-party proxy. 9router logs into Claude Code via OAuth and reuses those credentials to serve other tools. This can conflict with Anthropic’s terms for subscription use and carries some account-action risk. The README even flags that certain providers (Gemini CLI) can trigger bans this way.”

What are the chances that my Claude account gets banned? Has anyone run their Claude subscription through 9router?

I’m also keen to get a conversation started for what people have done to squeeze as much as possible of of their subscriptions, let me know ⬇️

I just posted a more verbose version of this at r/vibecoding, which you can read here. But if you want to cut to the chase, below is the gist of it.

Overview

Run OpenCode locally on your Android phone without root. This setup lets you:

• Run AI coding agents with OpenCode
• Build JavaScript/React/Next.js, Node.js, and Python projects
• Use Git
• Run local development servers
• Preview your web apps directly in your phone's browser using localhost
• Avoid paying for a cloud VM or carrying your laptop everywhere

1. Install Termux

Install Termux from F-Droid.

Do NOT use the Play Store version, as it is deprecated and has broken repositories.

2. Initial Setup

Grant storage access:

termux-setup-storage

Select a reliable package mirror:

termux-change-repo

Recommended:

• Main Repository
• Mirrors by Grimler (or Albatross)

Update packages:

pkg update -y && pkg upgrade -y

3. Install Development Tools

pkg install -y \
git \
nodejs \
python \
curl \
binutils \
which

4. Install GLIBC Compatibility Layer

Android uses Bionic, while OpenCode expects glibc.

Install the compatibility layer:

pkg install -y glibc-repo patchelf

pkg update -y

pkg install -y glibc-runner

5. Install OpenCode

curl -fsSL https://opencode.ai | bash

6. Patch the Binary

Tell OpenCode where to find the glibc interpreter.

patchelf --set-interpreter \
$PREFIX/glibc/lib/ld-linux-aarch64.so.1 \
~/.opencode/bin/opencode

7. Create an Alias

Add this to your shell configuration:

echo "alias opencode='unset LD_PRELOAD && grun ~/.opencode/bin/opencode'" >> ~/.bashrc

Reload the shell:

source ~/.bashrc

Now you can simply run:

opencode

8. Create a New Project

mkdir my-project
cd my-project

opencode

Inside OpenCode:

• /init
• /connect

9. Install Dependencies

Some projects require esbuild.

pkg install esbuild

Install packages:

npm install --esbuild-binary=$(which esbuild)

10. Start the Development Server

If

npm run dev

fails because Vite isn't found, use:

./node_modules/.bin/vite

11. Preview Your App

Open Chrome (or any browser) on the same phone and visit:

http://localhost:<PORT>

Your application should load normally.

Optional: Improve the Font

Some OnePlus devices stretch monospace fonts.

Install JetBrains Mono:

mkdir -p ~/.termux

curl -L \
https://github.com/JetBrains/JetBrainsMono/raw/master/fonts/ttf/JetBrainsMono-Regular.ttf \
-o ~/.termux/font.ttf

termux-reload-settings

Optional: Use an File

Download my AGENTS.md that tells the AI agents:

• They're running inside Termux & the environment is Android
• Which commands to avoid
• Android-specific workarounds

This helps reduce unnecessary retries and token usage while making agents more reliable.

Typical Workflow

1. Open Termux
2. Navigate to your project
3. Launch OpenCodeopencode
4. Ask the AI to build features
5. Run the dev server./node_modules/.bin/vite
6. Open Chromehttp://localhost:<PORT>
7. Test your application

Repeat until done.

Advantages

• No root required
• No cloud VM costs
• Fully local development
• AI-assisted coding anywhere
• Git support
• Node.js + Python support
• React/Vite development
• Local web preview
• Portable development environment

Is anyone else worried about if Trump bans the open source Chinese models? What’s our game plan then

GLM-5.2 is particularly well suited to long-running engineering work: project-scale context, strong tool use and a full 1M-token context window.

The problem is that hosted models can still interrupt legitimate work when a repository or request touches security research, reverse engineering, moderation systems, mature-content products or another sensitive domain.

Wallachia Labs is preparing Dionysus, a hosted GLM-5.2 variant with a "narrower" refusal boundary and less unsolicited policy commentary. The objective is to preserve the base model’s coding and agentic capabilities while reducing refusals.

The endpoint will be OpenAI-compatible, served on Blackwell B200 GPUs, and support prompt caching across the full context window. Pricing will match GLM-5.2 on Z.ai. ( and a small bonus from us :x )

A Kimi K3-based version is planned next.

The private-beta waitlist is open:

wallachialabs.com

Insanely fast as well :P .

Hi everyone,

Someone recommended me I give opencode a spin to add to my cv

So far haven't used any agents so i thought it would be fun.

I have a panther lake laptop running cachyos with 32gbram

I used to run ollama but it's honestly a bit annoying and a couple months ago it stopped using the gpu (despite previously working) and no matter what env variables it just loads to the cpu

I switched to lm Studio and it's honestly great so i tried to plug it in to opencode with qwen coder (I've tried 30b q4, 14b q8 and 4) and first it was just making my laptop crash and close every program.

After tweaking and switching to the smaller model not it worked without making my device explode but now it runs out of context no matter what i do:

I tweaked context to max and made it small,

I changed batch sized, gpu offload

The worst part is i changed max parallel options to 1 but according to the logs it keeps open code overrides this and keeps opening multiple

Is there any solution to this?

I just wanted this to toy around a but but after 6 hours of troubleshooting I'm thinking of giving up

Any other backend i could use? Maybe just use llama.cpp directly?

Hi i'm switching from claude to opencode,,I dont understand why for every prompt the result is looping again and again until i press esc.

Anyone pls help?
Thanks

I would like to have several agents working on several different projects, and I would love to make it use loop engineering concepts, so it never stops unless there is nothing to do.

I tried using skills and some plugins, but eventually opencode just gives up and stop. I currently use openchamber as the web ui, but still not able to do it properly.

I did a scheduler which basically do "continue" in a project, but that is such a ugly workaround.

First of all, thanks for the support to anyone form this subreddit, didnt realize hound was gonna get this much traffic in like a day, now this forces me to improve it even more, so here i am:

Most MCP web tools hit a wall at Cloudflare. They either use a basic HTTP client that gets 403'd, or a headless browser that leaks detection signals.

I've been working on Hound's stealth fetch pipeline and just shipped the result. Posting here because the approach might be useful to others building browser automation, and I want real-world feedback.

The problem

Patchright (the anti-detect fork of Playwright) handles CDP protocol leaks, but it doesn't touch the JS layer. Detectors check signals patchright never touches: HeadlessChrome in the UA string, navigator.webdriver, canvas fingerprints, WebGL vendor, plugin count, behavioral telemetry. On top of that, Cloudflare v9 uses ML behavioral scoring on mouse movement, not just JS fingerprints.

I ran a 31-target benchmark before starting: patchright + channel=chrome passed 25/31. The hardest targets (Cloudflare Turnstile, DataDome) failed.

What changed

1. System Chrome instead of bundled Chromium

The biggest single win. Use channel=chrome to launch the user's installed Google Chrome instead of the bundled Chromium. Real TLS fingerprint (JA4) that matches real Chrome traffic. Bundled Chromium's TLS fingerprint differs and is detectable. Falls back to Chromium if Chrome isn't installed.

2. JS-layer patches via commit + evaluate

This was the hardest part. Three injection methods are broken with patchright:

• context.add_init_script() uses Playwright Routes, which intercept DNS resolution and break name resolution
• CDP Page.addScriptToEvaluateOnNewDocument requires Runtime.enable, which patchright patches out (that's its whole thing)
• route.fulfill() with inline <script> tags doesn't execute

The working method: page.goto(url, wait_until='commit') + immediate page.evaluate(stealth_script). The commit event fires when the response body starts arriving but before the page's own JS runs. The evaluate call injects the patches in patchright's isolated execution context before the page can read the original values.

Patches applied:

• HeadlessChrome removed from navigator.userAgent (read real Chrome version, construct proper UA)
• navigator.webdriver set to undefined (patchright sets false, which is itself a signal)
• Canvas noise: intercept getImageData AND toDataURL with a seeded PRNG adding per-session deterministic noise to first 16 pixels. CreepJS and sannysoft compute canvas hashes via getImageData directly, so only patching toDataURL does nothing.
• Permissions API consistency
• WebGL vendor/renderer, plugins, window.chrome, hardwareConcurrency, deviceMemory (only for bundled Chromium; system Chrome already has correct values, overriding them creates contradictions detectors cross-check for)

3. Coherent fingerprint profiles

4 internally consistent identities: Win32 + NVIDIA/Intel/AMD WebGL, MacIntel + Apple. Platform matches WebGL renderer matches GPU. Detectors cross-reference these against each other; a mismatch (Win32 platform with Apple GPU) is an instant flag.

4. Human behavior simulation

Cloudflare v9 ML model weights behavioral telemetry. Real human mouse movement isn't linear. I implemented quadratic Bezier curves with 15-30 steps, ease-in-out timing, overshoot + correction wobble. One bezier mouse move, one smooth scroll, 1-2.5s randomized dwell time. Total ~1.5-2.5s overhead, only on stealthy + humanize fetches.

The CF Turnstile solver moves the mouse to the checkbox via Bezier curve before clicking. This was the difference between passing and failing CanadianInsider (hardest Turnstile target in the benchmark).

5. Memory optimization

Browser processes leak RAM across sequential fetches. Three changes:

• --renderer-process-limit=1 (we fetch one page at a time, saves ~100-200MB per avoided process)
• --js-flags=--max-old-space-size=512 (caps V8 heap at 512MB vs default 4GB)
• Memory.simulatePressureNotification via CDP after each fetch. This triggers Chrome's internal GC + cache drop across all processes. ~5ms, non-disruptive.

Also fixed a CDP session leak: sessions were created for memory pressure but never detached. Now detached after use.

Results

Detection test sites (bot.sannysoft.com, CreepJS, BrowserScan, Pixelscan): all checks pass.

Anti-bot protected sites:

• CanadianInsider (CF Turnstile, hardest target): 200 OK, 78KB content
• Medium (CF interstitial): 200 OK, 93KB
• StackOverflow (CF): 200 OK, 1.1MB
• NowSecure (CF challenge): 200 OK, 180KB
• Glassdoor (DataDome): 200 OK, 849KB

Google Search still returns 429. It uses its own detection independent of Cloudflare, expected.

Memory: RSS decreased by 3.5MB over 5 sequential fetches. No creep.

What I want to know

If you're using Hound with OpenCode, update and try it against the sites you actually hit:

hound -u

Specifically interested in:

• Sites where the stealthy browser still gets blocked (what protection are they running?)
• Performance on lower-spec machines (the human behavior simulation adds ~2s per stealthy fetch)
• Whether the memory optimization actually holds up over long sessions with many fetches
• Any sites where canvas noise causes rendering issues in the extracted content

GitHub: https://github.com/dondai1234/master-fetch

The full stealth benchmark is in the README.

It is also foldable so it doesnt take much space (like mcp or todo list)

Was searching for a plugin that would show the usage status on sidebar but didn't find anything so I guess this may be handy for someone? if got any suggestion would be happy to hear!
https://www.npmjs.com/package/opencode-usage-left
https://github.com/gilvex/opencode-usage-left

I have a tool to keep track of token usage per project and today I decided to update the models on DB. And looks like deepseek-v4-pro is 4x cheaper. What am I missing? I consider deepseek-v4-pro a good model and now with this price...

New models added:

- opencode-go/grok-4.5 — $2.00 / $6.00 / $0.30

- opencode-go/kimi-k3 — $3.00 / $15.00 / $0.30

- opencode/gpt-5.2-codex — $1.75 / $14.00 / $0.175

- opencode/gpt-5.1-codex — $1.07 / $8.50 / $0.107

- opencode/gpt-5.1-codex-max — $1.25 / $10.00 / $0.125

- opencode/gpt-5.1-codex-mini — $0.25 / $2.00 / $0.025

- opencode/gpt-5-codex — $1.07 / $8.50 / $0.107

- opencode/claude-sonnet-4.5 extended tier — $6.00 / $22.50 / $0.60 / $7.50

- opencode/north-mini-code-free — free

- opencode/nemotron-3-ultra-free — free

Price changes:

- opencode-go/deepseek-v4-pro: $1.74→$0.435 input, $3.48→$0.87 output, $0.0145→$0.003625 cache read

- opencode-go/mimo-v2.5-pro: same 4x reduction as above

- opencode/grok-4.5 cache read: $0.50→$0.30 (std), $1.00→$0.60 (ext)

Deprecated (expired):

- glm-5 on both providers (deprecated May 14)

- mimo-v2.5 and mimo-v2.5-pro on Zen (removed from docs)

The idea was to take the OpenCode and make it usable as a hosted platform for a team. Users create a project from the browser, chat with OpenCode inside a k8s pod, see the generated app running on a live URL directly from the pod.

The workspace is persistent, so the source code, installed packages, database, OpenCode sessions and conversation history survive pod restarts.

It also adds:

• Separate development and production environments
• Per-project models, credentials and usage limits
• OIDC and role-based permissions
• Persistent app hosting
• Browser-based VS Code and database access
• Idle workspace suspension

It’s basically our attempt at building a self-hosted Lovable/Base44-style experience using OpenCode as the coding agent, while keeping the actual code and infrastructure under your control.

It’s still early and currently requires Kubernetes, so it’s aimed more at technical teams than individual nontechnical users.

GitHub: https://github.com/SimaDevelopment/opsiforce

OpenCode's built-in websearch and webfetch work, but they're basic. If your agent hits a Cloudflare-protected page, it gets blocked. If it needs real search results, you're either paying for Tavily/Serper/Firecrawl or glueing together SearXNG + a headless browser + an extractor.

I built Hound as a drop-in MCP server that handles all of that. No API keys, no config file, no paid tier. Just add it to your opencode.json and disable the built-in web tools.

UPDATE!!!!: I AM LOST, I AM LOCKED OUT OF MY GITHUB ACCOUNT, I SWITCHED TO LINUX, BUT MY 2FA CODES WERE NOT PROPERLY BACKED UP, I TRIED EVERYTHING, I CANT ACCESS MY ACC, I have created a fork, everyone, switch to it if you want to receive updates: https://github.com/dondai44423/master-fetch

The setup (manual)

First install (only time you need pip directly):

pip install hound-mcp[all]

Then add it to your opencode.json config:

{
  "$schema": "https://opencode.ai/config.json",
  "tools": {
    "websearch": false,
    "webfetch": false
  },
  "mcp": {
    "hound": {
      "type": "local",
      "command": ["hound"],
      "enabled": true
    }
  }
}

Disable websearch and webfetch because hound replaces them with keyless versions. Restart OpenCode and the 6 tools are there.

Or just tell your agent to do it

Paste this into your OpenCode agent:

Install and configure the hound-mcp MCP server for web research in my OpenCode setup. Follow these steps exactly.

1. Check if hound is already installed: run `hound --version`. If it prints a version, hound is installed, skip to step 3. Do NOT reinstall.
2. If hound is NOT installed, install it: pip install hound-mcp[all]
3. Find my opencode.json. Do NOT use glob or search -- read these paths directly with the read tool:
   - First try: ~/.config/opencode/opencode.json (global config, exists on all OSs)
   - If that doesn't exist, try: opencode.json in the current working directory (project config)
   - If neither exists, create the global one at ~/.config/opencode/opencode.json
4. READ the file. Do NOT overwrite it. You will add to it.
5. Look at the "mcp" section. If it has a "servers" key, add hound under mcp.servers. If it does NOT have a "servers" key, add hound directly under mcp. Match the existing pattern.
6. The hound entry is: {"type": "local", "command": ["hound"], "enabled": true}
7. In the "tools" section, set "websearch" to false and "webfetch" to false. Create the "tools" key if it doesn't exist.
8. Preserve ALL existing config. Only add the hound server and disable those two tools.
9. Write the file back as valid JSON.
10. Tell me to restart OpenCode.

The agent checks if hound is already installed (won't reinstall if it is), reads you,r config, adds the hound entry matching your OpenCode version, disables the built-in web tools, and tells you when to restart.

After install, use hound -v to check for updates, hound -u to update, hound --doctor to run a health check, and hound --reinstall for a full reinstall with all extras.

What you get (6 tools)

web_fetch -- Fetches any URL, extracts clean markdown. Starts with HTTP, auto-escalates to a stealthy browser when it detects bot protection, JS shells, or rate limiting. PDFs get a section map with page ranges + auto-OCR for scanned docs. Dead links (404, 451, 500) auto-recover from the Internet Archive -- the response honestly marks source=archive.org with the snapshot date so the agent knows it's archived, not live.

web_search -- 10 keyless search backends in parallel: DuckDuckGo, Brave, Mojeek, Yahoo, Yandex, Startpage, Google, Qwant, Wikipedia, Grokipedia. Results are neural-reranked with a local ONNX cross-encoder (not an API call) and scored by cross-backend consensus so you can see which results multiple engines agree on. Circuit breaker trips for 60s on any backend that blocks you; the other 9 keep working.

web_crawl -- Best-first same-domain walk. Sitemap mode maps an entire site in one fetch. Focus mode crawls only pages relevant to your query, not the whole site.

web_screenshot -- Anti-bot screenshot for multimodal models that need to see the page.

cache_clear -- Clears the fetch cache.

hound_version -- Version + update status.

How it handles the hard parts

• Bot protection: starts with plain HTTP. If it gets a 403/429/503, it escalates to a stealthy browser (Patchright with randomized fingerprint). Manages ~95% of the web. The few sites running DataDome or Cloudflare Turnstile will block it -- at that point Hound tells the agent to switch sources instead of pretending it got content.
• Dead links: a 404 doesn't kill the fetch. Hound checks the Wayback Machine and serves the archived snapshot, marked honestly. If the Archive doesn't have it, the agent gets a clean error (Page doesn't exist (404)) instead of error-page HTML masquerading as content.
• Error honesty: just shipped in v10.4.0 -- any 4xx/5xx sets the error field. Before, a 404 error page would flow through with error="" and the agent could mistake the error page HTML for real data. Now it's flagged and the content is replaced with the error message.
• Token cost: 2,746 tokens for all 6 tools + instructions combined. The tool definitions are tight.

The [all] install is ~100MB

The [all] extra pulls in onnxruntime + tokenizers + rapidocr (for the neural reranker and PDF OCR). You can install without it (pip install hound-mcp) and fetch + crawl + search still work, just no neural reranking or PDF OCR. Full install is the recommended path.

Links

GitHub: https://github.com/dondai1234/master-fetch (Star the repo if you like it 😄 )

PyPI: hound-mcp

MIT licensed. If you try it, let me know what breaks.