Agent skill

Active Research

Deep research and analysis tool. An agent skill from actionbook/actionbook.

Apache-2.0Auto-check passedResearch & Science

Install Active Research

skills CLI

$ npx skills add actionbook/actionbook --skill active-research -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install actionbook/actionbook active-research --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/actionbook/actionbook.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/active-research .claude/skills/active-research && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "active-research" agent skill from https://github.com/actionbook/actionbook/tree/main/skills/active-research into .claude/skills/active-research/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "active-research", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/actionbook/actionbook/tree/main/skills/active-research

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add actionbook/actionbook --skill active-research -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install actionbook/actionbook active-research --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/actionbook/actionbook.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/active-research .agents/skills/active-research && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "active-research" agent skill from https://github.com/actionbook/actionbook/tree/main/skills/active-research into .agents/skills/active-research/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "active-research", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add actionbook/actionbook --skill active-research -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install actionbook/actionbook active-research --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/actionbook/actionbook.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/active-research .cursor/skills/active-research && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "active-research" agent skill from https://github.com/actionbook/actionbook/tree/main/skills/active-research into .cursor/skills/active-research/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "active-research", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/actionbook/actionbook.git --path skills/active-research

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add actionbook/actionbook --skill active-research -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install actionbook/actionbook active-research --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/actionbook/actionbook.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/active-research .gemini/skills/active-research && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "active-research" agent skill from https://github.com/actionbook/actionbook/tree/main/skills/active-research into .gemini/skills/active-research/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "active-research", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install actionbook/actionbook active-research

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add actionbook/actionbook --skill active-research -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/actionbook/actionbook.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/active-research .github/skills/active-research && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "active-research" agent skill from https://github.com/actionbook/actionbook/tree/main/skills/active-research into .github/skills/active-research/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "active-research", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add actionbook/actionbook --skill active-research -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install actionbook/actionbook active-research --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/actionbook/actionbook.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/active-research .opencode/skills/active-research && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "active-research" agent skill from https://github.com/actionbook/actionbook/tree/main/skills/active-research into .opencode/skills/active-research/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "active-research", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: active-research
GitHub stars: 1.6k
Used in: 1 other repo
Token cost: ~8.2k tokens
SKILL.md length: 2,297 words
Files: 1
Skills in repo: 13
Repo updated: Sep 8, 2026
First seen: Oct 7, 2026
Licence: Apache-2.0

At a glance

Deep research and analysis tool. An agent skill from actionbook/actionbook.

Works in 10 steps: Plan Search Strategy → Query Actionbook API for Selectors… → arXiv Search (URL-First, Form as Backup) → …
User asks to research
SKILL.md covers Enhanced Browser Capabilities, Usage, Architecture and MUST USE Actionbook CLI, plus 7 more sections
Calls npx, python and node; reaches arxiv.org and ar5iv.org

What it does

Active Research is an agent skill from actionbook/actionbook. Deep research and analysis tool. Generates comprehensive HTML reports on any topic, domain, paper, or technology. Enhanced with advanced browser automation — SPA handling, network idle wait, batch operations, stealth browsing, and intelligent page analysis. Use when user asks to research, analyze, investigate, deep-dive, or generate a report on any subject.

Its SKILL.md is about 8.2k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Research & Science, covering Browser automation and Deep research. The repository describes itself as: Let your AI agent get the sources behind logins and paywalls. The licence is Apache-2.0.

When your agent uses it

User asks to research
Generate a report on any subject

Example prompts

“/active-research”

Requirements

Python 3

Workflow steps

10 steps, taken from the step headings in SKILL.md.

Plan Search Strategy
Query Actionbook API for Selectors (ALWAYS DO THIS FIRST)
arXiv Search (URL-First, Form as Backup)
Supplement with Google / Bing Search
Deep Read Sources
Synthesize Findings
Generate json-ui JSON Report
Render HTML
Open in Browser
Close Browser

What it can do on your machine

Read from SKILL.md and the folder at commit 0e31254. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Shell commands in SKILL.md call:
- npx
- python
- node
- git
- npm
From the folder's file list and the shell code blocks in SKILL.md.
Network
Hosts in commands or code, which the agent is likely to contact:
- arxiv.org
- ar5iv.org
- google.com
- bing.com
- huggingface.co
- scholar.google.com
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Active Research loads about 8.2k tokens when it runs. Until then it costs about 94 tokens; SKILL.md has 2,297 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~94
When it runs · the whole SKILL.md, loaded when a task matches: ~8.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from actionbook/actionbook at commit 0e31254, republished under its Apache-2.0 licence (© actionbook). 2,297 words, ~8,150 tokens.

Download SKILL.mdSave it as .claude/skills/active-research/SKILL.md (or your agent's skills folder).

name: active-research
description: Deep research and analysis tool. Generates comprehensive HTML reports on any topic, domain, paper, or technology. Enhanced with advanced browser automation — SPA handling, network idle wait, batch operations, stealth browsing, and intelligent page analysis. Use when user asks to research, analyze, investigate, deep-dive, or generate a report on any subject.
exclude_tools: group:web
triggers: research, deep-dive, investigate, analyze topic, deep research, generate report
force_tool_turns: 10

Active Research

Analyze any topic, domain, or paper and generate a beautiful HTML report using Actionbook Browser — featuring SPA-aware navigation, network idle detection, batch operations, and intelligent page analysis.

Enhanced Browser Capabilities

Capability	Description
Page load wait	`wait-idle` — monitors fetch/XHR until network settles
SPA content	`wait-fn` — wait for JS conditions before extracting
Page understanding	`snapshot --filter interactive --max-tokens N` — focused, budget-friendly
Popups blocking	`--auto-dismiss-dialogs` — auto-handle alert/confirm/prompt
Load speed	`--block-images` — skip images for faster text extraction
Page stability	`--no-animations` — freeze CSS transitions
Error detection	`console --level error` — check for page issues
Multi-step forms	`batch` — execute multiple actions in one call
Element debugging	`info <selector>` — inspect visibility, position, properties
Change tracking	`snapshot --diff` — only see what changed
Anti-detection	`--stealth` + `fingerprint rotate` for protected sites
Auth management	`storage set` — inject JWT/tokens for gated content
One-shot fetch	`browser fetch <url>` — navigate+wait+extract+close in one command
Static page speed	`--lite` — HTTP-first, browser fallback only if needed
Anti-scrape URLs	`--rewrite-urls` — x.com→xcancel.com, reddit→old.reddit
Wait tuning	`--wait-hint` — domain-aware wait (fast/normal/slow/heavy)
Log correlation	`--session-tag` — tag all operations for debugging

Usage

/active-research <topic>
/active-research <topic> --output ./reports/my-report.json

Or simply tell Claude: "Research XXX and generate a report"

Parameters

Parameter	Required	Default	Description
`topic`	Yes	-	The subject to research (any text)
`--output`	No	`./output/<topic-slug>.json`	Output path for JSON report

Topic Detection

Pattern	Type	Strategy
`arxiv:XXXX.XXXXX`	Paper	arXiv Advanced Search + ar5iv deep read
`doi:10.XXX/...`	Paper	Resolve DOI, then arXiv Advanced Search for related work
Academic keywords (paper, research, model, algorithm)	Academic topic	arXiv Advanced Search + Google for non-academic sources
URL	Specific page	Fetch and analyze the page
General text	Topic research	Google search + arXiv Advanced Search if relevant

Architecture

┌──────────┐     ┌──────────────┐     ┌──────────────┐     ┌──────────┐
│  Claude   │────▶│  Actionbook  │────▶│  Web Pages   │────▶│ Extract  │
│  Code     │     │   Browser    │     │  (multiple)  │     │ Content  │
└──────────┘     └──────────────┘     └──────────────┘     └─────┬────┘
      │           │ wait-idle    │     │ SPA / dynamic │           │
      │           │ batch ops    │     │ protected     │           │
      │           │ --stealth    │     │ mobile-only   │           │
      │           │ snapshot     │     └───────────────┘           │
      │           └──────────────┘                                 │
      │          ┌──────────────┐     ┌──────────────┐            │
      ├─────────▶│  Actionbook  │     │ arXiv Adv.   │            │
      │          │  search/get  │────▶│ Search Form  │───────────▶│
      │          │  (selectors) │     │ (40+ fields) │            │
      │          └──────────────┘     └──────────────┘            │
      │                                                            │
┌──────────┐     ┌──────────────┐     ┌──────────────┐            │
│  Open in │◀────│   json-ui    │◀────│  Write JSON  │◀───────────┘
│  Browser │     │   render     │     │  Report      │  Synthesize
└──────────┘     └──────────────┘     └──────────────┘

MUST USE Actionbook CLI

Always use actionbook browser commands for web browsing. NEVER use any other method to access the web:

NEVER use curl, wget, httpie, or any HTTP CLI tool via bash
NEVER use python -c "import requests" or any scripting-language HTTP library via bash
NEVER use WebFetch or WebSearch tools
ONLY use actionbook browser and actionbook search/actionbook get commands

If you need web content, the PREFERRED path is: actionbook browser fetch <url> --format text --json (one-shot). For interactive multi-step workflows, use: actionbook browser open <url> → actionbook browser wait-idle → actionbook browser text.

Browser Flags — Research Defaults

CRITICAL: Always use these flags when opening the browser for research.

bash

# PREFERRED: One-shot fetch (I1) — handles open+wait+extract+close automatically
actionbook --block-images --rewrite-urls browser fetch "<url>" --format text --json

# For interactive multi-step workflows, use explicit open:
actionbook --block-images --auto-dismiss-dialogs --no-animations --rewrite-urls browser open "<url>"

Flag	Why
`--block-images`	Skip image downloads — 2-5x faster page load for text extraction
`--auto-dismiss-dialogs`	Prevent alert/confirm/prompt from blocking automation
`--no-animations`	Freeze CSS animations — stable snapshots, no timing issues
`--rewrite-urls`	Rewrite x.com→xcancel.com, reddit→old.reddit to avoid anti-bot blocking
`--wait-hint <hint>`	Domain-aware wait: `instant`, `fast`, `normal`, `slow`, `heavy`, or ms
`--session-tag <tag>`	Tag all operations for log correlation and debugging
`--lite` (fetch only)	Try HTTP first, skip browser for static pages (Wikipedia, docs, blogs)

For sites with anti-bot protection, add --stealth:

bash

actionbook --block-images --auto-dismiss-dialogs --no-animations --stealth --rewrite-urls browser open "<url>"

Option A: One-shot fetch (PREFERRED for read-only page extraction):

bash

# Single command: navigate → wait (domain-aware) → extract → close
actionbook --block-images --rewrite-urls browser fetch "<url>" --format text --json
# For static pages (Wikipedia, docs, blogs), add --lite to skip browser entirely:
actionbook --rewrite-urls browser fetch "<url>" --format text --lite --json
# For accessibility tree:
actionbook --block-images --rewrite-urls browser fetch "<url>" --format snapshot --max-tokens 2000 --json

Option B: Interactive multi-step pattern (for forms, clicks, multi-page flows):

bash

# Step 1: Navigate
actionbook browser open "<url>"          # or: goto, click a link

# Step 2: Wait for load (MANDATORY in v2)
actionbook browser wait-idle             # Wait for fetch/XHR to settle

# Step 3: Extract content
actionbook browser text [selector]       # Extract text
# OR
actionbook browser snapshot --filter interactive --max-tokens 500  # Understand page structure

Why wait-idle is critical:

SPAs (React, Vue, Next.js) load content via fetch/XHR after initial HTML
Without waiting, text returns empty or incomplete content
wait-idle monitors all pending network requests, waits until quiet for 500ms

For pages that load content dynamically after network settles:

bash

actionbook browser wait-idle
actionbook browser wait-fn "document.querySelector('.results')"    # Wait for specific element
actionbook browser text ".results"

Complete Workflow

REMINDER: Every web access in this workflow MUST use actionbook browser commands. Using curl, wget, python requests, or any other HTTP tool is strictly forbidden. The bash tool should ONLY be used for actionbook CLI commands and local file operations (json-ui render, open).

Step 1: Plan Search Strategy

Based on the topic, generate 5-8 search queries from different angles:

Core definition / overview
Latest developments / news
Technical details / implementation
Comparisons / alternatives
Expert opinions / analysis
Use cases / applications

Search order — ALWAYS query Actionbook API first, then search:

Step	Action	Why
Step 2 (FIRST)	Query Actionbook API	Get verified selectors for arXiv, ar5iv, and other known sites BEFORE browsing.
Step 3 (SECOND)	arXiv Advanced Search	Use Actionbook selectors for multi-field, filtered academic search.
Step 4 (THIRD)	Google / Bing search	Supplement with blogs, news, code, discussions, non-academic sources.

Step 2: Query Actionbook API for Selectors (ALWAYS DO THIS FIRST)

BEFORE browsing any URL, query Actionbook's indexed selectors.

bash

# Search for indexed actions by domain
actionbook search "<keywords>" -d "<domain>"

# Get detailed selectors for a specific page
actionbook get "<domain>:/<path>:<area>"

Pre-indexed sites useful for research:

Site	area_id	Key Selectors
arXiv Advanced Search	`arxiv.org:/search/advanced:default`	40+ selectors: field select, term input, category checkboxes, date range filters
ar5iv paper	`ar5iv.labs.arxiv.org:/html/{paper_id}:default`	`h1.ltx_title_document`, `div.ltx_authors`, `div.ltx_abstract`, `section.ltx_section`
Google Scholar	`scholar.google.com:/:default`	`#gs_hdr_tsi` (search), `#gs_hdr_tsb` (submit)
arXiv homepage	`arxiv.org:/:default`	Global search across 2.4M+ articles

For any URL you plan to visit, run actionbook search "<keywords>" -d "<domain>" to check if it's indexed.

Step 3: arXiv Search (URL-First, Form as Backup)

LESSON LEARNED: arXiv form submission via browser automation is unreliable. Use URL-based search as the PRIMARY method.

Option A: URL-based search (PRIMARY — most reliable):

bash

# Simple keyword search
actionbook --block-images --auto-dismiss-dialogs --no-animations browser open "https://arxiv.org/search/?query=large+language+model+agent&searchtype=all"
actionbook browser wait-idle
actionbook browser text "#main-container"

# Advanced URL search with filters
# searchtype: all, title, author, abstract
# start: result offset (0, 50, 100, ...)
actionbook browser open "https://arxiv.org/search/?query=Rust+machine+learning&searchtype=all&start=0"
actionbook browser wait-idle
actionbook browser text "#main-container"

Search strategy: Start broad, then narrow:

First search: broad terms (e.g., "Rust" "machine learning") — aim for 50+ results
If too few results (< 10): broaden further, remove date/category filters
If too many results (> 200): add more specific terms, use searchtype=title
Try 2-3 different query angles (e.g., framework names, use cases, benchmarks)

Option B: Form interaction via batch (BACKUP — use if URL search is insufficient):

bash

# Open arXiv with research flags
actionbook --block-images --auto-dismiss-dialogs --no-animations browser open "https://arxiv.org/search/advanced"
actionbook browser wait-idle

# Use batch for form — fewer round-trips, more reliable
cat <<'EOF' | actionbook browser batch --delay 150
{
  "actions": [
    {"kind": "click", "selector": "#terms-0-field"},
    {"kind": "click", "selector": "option[value='title']"},
    {"kind": "type", "selector": "#terms-0-term", "text": "large language model agent"},
    {"kind": "click", "selector": "#classification-computer_science"},
    {"kind": "click", "selector": "#date-filter_by-3"},
    {"kind": "type", "selector": "#date-from_date", "text": "2025-01-01"},
    {"kind": "type", "selector": "#date-to_date", "text": "2026-02-23"},
    {"kind": "click", "selector": "button:has-text('Search'):nth(2)"}
  ],
  "stopOnError": true
}
EOF
actionbook browser wait-idle
actionbook browser text "#main-container"

# If batch form submission fails (page shows form again instead of results):
# → Fall back to Option A URL-based search immediately
# → Do NOT retry the form — it wastes time

arXiv search capabilities (from indexed selectors — for Option B):

Capability	Selector
Search field (Title/Author/Abstract)	`#terms-0-field` select
Search term	`#terms-0-term` input
Add boolean terms	`button "Add another term +"`
Filter: Computer Science	`#classification-computer_science`
Filter: Physics, Math, etc.	`#classification-physics`, `#classification-mathematics`
Date: past 12 months	`#date-filter_by-1` radio
Date: specific year	`#date-filter_by-2` radio + `#date-year`
Date: custom range	`#date-filter_by-3` radio + `#date-from_date` / `#date-to_date`
Show abstracts	`#abstracts-0` radio

Step 4: Supplement with Google / Bing Search

bash

# Search via Google (with wait-idle for SPA results)
actionbook browser open "https://www.google.com/search?q=<encoded_query>"
actionbook browser wait-idle
actionbook browser text "#search"

# Or search via Bing
actionbook browser open "https://www.bing.com/search?q=<encoded_query>"
actionbook browser wait-idle
actionbook browser text "#b_results"

Parse search results to extract URLs. For each discovered URL, query Actionbook API to check if indexed.

CRITICAL: URL Handling Rules (Learned from Production Use)

NEVER manually construct URLs from search snippets. Many Google snippet URLs are truncated or reformatted. Instead:
- Use actionbook browser snapshot --filter interactive to find actual link elements
- Click the link directly: actionbook browser click "a[href*='domain.com']"
- Or extract href from snapshot refs

Expect 20-30% of URLs to be dead. In practice, ~5 out of 20 URLs return 404. Handle this:

bash

actionbook browser open "<url>"
actionbook browser wait-idle
# Check if the page is a 404 or error page
actionbook browser wait-fn "!document.title.includes('404') && !document.title.includes('Not Found')" --timeout 3000
# If timeout → page is dead, skip immediately. Do NOT retry.

Salvage info from Google snippets. If a URL is dead but the Google snippet had useful info:
- The snippet text you already extracted IS valid data
- Use it in the report with a note that the source is no longer available
- Search for the same content on alternative sites (archive.org, cached versions)
Use 4+ diverse search queries. Don't rely on one search angle:
- Query 1: Core topic overview (e.g., "Rust AI ecosystem 2026")
- Query 2: Specific frameworks/tools (e.g., "Candle vs Burn Rust ML framework")
- Query 3: Use cases/benchmarks (e.g., "Rust LLM inference performance benchmark")
- Query 4: Recent news/developments (e.g., "Rust machine learning latest 2026")
- Query 5: Community/ecosystem (e.g., "Rust AI agent framework comparison")

Step 5: Deep Read Sources

PREFERRED: Use browser fetch for one-shot page extraction (handles wait + extract + cleanup):

bash

# Quick text extraction (most common)
actionbook --block-images --rewrite-urls browser fetch "<url>" --format text --json

# Static pages (Wikipedia, docs, blogs) — skip browser entirely
actionbook --rewrite-urls browser fetch "<url>" --format text --lite --json

# Page structure analysis
actionbook --block-images --rewrite-urls browser fetch "<url>" --format snapshot --max-tokens 2000 --json

# With token budget for LLM context management
actionbook --block-images --rewrite-urls browser fetch "<url>" --format text --max-tokens 4000 --json

For interactive workflows (forms, clicks), fall back to multi-step:

bash

actionbook browser open "<url>"
actionbook browser wait-idle                    # MANDATORY: wait for network
actionbook browser text                         # Full page text (fallback)
actionbook browser text "<selector>"            # Use Actionbook selector if indexed

If page content seems incomplete, debug:

bash

# Check for JS errors that might block rendering
actionbook browser console --level error

# Check if a specific element exists
actionbook browser wait-fn "document.querySelector('.content')" --timeout 5000

# Inspect element properties
actionbook browser info ".content"

For arXiv papers, try sources in this order:

bash

# 1. arXiv abstract (most reliable) — use fetch
actionbook --block-images browser fetch "https://arxiv.org/abs/<arxiv_id>" --format text --json

# 2. HuggingFace papers page
actionbook --block-images browser fetch "https://huggingface.co/papers/<arxiv_id>" --format text --json

# 3. ar5iv HTML (structured, but fails on new papers) — use --lite for static HTML
actionbook browser fetch "https://ar5iv.org/html/<arxiv_id>" --format text --lite --json
# NOTE: if content too short, ar5iv didn't render. Fall back.

# 4. GitHub repo (from search results) — use fetch
actionbook --block-images browser fetch "<github_repo_url>" --format text --json

For protected sites (Cloudflare, bot detection) — use interactive mode with stealth:

bash

actionbook --stealth --block-images --auto-dismiss-dialogs --rewrite-urls browser open "<protected_url>"
actionbook browser wait-idle
actionbook browser text

For mobile-only content:

bash

actionbook browser emulate iphone-14
actionbook browser open "<url>"
actionbook browser wait-idle
actionbook browser text

For Google Scholar (indexed by Actionbook):

bash

actionbook browser open "https://scholar.google.com"
actionbook browser wait-idle
actionbook browser click "#gs_hdr_tsi"
actionbook browser type "#gs_hdr_tsi" "<query>"
actionbook browser click "#gs_hdr_tsb"
actionbook browser wait-idle
actionbook browser text "#gs_res"

For unindexed sites, use snapshot to discover structure:

bash

actionbook --block-images browser fetch "<url>" --format snapshot --max-tokens 800 --json

Step 6: Synthesize Findings

Organize collected information into a coherent report:

Overview / Executive Summary
Key Findings
Detailed Analysis
Supporting Data / Evidence
Implications / Significance
Sources

Step 7: Generate json-ui JSON Report

Write a JSON file following the @actionbookdev/json-ui schema. Use the Write tool.

Output path: ./output/<topic-slug>.json (or user-specified --output path)

Step 8: Render HTML

CRITICAL: You MUST try ALL fallback methods before giving up. Do NOT stop at the first failure.

IMPORTANT: Always use ABSOLUTE paths for JSON_FILE and HTML_FILE.

Try each method one by one until one succeeds:

bash

# Method 1: Monorepo absolute path (most reliable if inside actionbook project)
node "$(git rev-parse --show-toplevel)/packages/json-ui/dist/cli.js" render /absolute/path/to/report.json -o /absolute/path/to/report.html

# Method 2: Global install (if user ran: cd packages/json-ui && npm link)
json-ui render /absolute/path/to/report.json -o /absolute/path/to/report.html

# Method 3: npx (if published to npm)
npx @actionbookdev/json-ui render /absolute/path/to/report.json -o /absolute/path/to/report.html

NEVER give up silently. If all methods fail, tell the user:

The JSON report is saved at <path>
To enable HTML rendering, run: cd <actionbook-repo>/packages/json-ui && npm link

Step 9: Open in Browser

bash

# macOS
open <report.html>

# Linux
xdg-open <report.html>

Step 10: Close Browser

Always close the browser when done:

bash

actionbook browser close

Error Recovery Patterns

Intelligent error recovery using advanced browser capabilities:

Pattern: Page Load Failure

bash

# 1. Open page
actionbook browser open "<url>"
actionbook browser wait-idle --timeout 15000

# 2. Check for JS errors
actionbook browser console --level error
# If errors found → page is broken, skip to next source

# 3. Check if content rendered
actionbook browser wait-fn "document.body.innerText.length > 100" --timeout 5000
# If timeout → content didn't render, try fallback

Pattern: Selector Not Found

bash

# 1. Use snapshot to discover actual page structure
actionbook browser snapshot --filter interactive --max-tokens 800

# 2. Or inspect a specific area
actionbook browser info "<parent_selector>"
# Returns: suggested selectors, visibility, tag info

# 3. Adjust selector and retry

Pattern: Anti-Bot Detection

bash

# 1. If initial load returns CAPTCHA or access denied:
actionbook browser close

# 2. Reopen with stealth
actionbook --stealth --no-animations --auto-dismiss-dialogs browser open "<url>"
actionbook browser wait-idle

# 3. If still blocked, rotate fingerprint
actionbook browser fingerprint rotate --os windows
actionbook browser open "<url>"
actionbook browser wait-idle

Pattern: SPA Content Not Loading

bash

# 1. Wait for network
actionbook browser wait-idle --idle-time 1000 --timeout 15000

# 2. Wait for specific element
actionbook browser wait-fn "document.querySelector('.results')" --timeout 10000

# 3. If still empty, check console
actionbook browser console --level error

# 4. Try clicking a loading trigger
actionbook browser snapshot --filter interactive --max-tokens 300
# Look for "Load More", "Show Results", etc.

Show full SKILL.md (967 more words)Show less

Full Error Handling Reference

Error	Recovery Strategy
Browser fails to open	`actionbook browser status`, retry + check `console --level error`
Page load timeout	`wait-idle --timeout 15000`, then `console --level error` to diagnose
URL returns 404	`wait-fn "!document.title.includes('404')"` to detect fast. Skip immediately, do NOT retry. Use Google snippet text as backup data.
arXiv form submission fails	Fall back to URL-based search: `arxiv.org/search/?query=...&searchtype=all`
ar5iv content truncated	Fall back to arxiv abstract + `wait-fn "document.body.innerText.length > 5000"` to verify
Selector not found	`snapshot --filter interactive` to discover actual structure
Dynamic content missing	`wait-idle` + `wait-fn` for specific conditions
Alert popup blocking	`--auto-dismiss-dialogs` prevents this entirely
Anti-bot detection	`--stealth` + `fingerprint rotate`
Slow media-heavy page	`--block-images` or `--block-media` for 2-5x speedup
CSS animation interference	`--no-animations` freezes all transitions
json-ui render crash	Check MetricsGrid — `suffix`/`value` must be plain strings
`npx json-ui` 404	Try all 3 methods (monorepo, global, npx)
No search results	Start broad (50+ results), then narrow. Use 4+ query angles.

IMPORTANT: Always run actionbook browser close before finishing, even on errors.

Feature Usage Checklist

Before finalizing research, verify you used these capabilities:

Feature	When to Use	Check
`browser fetch`	Read-only page extraction (preferred over open+wait+text)	Use for most page reads
`--lite`	Static pages (Wikipedia, docs, blogs) — skip browser entirely	Add to `fetch` for static sites
`--rewrite-urls`	Always (avoids anti-bot on x.com, reddit)	Set in initial browser launch
`--wait-hint`	Domain-aware wait tuning (fast/slow/heavy)	Use with `fetch` or manual flow
`--session-tag`	Multi-step operations needing log correlation	Set for debugging sessions
`wait-idle`	After EVERY `open`/`goto`/`click` that triggers navigation	Must be used on every page
`--block-images`	Always (research doesn't need images)	Set in initial browser launch
`--auto-dismiss-dialogs`	Always (prevents blocking)	Set in initial browser launch
`--no-animations`	Always (stable snapshots)	Set in initial browser launch
`wait-fn`	When content loads asynchronously after network settles	Use on SPAs, dynamic pages
`console --level error`	When page content seems incomplete or broken	Use for debugging
`batch`	When filling multi-step forms (arXiv, Google Scholar)	Replaces 5+ sequential commands
`snapshot --filter interactive`	When discovering unknown page structure	Use on unindexed sites
`info <selector>`	When a click/type doesn't work as expected	Debug element visibility
`--stealth`	When site returns CAPTCHA or access denied	Add on retry

Common mistakes to avoid:

Using manual open → wait-idle → text → close when browser fetch does it in one command
Not using --lite for static pages (Wikipedia, docs, blogs) — wastes 5-10s on browser startup
Not using --rewrite-urls — x.com and reddit.com have aggressive anti-bot that blocks scraping
Forgetting wait-idle after navigation in interactive mode (content appears empty)
Not using batch for form interactions (slow, unreliable)
Retrying a dead URL instead of skipping it
Constructing URLs manually from search snippets instead of clicking links
Using only one search query angle (always use 4+ diverse queries)
Not checking for 404 pages before extracting content

json-ui Report Template

IMPORTANT: Always include BrandHeader and BrandFooter.

json

{
  "type": "Report",
  "props": { "theme": "auto" },
  "children": [
    {
      "type": "BrandHeader",
      "props": {
        "badge": "Deep Research Report",
        "poweredBy": "Actionbook"
      }
    },
    {
      "type": "Section",
      "props": { "title": "Overview", "icon": "paper" },
      "children": [
        {
          "type": "Prose",
          "props": {
            "content": "Overview of the topic..."
          }
        }
      ]
    },
    {
      "type": "Section",
      "props": { "title": "Key Findings", "icon": "star" },
      "children": [
        {
          "type": "ContributionList",
          "props": {
            "items": [
              {
                "badge": "Finding",
                "title": "...",
                "description": "..."
              }
            ]
          }
        }
      ]
    },
    {
      "type": "Section",
      "props": { "title": "Detailed Analysis", "icon": "bulb" },
      "children": [
        {
          "type": "Prose",
          "props": { "content": "..." }
        }
      ]
    },
    {
      "type": "Section",
      "props": { "title": "Key Metrics", "icon": "chart" },
      "children": [
        {
          "type": "MetricsGrid",
          "props": { "metrics": [], "cols": 3 }
        }
      ]
    },
    {
      "type": "Section",
      "props": { "title": "Sources", "icon": "link" },
      "children": [
        {
          "type": "LinkGroup",
          "props": { "links": [] }
        }
      ]
    },
    {
      "type": "BrandFooter",
      "props": {
        "timestamp": "YYYY-MM-DDTHH:MM:SSZ",
        "attribution": "Powered by Actionbook",
        "disclaimer": "This report was generated by AI using web sources. Verify critical information independently."
      }
    }
  ]
}

Paper Report Template (for arXiv papers)

When analyzing academic papers, use a richer template with:

PaperHeader (title, arxivId, date, categories)
AuthorList (authors with affiliations)
Abstract (with keyword highlights)
ContributionList (key contributions)
MethodOverview (step-by-step method)
ResultsTable (experimental results)
Formula (key equations, LaTeX)
Figure (paper figures from ar5iv)

Available json-ui Components

Component	Use For	Key Props
`BrandHeader`	Report header	`badge`, `poweredBy`
`PaperHeader`	Paper metadata	`title`, `arxivId`, `date`, `categories`
`AuthorList`	Authors	`authors: [{name, affiliation}]`, `maxVisible`
`Section`	Major section	`title`, `icon` (paper/star/bulb/chart/code/link/info/warning)
`Prose`	Rich text	`content` (supports bold, italic, `code`, lists)
`Abstract`	Abstract text	`text`, `highlights: ["keyword"]`
`ContributionList`	Numbered findings	`items: [{badge, title, description}]`
`MethodOverview`	Step-by-step	`steps: [{step, title, description}]`
`MetricsGrid`	Key stats	`metrics: [{label, value, trend, suffix}]`, `cols`
`ResultsTable`	Data table	`columns`, `rows`, `highlights: [{row, col}]`
`Table`	Generic table	`columns: [{key, label}]`, `rows`, `striped`, `compact`
`Callout`	Info/tip/warning	`type` (info/tip/warning/important/note), `title`, `content`
`Highlight`	Blockquote	`type` (quote/important/warning/code), `text`, `source`
`KeyPoint`	Key finding card	`icon`, `title`, `description`, `variant`
`CodeBlock`	Code snippet	`code`, `language`, `title`, `showLineNumbers`
`Formula`	LaTeX equation	`latex`, `block`, `label`
`Figure`	Image(s)	`images: [{src, alt, width}]`, `label`, `caption`
`Image`	Single image	`src`, `alt`, `caption`, `width`
`DefinitionList`	Term/definition	`items: [{term, definition}]`
`LinkGroup`	Source links	`links: [{href, label, icon}]`
`Grid`	Grid layout	`cols`, children
`Card`	Card container	`padding` (sm/md/lg), `shadow`
`TagList`	Tags	`tags: [{label, color, href}]`
`BrandFooter`	Footer	`timestamp`, `attribution`, `disclaimer`

json-ui Known Pitfalls

Pitfall	Symptom	Fix
`MetricsGrid.suffix` as object	`text.replace is not a function`	`suffix` must be a plain string
`MetricsGrid.value` as number	Render error	`value` must be a string (e.g., `"58.5"` not `58.5`)
Missing `BrandHeader`/`BrandFooter`	Report looks broken	Always include both
`Table` row values as object	`[object Object]` in cells	Row cell values must be plain strings
Very long Prose content	Truncated render	Split into multiple Prose blocks or use subsections

Text Fields

All text fields should use plain English strings.

json

{ "title": "Key Findings" }

Note: MetricsGrid props value and suffix, and Table row cell values must always be plain strings.

Academic Paper Support

arXiv Papers

ar5iv.org HTML (preferred for reading, but often incomplete for papers < 3 months old):

Element	Selector	Reliability	Fallback
Title	`h1.ltx_title_document`	High	`div.ltx_abstract`
Authors	`div.ltx_authors`	High	—
Abstract	`div.ltx_abstract`	High	—
Full article	`article`	Medium	Use when section selectors fail
Sections	`section.ltx_section`	Low on new papers	`article`
Figures	`figure.ltx_figure`	Medium	—
Tables	`table.ltx_tabular`	Medium	—

Recommended approach: Use wait-idle + wait-fn to verify ar5iv content loaded:

bash

actionbook browser open "https://ar5iv.org/html/<arxiv_id>"
actionbook browser wait-idle --timeout 15000
actionbook browser wait-fn "document.body.innerText.length > 5000" --timeout 10000
# If wait-fn times out → content didn't render, fall back to other sources

Recommended Source Priority

Priority	Source	What you get	Reliability
1	`arxiv.org/abs/<id>`	Abstract, metadata, submission history	Very high
2	`huggingface.co/papers/<id>`	Abstract, community, related models	Very high
3	GitHub repo	README, code, model zoo	High
4	HuggingFace model card	Training recipe, benchmarks	High
5	`ar5iv.org/html/<id>`	Full paper HTML	Medium
6	Google Scholar / Semantic Scholar	Citations, related work	Medium

Other Academic Sources

Google Scholar (scholar.google.com) — Actionbook indexed
Semantic Scholar (semanticscholar.org)
Papers With Code (paperswithcode.com)
Conference proceedings sites

Quality Guidelines

Breadth: Research from at least 3-5 diverse sources
Depth: Read full articles, not just snippets
Accuracy: Cross-reference facts across sources
Structure: Use appropriate json-ui components for each content type
Attribution: Always include source links in the report
Freshness: Prefer recent sources when relevance is equal

Files

Just SKILL.md in skills/active-research of actionbook/actionbook.

Open the folder on GitHubat commit 0e31254

Used in 1 other repository

We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in actionbook/actionbook, which our catalogue first saw on October 7, 2026.

aiskillstore/marketplaceskills/actionbook/active-research

Compare with similar skills

Active Research next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Active Research compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
Active Research this skillactionbook/actionbook	1.6k	1 repos	~8.2k	Automated safety check: Pass	Apache-2.0	29 days ago
Jev Socialsocai-io/jev-social	154	2 repos	~1.5k	Automated safety check: Pass	MIT	5 days ago
Deep Researchcoreyhaines31/makerskills	844	—	~1.4k	Automated safety check: Pass	MIT	1 mo ago
Web ResearchJuncai22/spring-ai-agent-learning	123	3 repos	~1.1k	Automated safety check: Pass	Apache-2.0	2 mo ago
Argo Search and Verificationtaxueseek/argo	184	—	~1.2k	Automated safety check: Pass	MIT	yesterday
Exa Searchmajiayu000/claude-skill-registry	666	5 repos	~856	Automated safety check: Pass	MIT	today

Similar skills

Jev Social
socai-io/jev-social
Run browser-grounded, read-only social research through Jev Social when a user wants posts, profiles, comments, video evidence, or a source-linked report from Instagram, TikTok, or LinkedIn and the…
154 GitHub starsUsed in 2 repos~1.5k tokens
Research & ScienceAuto-check passed
Deep Research
coreyhaines31/makerskills
When you want multi-source, multi-step research on a topic — competitor research before a sales call, market research for a new business idea, positioning angles, due diligence on a partnership or…
844 GitHub stars~1.4k tokensUpdated 1 mo ago
Research & ScienceAuto-check passed
Web Research
Juncai22/spring-ai-agent-learning
A skill your agent uses for requests related to web research; it provides a structured approach to conducting comprehensive web research
123 GitHub starsUsed in 3 repos~1.1k tokens
Research & ScienceAuto-check passed
Argo Search and Verification
taxueseek/argo
Unified web search, page fetching and evidence checking across hundreds of sources, with result verification, a research-dossier mode and vertical search engines.
184 GitHub stars~1.2k tokensUpdated yesterday
Research & ScienceAuto-check passed
Exa Search
majiayu000/claude-skill-registry
Neural search via Exa MCP for web, code, and company research.
666 GitHub starsUsed in 5 repos~856 tokens
Research & ScienceAuto-check passed
Interceptor Research
Hacker-Valley-Media/Interceptor
Deep web-research methodology for the interceptor browser surface — investigate a topic the way researchers, intelligence analysts, investigative journalists, private investigators, and OSINT…
514 GitHub stars~3.8k tokensUpdated 4 days ago
Research & ScienceAuto-check passed

Questions about Active Research

What does Active Research do?

Deep research and analysis tool. An agent skill from actionbook/actionbook. Active Research is an agent skill from actionbook/actionbook. Deep research and analysis tool.

When should I use Active Research?

Active Research fits situations like: user asks to research; generate a report on any subject.

How do I install Active Research in Claude Code?

Run `npx skills add actionbook/actionbook --skill active-research -a claude-code`. Or copy the skill folder (skills/active-research in actionbook/actionbook) into .claude/skills/active-research in your project. Claude Code loads it when a task matches its description.

How do I install Active Research in Codex?

Run `npx skills add actionbook/actionbook --skill active-research -a codex`. Or copy the skill folder (skills/active-research in actionbook/actionbook) into .agents/skills/active-research in your project. Codex loads it when a task matches its description.

Can I use Active Research in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add actionbook/actionbook --skill active-research -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/active-research, .gemini/skills/active-research, .github/skills/active-research and .opencode/skills/active-research in your project.

What does Active Research need to run?

Going by SKILL.md and its folder, Active Research needs the command-line tools its instructions call (npx, python, node, git and npm). Our summary lists: Python 3.

Does Active Research access the network?

SKILL.md names 6 domains. In commands or code: arxiv.org, ar5iv.org, google.com, bing.com, huggingface.co and scholar.google.com; the agent is likely to contact these when it follows the instructions. This is read from the text; nothing was executed.

Is Active Research safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Active Research use?

Active Research is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Active Research use?

About 8.2k tokens (SKILL.md is roughly 33k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Active Research?

Skills that share tags, products or a category with Active Research: Jev Social (socai-io/jev-social, 154 stars), Deep Research (coreyhaines31/makerskills, 844 stars), Web Research (Juncai22/spring-ai-agent-learning, 123 stars) and Argo Search and Verification (taxueseek/argo, 184 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Active Research?

actionbook (a GitHub organization) maintains it in actionbook/actionbook, which has 1,609 GitHub stars. The repository holds 13 skills in this directory. The repository was last updated on September 8, 2026.

Source: actionbook/actionbook on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install Active Research

Facts

At a glance

What it does

When your agent uses it

Example prompts

Requirements

Workflow steps

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

Active Research

Enhanced Browser Capabilities

Usage

Parameters

Topic Detection

Architecture

MUST USE Actionbook CLI

Browser Flags — Research Defaults

Navigation Pattern — ALWAYS Follow

Complete Workflow

Step 1: Plan Search Strategy

Step 2: Query Actionbook API for Selectors (ALWAYS DO THIS FIRST)

Step 3: arXiv Search (URL-First, Form as Backup)

Step 4: Supplement with Google / Bing Search

Step 5: Deep Read Sources

Step 6: Synthesize Findings

Step 7: Generate json-ui JSON Report

Step 8: Render HTML

Step 9: Open in Browser

Step 10: Close Browser

Error Recovery Patterns

Pattern: Page Load Failure

Pattern: Selector Not Found

Pattern: Anti-Bot Detection

Pattern: SPA Content Not Loading

Full Error Handling Reference

Feature Usage Checklist

json-ui Report Template

Paper Report Template (for arXiv papers)

Available json-ui Components

json-ui Known Pitfalls

Text Fields

Academic Paper Support

arXiv Papers

Recommended Source Priority

Other Academic Sources

Quality Guidelines

Files

Used in 1 other repository

Compare with similar skills

Similar skills

More from actionbook/actionbook

Related

Questions about Active Research