Skip to main content
First time here? Complete the Setup guide first. For the field grammar behind every file shown here, see Skill Format; for how an agent discovers and composes skills, see Agent Skills.
A skill is a folder with a SKILL.md in it: some YAML frontmatter and a Markdown procedure. That’s the whole format. It is not code, not an agent, and not a plugin — it is a written-down way of doing something, in a shape an agent can load. The point of shipping a pack of them is not that GAIA does exactly these things. It is that you can describe a new one in an afternoon. Each skill below is a worked example of a different platform primitive, and each is meant to be copied and edited rather than used verbatim. The pack lives in the hub’s skills lane, hub/skills/ — one directory per skill, alongside hub/agents/ and hub/components/. GAIA already includes them. The gaia agent ships with all of these skills built in, plus document-extract, gaia-voice and gaia-harness-engineering, so there is nothing to install to use them. The built-in copy wins over one in ~/.gaia/skills/. The rest of this page is for reading them, forking them, and installing skills the hub offers that GAIA does not ship.

Find and install skills from the hub

Skills are published to the GAIA hub, signed by AMD. Browse them at amd-gaia.ai/hub, or from the terminal:
Installing is for other agents and for skills GAIA does not ship, such as ones contributed by outside developers. It adds nothing for the gaia agent itself when the skill is one it already includes. install needs GAIA v0.25.4 or later, which trusts AMD’s signing key out of the box. It prints the provenance (signed by AMD) and the tier it installed at; no flags are needed for these skills. To update, run gaia skill install <name> --force, which replaces the installed copy with the newest version (<name>@<range> pins one). To remove one, run gaia skill remove <name>. You can also ask the GAIA agent in chat: “find a skill that does X and install it”. It searches the hub (search_skill_hub) and installs (install_skill), but an installed skill is not active until it is loaded (load_skill), which the agent does when you ask it to use the skill. The agent will not install a skill that is unsigned or asks for a dangerous permission; it tells you, and you can approve it yourself in a terminal with gaia skill install <name> --allow-experimental or --yes. Writing your own? See Build and Publish a Skill.

From a checkout or a local folder

gaia skill import <folder> copies a skill folder, such as one in a GAIA checkout, into ~/.gaia/skills/:
import audits the folder and stamps it security_tier: experimental: imported skills always re-earn trust, whatever tier the file claims, because the tier records what you have verified, not what the author asserted. It follows that a skill asking for more than experimental allows (coding and github-triage want shell:execute:<binary>) is refused at import, and a skill that ships tools.py needs --allow-experimental.

Use one

In chat, ask the agent to use a skill by name. From code, load it with load_skill:
load_skill resolves the name across the discovery roots, validates the manifest, registers any tools the skill provides under <skill-name>/<tool>, bridges its permissions to connector requirements, and injects the procedure into the system prompt. unload_skill(name) reverses all of it. On most agents a loaded body then renders in the prompt on every turn. The flagship gaia agent is the exception: it selects per turn which loaded bodies are relevant, and collapses the rest to a one-line menu entry — see the skill spec for the mechanics. GaiaAgent is the agent to target for this pack: its default config turns on the web, RAG, scratchpad, memory, file, and shell tools these skills consume. A skill loaded into a narrower agent, or into a ChatAgent with enable_browser and enable_scratchpad left at their default of off, still loads, but any tool it names that the agent lacks is logged as unavailable.

The skills

research-report

Decomposes a topic into sub-questions, searches each, reads the best sources, and writes a Markdown report with inline citations and an explicit “what I could not confirm” section.
  • Demonstrates — multi-step planning, web search + fetch, optional RAG over what it fetched.
  • Consumes — search_web, fetch_page, write_file, index_document, query_documents.
  • Configure — nothing. Ask it for a report on anything.
  • Note — search_web is DuckDuckGo-backed; coverage is uneven and it is rate-limited.

document-brief

Indexes a file or folder and answers questions from it, quoting the sentence that proves each claim rather than paraphrasing from the filename. A handful of documents to review or compare is read in full with read_file instead.
  • Demonstrates — the RAG loop end to end: index, query, summarize, status.
  • Consumes — index_document, index_directory, list_indexed_documents, query_documents, summarize_document, rag_status, read_file.
  • Configure — a file or directory path.

data-explore

Loads messy tabular data into SQL scratchpad tables and answers with real queries. Written around the observation that an LLM reading numbers off a table gets them subtly wrong, while an LLM writing SQL against them does not.
  • Demonstrates — scratchpad tables for structured analysis.
  • Consumes — create_table, insert_data, query_data, list_tables.
  • Configure — a CSV, export, or pasted table.

source-watch

The generic watcher, and the template the next two are forked from: fetch a source, extract items, apply a match, suppress anything already reported via memory, and speak up only when there is news.
  • Demonstrates — the watcher shape; memory used for de-duplication.
  • Consumes — fetch_page, recall, remember.
  • Configure — a source URL, a match condition, and a memory key.
  • Limit — runs when you invoke it. GAIA’s scheduler runs recurring prompts but cannot yet run a skill on a cron; gaia schedule add --skill is rejected at creation time.

price-watch

source-watch specialized to products: extract the current price, compare to the lowest ever recorded in memory, alert only on a new low.
  • Demonstrates — forking a template; memory holding a running extreme rather than a seen-list; the traps in extracting one number from a retail page.
  • Consumes — fetch_page, recall, remember.
  • Configure — product URLs, one memory key each, an optional price floor.

recommendations

Recalls what the user has liked and bounced off, searches for what is actually available now, ranks by predicted fit, and records the reaction so the next run is better.
  • Demonstrates — memory as personalization; the write-back step that makes a skill improve with use.
  • Consumes — recall, search_web, fetch_page, remember.
  • Configure — a category. It asks two questions if memory is empty.

check-in

The smallest complete memory loop in the pack: recall open commitments, ask about them specifically, write back what changed.
  • Demonstrates — recall → converse → update_memory / remember.
  • Consumes — recall, search_past_conversations, remember, update_memory.
  • Limit — you start it. A genuinely proactive daily check-in needs skill-aware scheduling, which is not wired yet.

daily-brief

Gathers several independent sources, tolerates any one of them failing, cuts hard, and produces one digest under 250 words.
  • Demonstrates — composition across sources and graceful partial failure.
  • Consumes — search_web, fetch_page, recall.
  • Configure — the sections you want and the topics or URLs behind each.
  • Limit — you ask for it; it is not delivered. See what’s deferred.

github-triage

The bring-your-own-CLI example. Reads a backlog with the gh command, groups duplicates, ranks by severity × reach, and posts the reply once you approve it.
  • Demonstrates — a scoped binary grant. It declares shell:execute:gh, which grants the GitHub CLI to this skill’s session on this agent, restricted to the subcommands in GAIA’s policy table (see the permission model).
  • Configure — nothing, if you let GAIA do it. Ask it to set up the GitHub CLI and it checks, installs, and signs in for you, showing you each command first — see Setting up a CLI a skill needs. gh still owns its own auth; GAIA never sees the token. To do it by hand instead, gh auth login then gh auth status works exactly as before. If gh is not on PATH the skill refuses to load rather than answering from no data — and the refusal now offers the setup rather than ending there. Reads run without a per-call approval prompt — loading the skill is the consent. The useful writes (gh issue create|comment|edit, gh pr comment, gh label create|edit) show you the exact command and wait for a yes, a no, or an “always” scoped to that one command class for the session. Commands the grant doesn’t cover — gh auth token prints a credential, gh alias/gh extension run arbitrary code, gh api -X POST is an unbounded write — are never pre-approved: each shows its exact text and a risk line and runs only on a one-time yes, with no “always”. Deletes (gh repo delete, gh api -X DELETE) are refused outright.

rss-digest

The pack’s one tool-providing skill: it ships a tools.py with a fetch_rss function, declared in metadata.gaia.tools and registered as rss-digest/fetch_rss.
  • Demonstrates — a skill contributing its own @tool. The loader compares the manifest to the function signature and refuses the skill if they disagree, so a stale manifest cannot ship.
  • Configure — a feed URL. Handles both RSS 2.0 and Atom.
  • Note — it fetches through GAIA’s WebClient, so private and loopback addresses are refused.

image-gen

Turns “draw me a red bicycle” into a prompt worth generating, runs it through a downloaded Lemonade image model (Stable Diffusion or TheNoise), and iterates on the previous image instead of starting over. Written around the fact that generation is slow enough that you only get a couple of attempts.
  • Demonstrates — a local non-text model in a skill, and iterating from session history rather than regenerating from scratch.
  • Consumes — generate_image, list_sd_models, get_generation_history.
  • Configure — a house style clause, if you always want the same look.
  • Note — these tools are only registered on the flagship gaia agent, which turns enable_sd_tools on. Generating evicts the chat model to make room for the SD model, so the next reply reloads it; ChatAgent keeps the flag off.

coding

Changes code the way you would check it yourself: find the right file, edit it, and prove the change works before reporting it.
  • Demonstrates — grep and semantic code search together, scoped shell grants for tests and git.
  • Consumes — read_file, edit_file, search_file_content, search_code_index, run_python, run_shell_command.
  • Configure — nothing. It declares shell:execute:pytest, python, python3 and git.

file-ops

Reads, writes and edits files on disk without guessing paths, and asks before anything hard to undo.
  • Demonstrates — read-before-write discipline and confirmation before destructive changes.
  • Consumes — read_file, write_file, edit_file, find_files, search_file_content, get_file_info, request_user_input.
  • Configure — nothing.

inbox-triage

Turns a mailbox into a short list of what needs you, with a one-line reason for each. Read-only: it never replies, archives or deletes.
  • Demonstrates — a skill over the email tools, where the model judges and the tools only report facts.
  • Consumes — check_mailbox_access, list_inbox, search_email, read_email, list_mail_folders, get_thread, list_connected_mailboxes, list_waiting_on_you.
  • Configure — a connected Gmail or Outlook mailbox; see the Email guide.

music-gen

Generates original music and sound effects as WAV files with local Lemonade models.
  • Demonstrates — a local audio model in a skill, used only when you ask.
  • Consumes — list_audio_generation_models, generate_music, generate_sound_effect.
  • Note — generating can load a multi-GB model and evict the chat model, so the next reply reloads it.

summarize

Picks a summary style that fits what the content is (transcript, email, or document) and folds long input forward in sections instead of dropping the back half.
  • Demonstrates — style selection and chunked summarizing of long input.
  • Consumes — index_document, summarize_document, list_indexed_documents, dump_document, read_file.
  • Configure — a file path or pasted text.

transcribe-meeting

Turns a meeting recording into a speaker-labelled transcript and a brief with decisions and action items. Takes roughly 4x realtime on a 46-minute recording.
  • Demonstrates — a three-step pipeline where each tool writes a file the next one reads, so a long transcript is never truncated.
  • Consumes — transcribe_media, refine_transcript, summarize_document, query_documents, remember.
  • Configure — an audio or video file, or a Teams/Zoom transcript export.

Fork one

This is the part that matters. Copying a skill and editing it is the whole workflow:
Then, in gpu-restock-watch/SKILL.md:
  1. Change name: source-watch to name: gpu-restock-watch. Keep the name field equal to the directory name: gaia skill import installs under the name in the file even when the folder is called something else, with no error, so a stale name installs under the original’s name.
  2. Rewrite description. It is not documentation; it is the trigger signal a model reads to decide whether this skill is relevant. Say what it does and when to use it.
  3. Edit the procedure. Numbered, concrete steps beat prose.
  4. Bump version and drop the provenance block if it is no longer ours.

Rules worth knowing before you edit

  • Permissions are declarations, and v1 only honors some of them. network:* and mcp:connect:<connector-id> bridge to the connector model and work today, and so does shell:execute:<binary> — that is the grant github-triage uses. Everything else local — filesystem, database, desktop, env, and a bare unscoped shell:execute — needs a sandbox that has not shipped, so a skill declaring one is refused at load rather than loaded unenforced. Do not add a permission to look thorough — add it only if the skill needs it.
  • tools and tools_required are different fields. tools are @tool functions your skill provides (and must exist in its tools.py). tools_required names registry tools it consumes. Only rss-digest uses the former.
  • pairs_with names skills this one is usually combined with, so the catalogue tells the model to load both. A name that is not installed is ignored, and no starter skill uses it today. See Companion skills.
  • Never put a secret in a skill file. Reference it as a requirements.env_vars entry and configure it through gaia connectors configure.

Reference files and scripts

A skill doesn’t have to fit in one file. Put long material — a query syntax, a style guide, a table of codes, a helper script — in files beside SKILL.md, and have the instructions point at them. The agent reads a file only when the instructions send it there, so a skill can carry pages of reference without filling the agent’s context every time it is used.
In SKILL.md, name the file by its path from the skill folder, and say when to read it:
  • Folder names are up to you. references/ and scripts/ are the Agent Skills standard’s conventions, and Claude Code skills use them, but GAIA reads reference/, docs/, or anything else the same way.
  • What loads when. Using a skill adds only its SKILL.md instructions to the conversation. When those instructions point at a file, the agent opens it with its file tools, and the load_skill result tells the model which folder the paths are relative to.
  • The agent can read the skill’s folder, not write it. A loaded skill’s folder is readable even when your session’s allowed folders don’t include it — that is what lets a skill installed in ~/.gaia/skills use its reference files in the Agent UI. Writes there are still refused, and so is any path that climbs out of the folder with ...
  • gaia skill import copies the whole folder, so reference files and scripts travel with the skill.
To read a skill’s reference files from your own Python code, see Skills SDK → Reference files and scripts.

What is not in the pack yet

Several skills in the original proposal (#893) describe things GAIA cannot do yet. Rather than ship manifests that parse but cannot run, they are left out, with the specific blocker named: Scheduling is the single largest unblock: with gaia schedule add --skill wired to the skills runtime, source-watch, price-watch, check-in, and daily-brief all become the background jobs they were designed to be.

Attribution

  • Nous Research — the curated-starter-pack model is theirs. Hermes Agent ships roughly 118 starter skills, and it is the existence proof that a pack of forkable examples is the right shape for a consumer agent platform. This pack is a deliberately small, fully-verified subset of that idea.
  • agentskills.io — the SKILL.md format these files are written in. GAIA adopts the standard’s base (name, description, license, metadata) unchanged and adds a top-level version plus its own metadata.gaia namespace, so every skill here remains a valid standard skill that a non-GAIA runtime can read.