> ## Content Index > Fetch the complete content index at: https://wuu73.org/aiguide/llms.txt > Use this file to discover other available public pages before exploring further. # Which coding agents actually know how to use the web? - URL: https://wuu73.org/aiguide/coding-agents-web-research/ - Published: 2026-05-29T00:15:00.000Z - Updated: 2026-05-29T00:15:00.000Z - Description: Part of Agent Harness Field Guide. - Author: WUU73 - Tags: Deep Dives, Agent Harness Field Guide, #Deep Dive Child, #Import 2026-09-12 06:38 Web Search • Web Fetch • Browser Grounding • Research Loops "Has web search" is a lazy label. Some repos ship a real no-extra-search-fee backend. Some only expose provider-native search inside Anthropic, OpenAI, Gemini, or Moonshot. Some bolt in Tavily, Perplexity, Exa, or Brave wrappers. And only a small subset turn search into an actual multi-hop research workflow instead of one more tool in the list. Shameless Plug[While we're deep-diving into complex CLI tools... let's be honest. Are you tired of feeling like nerds are trying to gatekeep the terminal life by having you memorize 30 key combos just to do basic stuff? Do you lie awake at night dreading the moment you have to edit a cryptic dotfile just to change a font size? Same. It's the AI age, we can have a crazy UI on top of the terminal with shameless amounts of AI built in to do things for you. We can even have AI nudge stalled coding agents for you when they stop for no reason.**ButtonsCLI**: The terminal for](https://buttonscli.com/?ref=wuu73.org) (Alright, ad over. Back to the serious technical analysis.) ## First: what counts as "free" here? The useful distinction is not "free compute" versus "paid compute." These tools all sit inside model-powered harnesses, so something is always paying for tokens somewhere. The practical question is whether the harness forces you to buy a **separate search API** just to get decent current information. 🧭 #### The three cost buckets **No extra search bill** means built-in DuckDuckGo, Bing, SearXNG, Jina-style fetch, or provider-native search already bundled into the model surface you are using. **Provider-native** means Anthropic, OpenAI/Copilot, Gemini, or Moonshot is doing the searching for you. **External paid search** means the harness wants Tavily, Perplexity, Exa, Serper, Brave, Firecrawl, or similar APIs on top of everything else. That framing keeps unlike things from collapsing together. A repo that defaults to DuckDuckGo scraping is solving a different problem from a repo that only lights up search when the model provider exposes a first-party tool. Both can be valid. They just have different portability, reliability, and operator-cost stories. ## The four recurring patterns ### No-extra-search-fee scraping **Wintermolt**, **Crush**, **DeerFlow**, and **Reasonix** all prove the same point: you can ship useful web search without forcing the operator into a Tavily-or-Exa subscription on day one. ### Provider-native grounding **Claude Code**, **Codex**, **ADK-Rust**, **OpenCode**, and **Kimi CLI** lean on the model provider's own web search surface. This is usually cleaner than scraping, but it ties the feature to provider support and account setup. ### Paid wrapper stacks **Pochi**, **Oh My Pi**, and **Open Claude Code** wrap Perplexity, Brave, Exa, Tavily, or large provider menus. The advantage is reach and optionality. The downside is configuration and cost creep. ### Research orchestration The most interesting split is not search versus no search. It is **tool-only web access** versus **method-shaped research**. DeerFlow, Crush, Claude Code, and Hermes are the clearest examples where the workflow around the search matters as much as the search itself. ## Full comparison matrix: all unique harnesses in the current repo set This table consolidates the current local snapshot by harness family. Duplicate refresh folders like `codex`/`codex_new` and `oh-my-pi`/`oh-my-pi_new` are treated as one product unless the duplicated directory meaningfully changes the picture. | Repo | Search surface | No separate search API? | Deep-research story | What matters | | ------------------------------- | --------------------------------------------------------------------------------------------------------- | ----------------------- | ----------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- | | **Claude Code source snapshot** | Anthropic-native web\_search\_20250305 plus dedicated WebFetchTool | Yes | Strong — Explore, Plan, and forked subagents | Best integrated product runtime for search + fetch + delegation | | **Codex CLI** | Built-in web\_search with search, open\_page, and find\_in\_page actions | Yes | Moderate — agents and config modes, but less research-specific guidance | Provider-native search is real here; older "no web search" summaries are outdated | | **DeerFlow** | Default DuckDuckGo search + Jina fetch; optional Serper, Tavily, Exa, Firecrawl, InfoQuest | Yes | Best in set — deep-research, GitHub deep-research, and literature-review skills | Strongest explicit methodology, not just strongest tool list | | **Crush** | DuckDuckGo Lite scraping plus built-in fetch and Sourcegraph side-channel | Yes | Strong — agentic\_fetch subagent decomposes and iterates | Cleanest coding-agent example of free search plus a real research loop | | **Wintermolt** | DuckDuckGo HTML search plus browser\_control and generic HTTP tooling | Yes | Light — mostly tool surface, not an opinionated research workflow | Best bare-metal free stack in one small binary | | **ADK-Rust** | Gemini google\_search and Anthropic web\_search built-ins | Yes | Moderate — loop agents and optional skills | Best reusable framework example of provider-native search abstractions | | **DeepSeek Reasonix** | Bing HTML by default; optional SearXNG, Metaso, Tavily, Perplexity, Exa | Yes | Moderate — general subagent delegation rather than research-specific logic | Most configurable search engine menu without abandoning a free default | | **Pochi** | Perplexity search via gateway, batch query arrays, Jina fetch via gateway | No | Light — search and fetch only | Batching up to five related queries in one call is genuinely useful | | **Oh My Pi** | Large provider cascade: SearXNG, Perplexity, Exa, Brave, Tavily, Anthropic, Gemini, Kimi, Codex, and more | Mixed | Moderate — autoresearch exists, but it is more experiment tracking than deep web research | Broadest search-provider menu, but most of the interesting routes cost money or setup | | **Kimi CLI** | SearchWeb service plus FetchURL fallback | No | Light — good tools, little explicit methodology | Nicely engineered Moonshot-native search, but not portable | | **OpenCode** | OpenAI / GitHub Copilot openai.web\_search provider tool | Yes | Light — search surface exists, research orchestration is not the point | Good example of provider-native web search inside a platform runtime | | **Qwen Code** | Built-in web\_fetch only; knows URLs, does not discover them | Yes | Light — agent system exists, but search is absent | Fetch is solid; discovery is delegated elsewhere | | **Dirac** | Browser automation, but no dedicated web-search tool surfaced in the current snapshot | Yes | Light | Interesting browser plumbing, not a web-research-first design | | **Goose** | No built-in search; relies on MCP extensions like AgentQL or Apify | No | None — research is extension-dependent | Extensible, but not a built-in answer | | **Hermes Agent** | Optional research skills: DuckDuckGo, SearXNG, and a heavy OSINT stack | Mixed | Specialized — OSINT workflows are unusually deep | The research methods are impressive, but they live in optional skill packs rather than a default coding-agent surface | | **Open Claude Code** | Brave API or SearXNG if configured; otherwise fetch-only fallback | Mixed | Light | Search is present, but it is not a turnkey default | | **OpenHands** | No meaningful built-in web research surface in the local snapshot | No | None | Sandbox/runtime focus outweighs web-grounding focus | | **Pi Mono** | No built-in web search or browser layer in the audited snapshot | No | None | A deliberate minimal kernel, not a research stack | | **Zaica** | Local coding tools only | No | None | Focused specialist rather than web-connected assistant | | **Neovate Code** | No genuine web-search surface detected | No | None | Strong shell safety, not web research | ## So which ones actually stand out? ### Best deep-research workflow: DeerFlow DeerFlow is the clearest case where web access becomes a **method**. The default config already ships free DuckDuckGo search and Jina fetch. Then the skill layer goes further: broad exploration, targeted deep dives, diversity checks, GitHub-specific research rounds, and literature-review batching with explicit concurrency limits. ### Best no-extra-search-fee coding-agent stack: Crush Crush is the surprise favorite if the question is "what would I actually copy into a coding agent?" The DuckDuckGo Lite search path is free, production-minded, and paired with an `agentic_fetch` subagent that explicitly tells the child to break questions apart, iterate, fetch promising links, and return sources. ### Best bare-metal implementation: Wintermolt Wintermolt is the most elegant "just make it work" answer: DDG HTML search, browser control, generic HTTP, and no giant runtime. It is less impressive on methodology than DeerFlow or Crush, but it is the cleanest demonstration that free web grounding does not need a SaaS dependency pyramid. ### Best provider-native examples: Claude Code, Codex, ADK-Rust These three show the cleanest path when you are willing to trust the model vendor. Claude Code has the richest integrated search + fetch + delegated exploration stack. Codex now clearly belongs in the conversation too, with a real built-in web-search surface and configurable modes. ADK-Rust is the best framework-shaped wrapper around Gemini and Anthropic built-ins. ### Best engine matrix: Reasonix Reasonix is the most useful answer if you hate lock-in. Bing works by default, SearXNG is available for self-hosters, and the rest of the usual premium suspects are there when you want them. What it lacks is a uniquely opinionated research workflow on top. ### Best "research brain" outside the coding mainstream: Hermes Hermes is a weird but important edge case. Its OSINT/public-records skill work is deeper than almost anything else here. The catch is that this is not the default coding-agent tool surface. It is a skills-heavy research platform grafted onto a broader agent. ## Are they all basically the same? Superficially, yes. Once you read enough repos, the search backends start repeating: - **Free default path:** DuckDuckGo, Bing HTML, or SearXNG. - **Premium path:** Tavily, Exa, Perplexity, Serper, Firecrawl, Brave. - **Provider-native path:** Anthropic, OpenAI/Copilot, Gemini, Moonshot. - **Fallback:** if search is weak, ship `web_fetch` or browser automation and make the model do the rest. The interesting engineering is not the backend name. It is everything around it: ### Search/fetch separation Claude Code, Crush, DeerFlow, Pochi, and Qwen all keep "find the page" separate from "read the page." That split matters because fetch needs a different permission, extraction, and token-budget story from search. ### Mode control Codex is especially interesting here: cached, live, and disabled web-search modes are treated as a real configuration axis rather than a hidden feature flag. ### Method enforcement DeerFlow and Crush stand out because they tell the agent *how* to research: start broad, narrow down, follow links, validate, synthesize, and carry sources through to the result. ### Source discipline Pochi and Crush explicitly push the model toward returning a source list. That sounds small, but it is the difference between a web tool that looks smart and one that remains auditable. ## What I would steal for a new coding agent ### DeerFlow's research phases "Broad exploration → deep dive → diversity & validation → synthesis check" is exactly the sort of explicit method most agents are missing. It converts search from a toy tool into a repeatable operator behavior. ### Crush's agentic\_fetch child This is the most copyable coding-agent pattern in the set: spawn a smaller child with search, fetch, grep, glob, and view; tell it to decompose the question; make it return sources. ### Claude Code's tool split Search, fetch, explore, and plan are separate surfaces. That makes permissions, UI, and delegation cleaner than the monolithic "do web stuff" tools common elsewhere. ### Wintermolt's default-free posture A working DDG search backend plus browser control in a compact runtime is a great reminder not to over-engineer the first version. ### Reasonix's engine menu One free default, one self-hosted path, and several premium upgrades is a much healthier operator story than "here are six paid APIs, good luck." ### Codex's mode knob Treating web search as cached/live/disabled is better than burying the behavior in undocumented provider assumptions. Search needs a policy surface just like sandboxing and approvals do. ## If I had to pick one or two 🏁 #### My actual picks If I only get **one overall pick**, I take **DeerFlow**. It is the most complete answer to the actual problem: free defaults, optional premium upgrades, and the best built-in research methodology in the current repo set. If I get **a second pick**, I take **Crush**. It is the best example of a coding-agent-shaped runtime that gives you current information with no separate search API bill and turns that into a delegated multi-step workflow instead of a one-off query. My honorable mentions would be: - **Wintermolt** for the cleanest lightweight free search + browser stack - **Claude Code** for the strongest integrated provider-native product design - **Codex** for joining that provider-native tier more clearly than older summaries implied - **Reasonix** for the most operator-friendly engine menu ## Recommendations for new agent builders 1. **Ship one no-extra-search-fee path by default.** Even if the premium integrations are excellent, the harness should work out of the box with DDG, Bing, SearXNG, or provider-native grounding. 2. **Separate search from fetch from browser control.** Discovery, extraction, and interaction are different permission and UX problems. 3. **Write the research method down.** A prompt or skill that explicitly says "search broadly, then narrow, then validate, then synthesize" is more valuable than adding a fifth search provider. 4. **Demand sources.** If the harness cannot surface what URLs informed the answer, the web tool is incomplete. 5. **Expose a mode knob.** Cached/live/disabled, free/paid, or local/remote: the operator should be able to control how much web access the agent is using. 6. **Do not confuse a browser with a research system.** Browser automation is valuable, but it is not the same thing as planning searches, comparing sources, and preserving provenance. ## Bottom line The field is not boring, but the boring parts are increasingly easy to spot. Everyone can wire in a paid API. Everyone can add a fetch tool. The repos worth copying are the ones that make a clear choice about defaults, cost, and method. **DeerFlow** wins on research discipline. **Crush** wins on no-extra-search-fee coding-agent pragmatism. **Wintermolt** wins on compact free implementation. **Claude Code**, **Codex**, and **ADK-Rust** show what provider-native search looks like when it is taken seriously. And the rest of the field mostly falls into one of three buckets: wrappers, fetch-only helpers, or repos that simply are not trying to solve this problem yet.