home / skills / openclaw / skills / deep-research-gemini

deep-research-gemini skill

/skills/zhengxinjipai/deep-research-gemini

This skill conducts autonomous multi-step research using Gemini Deep Research to deliver detailed, cited market, tech, and due-diligence reports.

npx playbooks add skill openclaw/skills --skill deep-research-gemini

Review the files below or copy the command above to add this skill to your agents.

Files (3)
SKILL.md
2.9 KB
---
name: deep-research
description: "Execute autonomous multi-step research using Google Gemini Deep Research Agent. Use for: market analysis, competitive landscaping, literature reviews, technical research, due diligence. Takes 2-10 ..."
risk: safe
source: "https://github.com/sanjay3290/ai-skills/tree/main/skills/deep-research"
date_added: "2026-02-27"
---

# Gemini Deep Research Skill

Run autonomous research tasks that plan, search, read, and synthesize information into comprehensive reports.

## When to Use This Skill

Use this skill when:
- Performing market analysis
- Conducting competitive landscaping
- Creating literature reviews
- Doing technical research
- Performing due diligence
- Need detailed, cited research reports

## Requirements

- Python 3.8+
- httpx: `pip install -r requirements.txt`
- GEMINI_API_KEY environment variable

## Setup

1. Get a Gemini API key from [Google AI Studio](https://aistudio.google.com/)
2. Set the environment variable:
   ```bash
   export GEMINI_API_KEY=your-api-key-here
   ```
   Or create a `.env` file in the skill directory.

## Usage

### Start a research task
```bash
python3 scripts/research.py --query "Research the history of Kubernetes"
```

### With structured output format
```bash
python3 scripts/research.py --query "Compare Python web frameworks" \
  --format "1. Executive Summary\n2. Comparison Table\n3. Recommendations"
```

### Stream progress in real-time
```bash
python3 scripts/research.py --query "Analyze EV battery market" --stream
```

### Start without waiting
```bash
python3 scripts/research.py --query "Research topic" --no-wait
```

### Check status of running research
```bash
python3 scripts/research.py --status <interaction_id>
```

### Wait for completion
```bash
python3 scripts/research.py --wait <interaction_id>
```

### Continue from previous research
```bash
python3 scripts/research.py --query "Elaborate on point 2" --continue <interaction_id>
```

### List recent research
```bash
python3 scripts/research.py --list
```

## Output Formats

- **Default**: Human-readable markdown report
- **JSON** (`--json`): Structured data for programmatic use
- **Raw** (`--raw`): Unprocessed API response

## Cost & Time

| Metric | Value |
|--------|-------|
| Time | 2-10 minutes per task |
| Cost | $2-5 per task (varies by complexity) |
| Token usage | ~250k-900k input, ~60k-80k output |

## Best Use Cases

- Market analysis and competitive landscaping
- Technical literature reviews
- Due diligence research
- Historical research and timelines
- Comparative analysis (frameworks, products, technologies)

## Workflow

1. User requests research → Run `--query "..."`
2. Inform user of estimated time (2-10 minutes)
3. Monitor with `--stream` or poll with `--status`
4. Return formatted results
5. Use `--continue` for follow-up questions

## Exit Codes

- **0**: Success
- **1**: Error (API error, config issue, timeout)
- **130**: Cancelled by user (Ctrl+C)

Overview

This skill runs autonomous multi-step research using the Google Gemini Deep Research Agent to plan, search, read, and synthesize information into comprehensive, cited reports. It is optimized for market analysis, competitive landscaping, literature reviews, technical research, and due diligence. Tasks usually complete in 2–10 minutes and can output human-readable reports, structured JSON, or raw API responses.

How this skill works

You start a research task with a query and the agent autonomously builds a plan, fetches and reads sources, extracts key findings, and synthesizes them into a structured report. Progress can be streamed in real time, polled for status, or continued from a previous run to refine or expand results. Outputs include formatted markdown reports, JSON for programmatic use, or raw API responses for debugging.

When to use it

  • Market sizing, trends, and opportunity discovery
  • Competitive landscape and feature comparison
  • Academic or technical literature reviews
  • Due diligence for investments or partnerships
  • Comparative analyses of products, frameworks, or technologies

Best practices

  • Provide a clear, scoped query and desired deliverables (e.g., executive summary, tables, recommendations).
  • Specify an output format when you need machine-readable results (use --json for structured data).
  • Use --stream to monitor progress for long-running tasks and --wait or --status to retrieve results reliably.
  • Start with a concise seed query and use --continue to iterate, refine scope, or request deeper analysis.
  • Monitor estimated time and cost—tasks typically take 2–10 minutes and cost varies with complexity.

Example use cases

  • Run a market analysis report on EV battery suppliers with a competitor matrix and recommendations.
  • Produce a literature review summarizing recent papers on a machine learning algorithm with citations and gaps.
  • Perform due diligence on a startup’s technology landscape and highlight risks and opportunities.
  • Compare Python web frameworks with a comparison table, performance notes, and suggested choices for specific project types.

FAQ

What prerequisites are required to run this skill?

Python 3.8+ and the required HTTP client libraries. An active Gemini API key must be available via the GEMINI_API_KEY environment variable or a local .env file.

How long does a typical research task take and what does it cost?

Most tasks finish in about 2–10 minutes. Cost varies by complexity but typically ranges from $2–$5 per task; token usage depends on task size and depth.