Skip to content

DANG-ai/SKILLER / gaia/skills/manus

gaia-general-skill

Verified

Global static GAIA skill for web, file, multimodal, calculation, evidence, and final-answer discipline.

FileKindSize
SKILL.mdskill md10.7 KB
---
name: gaia-general-skill
description: Global static GAIA skill for web, file, multimodal, calculation, evidence, and final-answer discipline.
allowed-tools:
  - list_dir
  - read_file
  - read_json_file
  - extract_pdf_text
  - read_table
  - image_metadata
  - audio_transcribe
  - ocr_image
  - image_qa
  - parse_docx
  - parse_pptx
  - extract_archive
  - web_search
  - fetch_url
  - html_extract
  - run_python
metadata:
  benchmark: GAIA
  generator: Manus
  baseline: manus_plain_skill
  generation_constraints: gaia_original_annotation_gold_no_instance_memory_v4
  allowed_gold_input: train83_original_annotation_gold
  skill_injection_mode: global_static
  runtime_state_transitions: disabled
  date: "2026-05-20"
---

# GAIA General Skill

## Global Operating Loop

For every GAIA task, follow this loop until a final answer is produced:

1. **Parse the question** — extract the answer contract (format, unit, precision, constraints).
2. **Triage inputs** — check for attached files; if present, inspect them first.
3. **Plan evidence path** — decide whether the answer requires web research, file analysis, multimodal processing, calculation, or a combination.
4. **Execute evidence gathering** — use the minimum tool calls needed; record each intermediate finding.
5. **Validate evidence** — cross-check with a second source or method when feasible.
6. **Compute final answer** — apply any required arithmetic, filtering, or formatting.
7. **Normalize output** — strip trailing punctuation, units unless requested, and whitespace; match the exact format the question demands.
8. **Emit final answer** — return only the concise answer string.

If any step fails or yields ambiguous results, invoke the Recovery section before answering.

## Answer Contract Extraction

Before any research or computation, identify:

- **Expected type**: number, name, date, list, yes/no, short phrase.
- **Precision**: "round up to next integer", "two decimal places", "exact title as it appears".
- **Constraints**: "use Wikipedia 2022 version", "between years X and Y", "only articles not reviews".
- **Format markers**: "return it as appearing in the spreadsheet", "give the shortest name".

Write the contract mentally before proceeding. Every subsequent step must serve the contract.

## Source and Evidence Discipline

- Prefer authoritative primary sources: official archives, Wikipedia, government databases, institutional pages.
- When a question specifies a source (e.g., "use English Wikipedia"), restrict evidence to that source.
- When multiple sources conflict, prefer the source closest to the question's specification.
- Never fabricate a URL, title, or numeric value. If a source cannot be found, try alternative search terms before concluding.
- Record the provenance of every factual claim: which URL or file produced it.

## Web Search and Stale-Source Handling

### Search Strategy

```
web_search(query="<targeted keywords from question>")
```

- Start with the most specific query derived from the question.
- If zero relevant results, broaden by removing qualifiers one at a time.
- If the question references a specific website or database, include the site name in the query.

### Navigating Results

```
fetch_url(url="<result_url>")
html_extract(url="<result_url>", selector="<css_selector>")
```

- Open the most promising result first.
- If a page is paywalled, archived, or returns 404, try the Wayback Machine or an alternative mirror.
- For Wikipedia, navigate directly to the relevant section using anchors or table of contents.

### Stale or Missing Data

- If a page has been updated since the question's reference date, look for archived versions.
- If a count or list is needed, verify by checking the archive/filter interface of the target site rather than trusting a single search snippet.

## Local File Triage

When the task includes an attached file:

1. **Identify format** — use `list_dir` to see the filename and extension.
2. **Route by type**:
   - `.xlsx`, `.csv`, `.tsv` → `read_table`
   - `.pdf` → `extract_pdf_text`
   - `.docx` → `parse_docx`
   - `.pptx` → `parse_pptx`
   - `.json`, `.jsonl` → `read_json_file`
   - `.zip`, `.tar`, `.gz`, `.7z` → `extract_archive`, then re-triage contents
   - `.png`, `.jpg`, `.jpeg`, `.gif`, `.bmp`, `.tiff` → `ocr_image` or `image_qa`
   - `.mp3`, `.wav`, `.m4a`, `.ogg`, `.flac` → `audio_transcribe`
   - Other text → `read_file`
3. **Inspect before computing** — always read or preview the file content before applying calculations.
4. **Handle multi-sheet spreadsheets** — check all sheet names; the relevant data may not be on the first sheet.

## Multimodal Handling

### Images

```
ocr_image(path="<file_path>")
image_qa(path="<file_path>", question="<specific_question>")
image_metadata(path="<file_path>")
```

- Use `ocr_image` when the answer is text visible in the image.
- Use `image_qa` when the answer requires visual understanding (colors, objects, spatial relations).
- Use `image_metadata` to check EXIF data, dimensions, or embedded metadata.
- If OCR returns garbled text, try `image_qa` with a targeted question instead.

### Audio

```
audio_transcribe(path="<file_path>")
```

- Transcribe first, then search the transcript for the answer.
- If the question asks about a specific segment, note timestamps if available.
- For non-English audio, the transcription tool may still produce usable output; verify key terms.

## Python Calculation and Validation

```
run_python(code="<python_code>")
```

### When to Use Python

- Any arithmetic beyond trivial single-step operations.
- Percentage calculations, rounding, counting, filtering, sorting.
- Date arithmetic (days between dates, day of week).
- String manipulation (extracting substrings, regex matching).
- Statistical computations (mean, median, percentages of populations).

### Calculation Discipline

- Always use Python for multi-step math; never compute mentally.
- Print intermediate results to verify each step.
- When rounding, use the exact method specified: `math.ceil`, `math.floor`, `round`.
- For currency or unit conversions, state the conversion factor and its source.
- Double-check by reversing the calculation or using an alternative method.

### Common Patterns

```python
import math
# Percentage then round up
result = math.ceil(total * percentage / 100)

# Count items matching criteria
count = len([x for x in items if condition(x)])

# Filter by date range
filtered = [r for r in records if start_year <= r['year'] <= end_year]
```

## Multi-Hop Research

Many GAIA tasks require chaining multiple lookups:

1. **Identify the chain** — the question often contains nested references ("the species whose shell is object X in museum Y").
2. **Resolve one hop at a time** — find the intermediate entity before searching for the final answer.
3. **Verify synonyms and redirects** — scientific names may have accepted vs. deprecated forms; check taxonomy databases.
4. **Track the chain** — maintain a mental list: Hop 1 → Entity A, Hop 2 → Entity B, Final → Answer.
5. **Cross-validate** — if possible, find a source that connects the full chain to confirm.

### Handling Name Variations

- For species: check World Register of Marine Species, ITIS, or Wikipedia for accepted names.
- For people: check birth names, stage names, married names.
- For places: check historical names, transliterations, abbreviations.
- For organizations: check acronyms, former names, parent organizations.

## Evidence Bookkeeping

Within the current task only, maintain a running evidence log:

- After each tool call that produces useful information, note: `[Evidence] <source>: <finding>`.
- Before computing the final answer, review all evidence entries for consistency.
- If evidence conflicts, investigate further before answering.
- Do not carry evidence across tasks.

## Final Answer Normalization

Apply these rules to the final answer:

1. **Numbers**: remove leading zeros; use the requested precision; omit units unless explicitly requested.
2. **Names/Titles**: preserve exact capitalization and punctuation as found in the authoritative source; do not add quotes unless the question asks for them.
3. **Lists**: use comma separation unless another format is specified; maintain the requested order.
4. **Yes/No**: use the exact word requested (yes/no, Yes/No, true/false).
5. **Dates**: use the format specified; if unspecified, use the format found in the source.
6. **Rounding**: apply the exact rounding method specified (round up = ceil, round down = floor, round = nearest).

### Common Normalization Pitfalls

- "Round up to the next integer" means `math.ceil`, not `round`.
- "As appearing in the spreadsheet" means copy the exact string including any typos or unusual formatting.
- "The shortest name" means choose the briefest valid name for the character/entity.
- Trailing periods, commas, or spaces must be stripped unless they are part of the answer.

## Recovery When the First Path Fails

If the primary approach does not yield a clear answer:

1. **Reformulate search queries** — use synonyms, alternative phrasings, or the entity's full official name.
2. **Try alternative sources** — if one database is down, try another (e.g., Google Scholar instead of direct journal access).
3. **Decompose the problem** — break a complex question into smaller verifiable sub-questions.
4. **Check assumptions** — re-read the question for constraints you may have missed.
5. **Use Python for brute-force** — if a small search space exists, enumerate possibilities programmatically.
6. **Fallback to broader search** — remove date/source constraints temporarily to find any relevant information, then verify it matches the original constraints.
7. **Verify partial answers** — if you have a partial answer, check whether it satisfies all constraints before submitting.

### When to Stop Searching

- If three different search strategies yield no results, consider whether the question has a trick or requires a different interpretation.
- If you have strong evidence for an answer but cannot find a second source, proceed with the best-supported answer.
- Never guess without evidence. If truly stuck, state the most evidence-supported answer.

## Tool-Use Quick Reference

| Scenario | Primary Tool | Fallback |
|----------|-------------|----------|
| Find a fact online | `web_search` → `fetch_url` | `html_extract` with selector |
| Read spreadsheet | `read_table` | `run_python` with openpyxl/pandas |
| Read PDF | `extract_pdf_text` | `run_python` with PyPDF2 |
| Identify image content | `image_qa` | `ocr_image` |
| Transcribe audio | `audio_transcribe` | — |
| Extract from archive | `extract_archive` → re-triage | — |
| Compute/validate | `run_python` | — |
| Parse structured data | `read_json_file` | `read_file` + `run_python` |
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall