Search the web using Kagi's curated search index.

Use this as an alternative to web_search when it returns few or poor quality results. Kagi's index is independently curated, resistant to SEO spam, and may surface different sources. Returns compact results with snippets and timestamps — much lighter on context than web_search's summarized snippets, making it better suited for multi-query research workflows.

Switch result categories via workflow= (search / images / videos / news / podcasts). Cap returns with limit=, scope with lens_id=, paginate with page=, filter by region= / after= / before=. The query string supports site: / filetype: / intitle: / inurl: filters, "exact phrases", +/- terms, boolean (A AND B) / (A OR B) grouping, and * wildcards — full operator syntax is on the query parameter.

List a document's section headings to understand page composition or plan targeted extraction.

Returns a heading tree with anchor slugs — a cheap structural preview that avoids pulling the page body. Typical use: call this first to decide which sections of a long page are worth fetching, then follow up with web_fetch_incisive using the returned heading names as section= or slugs as slices=. URL fragments (e.g. #section-name) are resolved against the heading tree.

For a quick sense of document scope, the section tree reveals structure at minimal cost and leaves the source material unsummarized for precise follow-up.

For Reddit threads, returns the comment tree with author, score, and content length metadata. Comment IDs serve as section identifiers for follow-up extraction of specific subthreads.

Fetch and extract unsummarized content from URLs as markdown.

Unlike web_fetch, fetches through the user's device instead of proxying through Anthropic's servers. Uses precise content extraction techniques and clean first-party APIs for navigating content instead of summarization. Use this for a rich content exploring experience that is not subject to 403 bans of data-center subnets, or when web_fetch is rejected with PERMISSIONS_ERROR.

Targeted extraction (preferred over fetching full pages):

• section="Syntax" — extract a specific section by heading name

• search="terms" — keyword search over ~500-token slices, ranked by BM25

• slices=[3, 4, 5] — retrieve specific slices by index

• URL fragments (#section-name) are resolved automatically as sections

RECOMMENDED WORKFLOW: For pages of substantial or unknown length, call web_fetch_sections first to map the heading tree, then come back here with precise section= or slices= targets. A full-page fetch is rarely the right first move — it fills context with material you don't need and discards the structural information that makes follow-up queries cheap. For Reddit threads, web_fetch_sections returns the comment tree instead.

search= operators (tantivy query language):

• foo bar — match any term (whitespace is OR)

• +foo +bar — require both terms

• foo -bar — exclude 'bar'

• "exact phrase" — adjacent words in order

• "some words"~3 — phrase with up to 3-word gaps

• (foo OR bar) baz — grouping + AND/OR/NOT

• foo~ — fuzzy match (edit distance) Matching is case-insensitive; no stemming (search for both 'prompt' and 'prompts' if you want either). Stray punctuation in natural-language queries is silently dropped.

For Wikipedia and other MediaWiki pages, a dedicated companion tool offers footnote and inline-citation resolution that this fast path can't provide. When the target page has those reference types, the response frontmatter surfaces a see_also hint pointing at it.

Always use this tool for Reddit URLs — built-in fetch tools cannot access Reddit content when proxied. Handles posts, subreddit listings, user pages, and comment permalinks; a permalink scopes output to the linked comment while caching the whole thread for follow-up section=/slices= queries.

JavaScript-dependent pages: a plain fetch returns static HTML. When that comes back as an empty shell, the response frontmatter says so — retry with requires_js=true to render through a headless browser. requires_js is the heavier path; reach for it in response to that signal, not by default. Pass actions to run a ReAct interaction chain before extraction (supplying actions implies requires_js):

• {"action": "click", "selector": "button#submit"}

• {"action": "fill", "selector": "input[name=query]", "value": "search term"}

• {"action": "select", "selector": "select#region", "value": "us-east"}

• {"action": "wait", "selector": ".results-loaded"} A browser render annotates interactive elements for follow-up actions; max_elements caps that list, and 0 omits it.

Supports HTML, plain text, JSON, and XML content types.

Search and retrieve academic papers from arXiv.

Use this for arXiv paper lookups: search by query, get paper details (abstract, authors, categories, affiliations, DOI, journal refs), or browse recent papers by category. arXiv abstract and PDF URLs are also handled automatically by web_fetch_incisive.

Actions: search, paper, category.

Query formats:

• search: arXiv query syntax, NOT natural language (see operators below)

• paper: arXiv ID (e.g. "2301.00001", "cs.CL/0501001") or arXiv URL

• category: arXiv category code (e.g. "cs.CL", "math.CO", "astro-ph.GA")

search operators:

• Field prefixes: ti: (title), au: (author), abs: (abstract), cat: (category), all: (all fields), co: (comment), jr: (journal ref)

• Boolean operators: AND, OR, ANDNOT

• Examples: "ti:attention AND cat:cs.CL", "au:vaswani AND ti:transformer"

Papers retrieved via the paper action are automatically tracked on the research shelf.

Manage the research shelf — an in-memory tracker for papers inspected during research.

Papers are automatically added when the following tools resolve a paper, RFC, or citable repository: arxiv, semantic_scholar, ietf, github (for repos with CITATION.cff), and web_fetch_incisive (via its DOI fast path). Use this tool to review, score, confirm, or remove tracked entries, and to export citations in BibTeX, RIS, or JSON format.

Actions: list, confirm, remove, score, note, export, import, clear.

Query formats:

• list: section name (active, retracted, all) — default active

• confirm/note: DOI of the paper (note takes DOI + space + note text)

• remove: comma-separated DOIs

• score: DOI + space + integer (e.g. "10.1234/foo 8")

• export: format name (bibtex, ris, json), optionally "with_retracted" (e.g. "bibtex with_retracted")

• import: JSON export string (merges with current shelf)

• clear: ignored

The shelf survives context compaction within the same session. For cross-session persistence, use export json to save the shelf to a memory file, then import it in a future session.

Search and retrieve code, issues, pull requests, and repositories from GitHub.

Use this for GitHub lookups: search issues/PRs across repositories, search for repositories by topic/stars/language, search code, get issue or PR details with comments, fetch file content from a specific ref, get repo metadata with README, or inspect a repo's custom issue submission flow (forms, markdown templates, contact-link routing) before filing a new issue. GitHub URLs are also handled automatically by web_fetch_incisive — this tool is for structured queries by owner/repo/number.

Actions: search_issues, search_repos, search_code, issue, pull_request, file, repo, tree, issue_templates.

Query formats vary by action:

• search_issues/search_code: GitHub search query with qualifiers (repo:, is:, label:, language:, path:)

• search_repos: GitHub search query with qualifiers (topic:, stars:, language:, forks:, license:)

• issue/pull_request: "owner/repo#number" (e.g. "pallets/flask#5618")

• file/tree: "owner/repo/path" (e.g. "pallets/flask/src/flask/app.py") — use ref= for branch/tag

• repo: "owner/repo" (e.g. "pallets/flask")

• issue_templates: "owner/repo" (e.g. "pallets/flask") — call before filing an issue if the repo action's frontmatter hints at custom submission flow

Authentication: Set GITHUB_TOKEN env var or create ~/.config/parkour/github_token for 5000 req/hr (vs 60/hr unauthenticated). No special scopes needed for public repos.

Inspect HuggingFace Hub models: metadata, files, and quantization quality.

Use this for model-repo lookups: architecture and parameter count, checkpoint size and shard layout, gated/private status, base-model lineage, per-file sizes and LFS checksums, and a quantization analysis that reports effective bits per weight rather than what the uploader claimed. huggingface.co URLs are also handled automatically by web_fetch_incisive — this tool is for structured queries.

Actions: model, file, tree, search, org.

Query formats vary by action:

• model: "org/name" (e.g. "openai/gpt-oss-120b"), optionally "org/name@revision"

• file: "org/name/path/to/file" (e.g. "openai/gpt-oss-120b/config.json") — use ref= for a branch/tag

• tree: "org/name" or "org/name/subdirectory"

• search: free text (Hub search is substring-based over repo ids); pair with author= to scope

• org: an organization or user name (e.g. "mlx-community")

Weight files are never downloaded. Asking for a .safetensors or .gguf file returns its size, LFS checksum, and the byte-range recipe for reading the header — a multi-GB shard exposes its per-tensor dtypes and shapes in a header of a few hundred KiB.

On the model action, effective bits-per-weight is suppressed rather than guessed whenever the Hub's own numbers cannot support it: packed storage counts reported as parameter counts, repos shipping more than one checkpoint set, diffusers pipelines, and GGUF-only repos each get an explicit explanation instead of a misleading number. Set quant_audit=true to spend one extra request reading the base model's native weight format, which resolves several of those cases and yields a grid-preservation verdict.

Authentication: optional. Set HF_TOKEN env var or create ~/.config/parkour/hf_token to reach gated and private repos and raise the rate limit. Without a token the Hub returns an identical 401 for gated, private, and nonexistent repos, and this tool reports that ambiguity rather than guessing which one it hit.

Search and retrieve IETF RFCs, Internet-Drafts, and standards-track documents.

Use this for RFC lookups: get RFC details (abstract, authors, status, relationship chains), search RFCs by keyword, look up Internet-Drafts, or resolve STD/BCP/FYI subseries bundles. RFC Editor and Datatracker URLs are also handled automatically by web_fetch_incisive.

Actions: rfc, search, draft, subseries.

Query formats:

• rfc: RFC number (e.g. "9110"), RFC URL, or DOI (10.17487/RFC9110)

• search: keywords for title search via IETF Datatracker

• draft: Internet-Draft name (e.g. "draft-ietf-httpbis-semantics") or URL

• subseries: subseries identifier (e.g. "STD97", "BCP14", "FYI36")

Optional filters for search: status (ps, std, bcp, inf, exp, hist), wg (working group acronym like "httpbis" or "tls").

RFCs have native DOIs (10.17487/RFC{N}) and are automatically tracked on the research shelf when inspected.

Search and inspect software packages across language ecosystems via deps.dev.

Use this for package lookups: get version history, licenses, security advisories, dependency graphs, OpenSSF Scorecards, and SLSA provenance data. Covers 7 ecosystems: npm, PyPI, Go, Maven, Cargo, NuGet, and RubyGems.

Actions: package, version, dependencies, project, advisory.

Query formats:

• package/version/dependencies: ecosystem/name[@version] (e.g. "pypi/requests", "npm/express@4.18.2")

• project: github.com/owner/repo (e.g. "github.com/psf/requests")

• advisory: advisory ID (e.g. "GHSA-9hjg-9r4m-mvj7")

Ecosystem aliases: pypi, npm, cargo/crates, go/golang, maven, nuget, rubygems/gems.

For repository details (README, issues, code), use web_fetch_incisive or github.

Search and browse Discourse forum topics.

Use this for Discourse forum lookups: fetch a topic with all posts, search a forum, or browse recent topics. Discourse URLs are also detected automatically by web_fetch_incisive via response headers — this tool is for structured queries when you know the forum's base URL.

Actions: topic, search, latest.

Query formats:

• topic: full topic URL (e.g. 'https://meta.discourse.org/t/topic-slug/12345')

• search: search query string (requires base_url)

• latest: ignored (requires base_url to identify the forum)

The base_url parameter identifies which Discourse instance to query (e.g. 'https://meta.discourse.org'). For the topic action, base_url is inferred from the URL if not provided.

No authentication required for public forums.

Search and retrieve content from Wikipedia and other MediaWiki sites.

Use this for direct Wikipedia access without resorting to web_search with site: filters. Fetches articles by title (no URL guessing), runs native full-text wiki search, and resolves footnotes/inline citations on a specific article. Wikipedia URLs are also handled automatically by web_fetch_incisive.

Actions: page, search, references.

PARAMETER SPLIT: unlike other dedicated tools, this one uses two primary parameters:

• title= for 'page' and 'references' (article identifier: title or URL)

• query= for 'search' only (search terms) The dispatcher will reject mismatches with a specific error.

Query formats:

• page: title (e.g. "Gödel's incompleteness theorems") or full Wikipedia URL. Supports section=, search= (within-page BM25), and slices= for targeted extraction.

• search: keywords (e.g. "quantum entanglement"). Supports MediaWiki search operators.

• references: title identifying the page; supply footnotes=[1,2] and/or citations=["#CITEREFFoo2005"] to resolve numbered footnotes and/or inline author-date citations. Both can be passed in one call.

search= operators (tantivy query language):

• foo bar — match any term (whitespace is OR)

• +foo +bar — require both terms

• foo -bar — exclude 'bar'

• "exact phrase" — adjacent words in order

• "some words"~3 — phrase with up to 3-word gaps

• (foo OR bar) baz — grouping + AND/OR/NOT

• foo~ — fuzzy match (edit distance) Matching is case-insensitive; no stemming (search for both 'prompt' and 'prompts' if you want either). Stray punctuation in natural-language queries is silently dropped.

Wiki instance via wiki= parameter:

• Language code: "en" (default), "de", "simple", "zh-yue", "pt-br"

• Sister project: "commons", "wikidata", "meta", "species"

• Hostname/URL: "en.wikipedia.org", "https://wiki.archlinux.org"

• Ignored when title= is a full URL (URL wins)

Fetch YouTube content via yt-dlp and youtube-transcript-api.

Use this for YouTube lookups when web_fetch_incisive doesn't apply: structured metadata + description for a video, a rendered caption transcript with timing and search, a flat listing of recent uploads for a channel or items for a playlist, or a YouTube-wide search by free-text query.

Actions: video, transcript, channel, playlist, search.

PARAMETER SPLIT: video / transcript / channel / playlist take url=; search takes query=.

Query formats:

• video: full YouTube URL (watch?v=, youtu.be/, shorts/, clip/, embed/, or v/)

• transcript: same URL formats as video; combine with languages=, timestamps=, search=, windows=, start_seconds=, end_seconds=, order=

• channel: /@handle, /channel/UC..., /c/, /user/. The bare channel URL returns the channel's available tabs (Videos, Shorts, Live, etc.). Append /videos, /shorts, /streams, /playlists, or /podcasts to list the actual entries within that tab.

• playlist: /playlist?list=...

• search: free-text query (passed to yt-dlp's ytsearch{N}: routing).

Transcript actions:

• Default (no search/windows/range): full transcript in the requested timestamps= shape.

• search="query": BM25 over window text, with optional time-range filter.

• start_seconds/end_seconds: half-open time-range filter.

• windows=[i, ...]: explicit retrieval by window index. Mutually exclusive with search and time-range filters.

• order=score (default) or order=time: BM25 vs chronological ordering.

Transcript timestamps= modes:

• compact (default): sparse anchors at ~30s windows plus inline markers for unusually long pauses; each source caption cue on its own line. Hybrid shape that preserves citation precision while keeping token cost low.

• absolute: per-line [MM:SS] prefix on every cue.

• none: flat text with no timing.

• structured: YAML list of {t, d, text} triples for machine consumers.

Auto-generated captions lack punctuation and capitalization; the 'transcript_kind' field in frontmatter signals which to expect. The chunking strategy adapts: punctuated input gets sentence-aware window cuts; unpunctuated input falls back to pause-aware time windows.

Channel, playlist, and search listings use yt-dlp's flat extraction, returning stub entries with id, title, duration, and view count. Set limit= to control how many entries (default 30, max 200). When a bare channel URL is passed, the response surfaces the channel's tab list with a frontmatter hint nudging toward /videos, /shorts, etc. — pick the right tab and resubmit. Search results match what the user would see browsing youtube.com/results?search_query=... since yt-dlp routes through the same Innertube endpoint.

A 'video' call returns the description. Comments live on the dedicated youtube_comments — the video frontmatter surfaces a 'see_also' pointing there when the channel reports a non-zero comment count, so callers can pivot when they want to read the conversation.

Music URLs (music.youtube.com) are out of scope and will be handled by a sibling tool.

No authentication required. May fail with bot-detection or PoTokenRequired errors; residential connections fare best. The fallback workaround when blocked is to set HTTPS_PROXY to a residential proxy endpoint.

Read YouTube video comments: top-level overview or per-thread drill-down.

Pivot from youtube when the goal is to read what viewers are saying about a video. The video tool returns the description; this tool returns the conversation.

Two views, selected by whether comment_id is set:

• Overview (no comment_id): top-level comments sorted by 'top', each with author, score, pinned/uploader badges, and a yt-dlp comment id for drill-down. No replies.

• Thread (comment_id=): the target top-level comment plus its replies (up to 50 per thread).

The flow matches how a human reads YouTube comments: skim top-level statements for what people thought of the video, then drill into threads that look interesting (high score, pinned, uploader replied).

URL formats accepted: same as the youtube video action — watch?v=, youtu.be/, shorts/, clip/, embed/, v/.

No authentication required. Comment-fetch failures (bot detection, private video, age-restricted) surface as user-facing error strings via the same exception mapping as youtube.