Primary question: Do you want to stop paying per-query search and scraping fees while keeping web tools inside your MCP-connected agent?
RepoDaily adoption score
RepoDaily rates this as 91/100 (strong) for adoption: evidence, installation path, production risk, differentiation, license clarity, and AI/agent fit are scored from the article sources and adoption notes.
5 source(s) across 3 source category/categories, plus a RepoDaily-specific evidence module when available.
5 workflow step(s), 6 next-action step(s), and 7 command/install signal(s) were detected.
Trending momentum is +192 stars, with maintenance/release/issue signals counted when present.
Risk is marked medium, with 6 security note(s) and 4 explicit skip condition(s).
3 opportunity lens item(s), 4 alternative(s), and 3 type-specific section(s) support differentiation.
License source or license wording is present.
9 AI/agent-related signal(s) were detected in the article text and metadata.
Project overview
wigolo is a TypeScript MCP server that bundles ten web-intelligence tools — search, fetch, crawl, extract, cache, find_similar, research, agent, diff, and watch — into a single local runtime. It runs as an MCP server over stdio next to coding agents like Claude Code, Cursor, Codex, Gemini CLI, VS Code, Windsurf, Zed, and Antigravity, as a REST/MCP daemon for self-hosted agents such as n8n or VPS automations, and as an embeddable SDK inside custom applications.
The core pitch is simple: search, fetch, crawl, extract, cache, and find-similar work with no API keys and no metered cloud. Everything the server touches stays inside `~/.wigolo/` on your disk. The optional `research` and `agent` tools can call an LLM to synthesize cited answers, but without a configured LLM provider they hand back raw briefs and evidence instead.
The project shipped v0.2.0 on 2026-07-17, which introduced zero-config onboarding, an HTTP/REST surface, TypeScript and Python SDKs, an 11-pack skill installer, framework wrappers for LangChain, CrewAI, LlamaIndex, and Vercel AI SDK, and a hardened anti-bot fetch ladder. It is labeled public beta, AGPL-3.0 licensed, and distributed primarily through npm with Docker, Homebrew, and single-file-binary channels documented.
Why it is trending now
- 192 period stars at rank 13 during the 2026-07-19 window, driven by the v0.2.0 release two days earlier.
- v0.2.0 shipped zero-config onboarding — the default direct-engine backend needs no external process, no Python sidecar, and no port; idle footprint dropped to roughly 47 MB.
- Ten keyless tools now ship in one MCP server, covering search, fetch, crawl, extract, cache, find_similar, research, agent, diff, and watch.
- HTTP/REST API, TypeScript and Python SDKs, and framework wrappers for LangChain, CrewAI, LlamaIndex, and Vercel AI SDK landed in the same release.
Problem it solves
- AI coding agents need durable web access, but hosted search and scraping APIs charge per query and require API keys.
- Cloud-based agent web tools expose query content and results to third-party services, which is a blocker for sensitive codebases.
- Self-assembled browser-crawler setups are fragile — anti-bot challenges, TLS fingerprinting, and interstitial walls break naive fetchers.
- Wiring web tools into multiple coding agents means repeating MCP config, instructions, and skill files across Claude Code, Cursor, VS Code, and others.
How it works
- `npx wigolo init --agents=claude-code` downloads the browser engine and on-device ranking and embedding models, runs a health check, and writes the MCP config and agent instructions. Init is unattended by default and safe in CI.
- The agent now sees ten MCP tools. When the agent needs the web, it calls `search`, `fetch`, `crawl`, `extract`, `cache`, `find_similar`, `research`, `agent`, `diff`, or `watch` through the stdio MCP transport.
- Search queries hit the default direct-engine backend (Bing, DuckDuckGo, and optional keyed engines) with no external process or port. Fetch and crawl use a hardened ladder that rotates request identity, impersonates browser TLS fingerprints, and waits out JS challenges to capture and reuse clearance cookies per domain.
- Results are cached in `~/.wigolo/` on disk with per-result evidence scores, per-engine telemetry, and labeled failures. `doctor` and `verify` commands report component status and run end-to-end smoke tests.
- For remote agents, `wigolo serve` exposes `POST /v1/{tool}` for all ten tools, `GET /openapi.json`, and `GET /v1/tools`, with optional bearer auth and a fail-closed policy on non-loopback binds.
Product demo and interface preview
Command Surface — What You Actually Type
- `npx wigolo init --agents=claude-code,cursor` — full unattended setup, wires multiple agents, downloads browser engine and on-device models.
- `npx wigolo init --no-warmup` — defer all downloads to first use; failed component download never aborts setup.
- `npx wigolo doctor` — reports data directory, browser engine, on-device models, configured LLM providers, and per-engine status including which engines want an API key and which env var enables them.
- `npx wigolo doctor --fix` — re-downloads a missing model, installs the browser engine, clears stale sidecar state, resets stuck engine breakers, even on a running daemon.
- `npx wigolo verify` — end-to-end capability smoke test over real network; exit code 0 means pass, 1 means failure.
- `npx wigolo search "css container queries" --limit=2` — one-shot CLI search with formatted output.
- `npx wigolo fetch https://example.com --max-content-chars=400` — fetch a page as clean markdown.
- `npx wigolo config --uninstall --yes` — removes MCP config, instructions, skills, and slash command; does not remove `~/.wigolo/`.
- `wigolo serve` — HTTP daemon with REST (`POST /v1/{tool}`), MCP-over-HTTP at `http://127.0.0.1:3333/mcp`, and OpenAPI 3.1 at `GET /openapi.json`.
Integration Surface — Where It Connects
wigolo's primary transport is MCP over stdio, which is why it slots directly into coding agents. The auto-wire matrix covers Claude Code (`claude-code`), Cursor (`cursor`), VS Code (`vscode`), Gemini CLI (`gemini-cli`), Zed (`zed`), Windsurf (`windsurf`), Codex (`codex`), and Antigravity (`antigravity`). Init writes the MCP server entry and, where the host supports them, instructions and skill packs.
For any other MCP client, the config block ships as `mcp.json` at the repo root: `{"mcpServers":{"wigolo":{"command":"npx","args":["-y","wigolo"]}}}`. For HTTP-speaking hosts, `wigolo serve` exposes `http://127.0.0.1:3333/mcp`. Framework wrappers live under `packages/` for LangChain, CrewAI, LlamaIndex, and Vercel AI SDK, and thin TypeScript and Python SDKs are in `sdks/typescript` and `sdks/python`. Cline is not an `--agents` target but can be wired by hand and still receives skill packs through `wigolo skills add`.
Deployment Notes — Docker and Self-Host
The published Docker image is `ghcr.io/knockoutez/wigolo`, slim variant. The browser engine binary and on-device models download on first use into the `/data` volume. For MCP over stdio with one local client: `docker run -i --rm -v wigolo-data:/data ghcr.io/knockoutez/wigolo`. For a multi-client HTTP daemon, the compose file at `packaging/compose.serve.yml` binds `0.0.0.0` inside the container — a non-loopback bind that fails closed until you set `WIGOLO_API_TOKEN` or explicitly opt into open access.
The repo's `Dockerfile` has a `full` build target with the browser engine preinstalled at build time, useful for `--rm`/no-volume runs where first-use downloads would repeat. The named volume persists the local cache, on-device models, the browser engine binary, and encrypted keys across restarts.
Who should pay attention?
Good fit if
- You use Claude Code, Cursor, Codex, or Gemini CLI and want web tools without per-query fees.
- You run self-hosted agents on a VPS or in n8n and need a local MCP/REST endpoint.
- You build agent frameworks on LangChain, CrewAI, LlamaIndex, or Vercel AI SDK and want a thin typed client.
- You want the anti-bot fetch ladder, on-device models, and disk cache without standing up your own crawler stack.
Skip for now if
- You cannot run Node.js 20+ or allocate roughly 1.5 GB of free disk for the browser engine and models.
- You need managed IP-rotation proxying and the target sites use IP-reputation challenge networks — wigolo labels those as `blocked_by_challenge` and does not solve them by default.
- Your policy forbids AGPL-3.0 dependencies in shipped products.
- You need a production-grade SLA — this is a public beta at v0.2.0.
Risks and cautions
Public beta at v0.2.0, AGPL-3.0 licensed, with honest anti-bot ceilings and pending SDK package publication.
- Project version is 0.2.0 and labeled public beta — APIs and tool surfaces may shift.
- AGPL-3.0 license creates obligations for derivative or network-served uses that teams must review.
- Anti-bot fetch has a documented ceiling: managed-challenge networks with IP-reputation scoring will not issue clearance to datacenter or fresh residential addresses, returning `blocked_by_challenge` instead.
- TypeScript and Python SDK package names are pending and not yet published per the v0.2.0 changelog.
- Homebrew formula, single-file binary, and `.mcpb` artifacts are documented but noted as shipping with an upcoming release.
- Everything the server stores stays in `~/.wigolo/` on your local disk; core tools send no data to wigolo-controlled cloud.
- `wigolo serve` fails closed on non-loopback binds until `WIGOLO_API_TOKEN` is set or open access is explicitly opted into.
- Redirect-following is SSRF-re-guarded on every fetch tier; the MCP-over-HTTP transport rejects cross-origin DNS-rebinding requests.
- REST surface has transport-level body caps, per-route deadlines, and a concurrency limiter.
- `uninstall` deliberately does not remove `~/.wigolo/`; full cleanup requires a separate step.
- Security reports go through the privacy-and-security responsible-disclosure channel, not public issues.
Alternatives to compare
| Approach | When to use | Trade-off |
|---|---|---|
Tavily | You want a hosted search API optimized for LLM agents and are fine paying per query. | Metered API with a free tier |
Brave Search API | You only need search results and prefer a commercial key-based endpoint. | Metered API with a free tier |
Firecrawl | Your primary need is large-scale crawl and markdown conversion and you want a self-hostable option. | Open source, self-hostable, with a hosted paid tier |
Jina Reader | You want a simple reader-API that returns clean markdown from a URL. | Hosted API with free tier |
What this trend reveals
Replace metered web-tool spend for power-user agents
Teams running coding agents all day on Claude Code or Cursor can point those agents at wigolo's keyless search and fetch to cut recurring per-query costs.
Run `npx wigolo init --agents=claude-code`, then compare a week of agent web-tool calls against the previous API bill.
Add a local research layer to self-hosted automation
VPS and n8n automations can call `POST /v1/{tool}` through `wigolo serve` to get search, crawl, and research without a third-party key.
Stand up the compose file at `packaging/compose.serve.yml`, set `WIGOLO_API_TOKEN`, and run a curl smoke test against `GET /v1/tools`.
Ship framework-native agent features on a thin SDK
LangChain, CrewAI, LlamaIndex, and Vercel AI SDK wrappers under `packages/` let framework-first teams add web tools without a new runtime dependency.
Import the wrapper, wire one tool, and confirm it returns the same evidence-scored payload as the CLI.
RepoDaily verdict
wigolo is a credible public-beta attempt to collapse the metered web-tool stack into a single keyless MCP server. The v0.2.0 release covers the critical surface — ten tools, auto-wire for eight coding agents, REST/SDK distribution, and an honest anti-bot ceiling. The medium risk is real: it is a 0.2.x AGPL-3.0 beta with pending SDK publication. For individual developers and small self-hosted setups, it is worth a 30-minute trial today.