Gaia skills: Verifying 235 AI capabilities via code

Gaia's registry verifies 235 total skills through code-execution runs rather than marketing claims. You will learn how skill fusion mechanics combine basic primitives into ultimate capabilities, why trust ledger validation is required for permanent attribution, and how to deploy the Gaia CLI to scan and publish your own verified assets.

Current market noise often relies on unverified assertions found in repositories like the "awesome-agent-skills" collection by VoltAgent, which aggregates over 1,000 entries without rigorous proof. In contrast, the Gaia project enforces a strict hierarchy where Basic capabilities fuse into Extra workflows and eventually Ultimate platform capstones. This structure ensures that every claimed ability maps to a specific, auditable commit history rather than a vague promise.

The system uses a tiered ranking from 0★ to 6★ to categorize agent maturity objectively. By examining the Gaia Skill Tree, developers can see exactly how component skills evolve into complex workflow skills through transparent validation. 0 licensed system.

The Role of Evidence-Backed Skill Graphs in Verifying AI Capabilities

Gaia Skill Tree Architecture and the G7 Trust Taxonomy

Mutable assertions die hard in our industry, but the Gaia skill tree forces a different standard: an open-source registry confirming AI capabilities through a public ledger of code-execution runs. Here, executable proof replaces hope, guaranteeing skills stay attributed to their provers permanently. The system bundles reusable capabilities as plain Markdown files, demanding a `SKILL.md` manifest for metadata and instructions. Trust derivation depends on the G7 Trust Taxonomy RFC, which outlines 10 canonical evidence types such as `arxiv`, `repo-own`, and `benchmark-result`. These inputs produce a Trust Magnitude score, grading each skill from S to ungraded based on verification depth. The public trust ledger ranks every named skill by this computed magnitude, establishing a transparent hierarchy of reliability. High barriers emerge when specific evidence types like `verifier-attestation` are mandatory, slowing down emerging skills without established provenance. Operators balance the security of high-magnitude skills against the innovation speed of ungraded contributions. This tension forces a choice between immediate utility and long-term auditability in agent deployments.

Operationalizing Trust Magnitude in the Public Trust Ledger

Subjective claims vanish in the Public Trust Ledger, replaced by a trust magnitude derived from the G7 Trust Taxonomy RFC. Every named skill gets ranked by computed magnitude using graded evidence inputs. Evidence types span from `repo-own` to `benchmark-result`, each mapped to a specific grade: S, A, B, C, or ungraded. When contributor @balukosuri submitted proof for community reproduction of Karpathy's autoresearch, the ledger ingested the artifact and assigned a corresponding tier. Contributor @kriptoburak demonstrated this grading by evaluating x-twitter-automation skills, where partial evidence resulted in a lower B classification rather than an automatic rejection. The VoltAgent system illustrates the scale of this curation, hosting over 1,000 compatible skills that rely on similar validation logic. Manual curation for higher tiers creates a bottleneck though; as the registry grows, the latency between submission and S tier assignment may increase without automated verifiers. A C grade indicates presence, not reliability, requiring downstream systems to filter skills based on minimum trust thresholds for production workloads. This distinction prevents unverified code from propagating through the agent skills supply chain.

Validating AI Skills Against G7 Canonical Evidence Types

Mapping components to the 10 canonical evidence types set by the G7 Trust Taxonomy RFC validates an AI skill. The SkillsBench research initiative structurally defines a skill as a package containing instructions, code templates, resources, and verification logic. Rigorous agent capabilities differ from simple prompts lacking executable verification. Submissions must include all four components to achieve a Trust Magnitude grade above ungraded status. Basic skills typically rely on single-source attestation, whereas extra skills demonstrate composite workflow validation through fusion recipes. The registry currently hosts 235 total skills, each attributed permanently to the prover. Omitting resource definitions creates a critical limitation; without external data pointers, the verification logic cannot execute independently, rendering the evidence invalid. Consequently, the Public Trust Ledger rejects incomplete packages regardless of the claimed capability. Builders should consult the Gaia skill tree to verify their package structure before submission. Strict adherence prevents the degradation of the graph into a collection of unverified claims.

Inside the Mechanics of Skill Fusion and Trust Ledger Validation

Gaia Skill Fusion Tiers and Star Ranking Logic

The Gaia Skill Tree enforces a strict hierarchy where Basic capabilities fuse into Extra composites, which subsequently merge into Ultimate capstones. This structural graph prevents unverified claims by requiring every node to pass through a set fusion recipe.

Operators generate skill badges by executing a local scan that validates code against the gaia-skill-tree registry standards. The system computes a Trust Magnitude for each entry, ranking it from S to ungraded based on proven evidence types like benchmark results or verifier attestations. Unlike simple instruction lists, a valid skill package must structurally include verification logic to confirm performance at inference time.

However, the requirement for explicit verification logic creates a friction point for rapid prototyping, as community-curated collections often lack the rigorous testing needed for higher trust tiers. This constraint means that while Basic skills may propagate quickly, ascending to the Unique or Ultimate tiers demands significant engineering overhead to satisfy the verification logic mandates. Consequently, the registry favors stable, well-documented workflows over experimental prompts, ensuring that high-star skills represent reproducible engineering assets rather than transient configurations. Builders should treat the star rating as a signal of maintenance burden; a 5★ skill implies a verified, stable dependency, whereas a 1★ skill requires local validation before production use.

Executing Fusion Recipes for Composite Workflows

Developers execute fusion-recipe evidence types to bind primitive capabilities into validated composite workflows. This mechanism requires explicit definition rather than implicit assumption, ensuring that an Extra tier skill functions only when its constituent Basic inputs satisfy strict dependency constraints. High-volume curators like @ruvnet demonstrate this utility by fusing distinct modules such as `agentdb` and `flow-nexus` into 48 coordinated skills, while @garrytan applies similar logic across 47 `gstack` system entries. These examples illustrate how operators convert isolated functions into reliable, multi-step automations without manual re-verification of every sub-component.

Builders integrate this process with the Model Context Protocol by using automated acquisition tools. The Nous Research `/learn` command exemplifies this by capturing directories, documentation URLs, and conversation logs to generate reusable `SKILL.md` files instantly. This approach eliminates manual authoring errors and ensures that the resulting fusion-recipe accurately reflects the executed logic.

The cost of this rigor is increased initial configuration overhead compared to ad-hoc scripting. Operators must define explicit interfaces for each fusion point, which slows initial prototyping but prevents downstream trust failures. Relying on unverified composites risks propagating errors through the entire skill graph, making the upfront investment in fusion-recipe validation necessary for production stability.

Privacy Boundaries in Gaia Scan and Data Curation

Gaia isolates capability metadata by recording only type, level, and evidence class while strictly excluding file contents, prompt text, or conversation history. This architectural constraint ensures the public ledger functions as a trust verification mechanism without becoming a repository for sensitive user data. Unlike static analysis tools that failed to detect mutable link vulnerabilities in recent security incidents, Gaia's model prioritizes structural evidence over content storage, mitigating risks associated with flexible content verification. The system collects zero analytics or usage data, meaning operators do not leak proprietary workflow details during the scanning process.

When integrating via the Model Context Protocol, builders connect local agents to this read-only registry to validate executable proof before loading skills. This approach prevents the injection of unverified code paths that have historically bypassed standard vetting processes. The trade-off is that developers must manually curate evidence pointers rather than relying on automated content scraping. Consequently, the registry maintains high fidelity for attribution data while leaving private intellectual property entirely on the user's local machine. This separation allows organizations to adopt shared capability graphs without exposing internal logic to the public network.

Deploying the Gaia CLI to Scan and Publish Verified Skills

Gaia CLI 6.3.14 Installation Methods and Core Commands

Release 6.3.14 of the Gaia CLI delivers the executable interface required to populate the public trust ledger with verified agent capabilities. Operators must choose an installation path that fits their specific environment constraints to guarantee proper dependency resolution.

1. Shell environments: Execute the automated script via `curl -fsSL gaiaskilltree.com | sh`.
2. Python ecosystems: Install directly using `pip install gaia-cli` within an isolated virtual environment.
3. Windows systems: Run the PowerShell command `iex (irm gaiaskilltree.com)` to configure the binary.

Local verification happens before any data leaves the machine once the toolset is active. The `gaia init` command builds the directory structure and configuration files needed for a new skill tree. Running `gaia scan` next analyzes the local repository to find code templates and resources matching the structural definition of a verifiable skill. This local-first strategy guarantees that only capabilities carrying attached verification logic enter consideration for the registry.

The `gaia push` operation opens a GitHub issue for review, adhering to the rule that programmatic management handles all metadata shifts. Hand-editing JSON nodes is deprecated because the system enforces integrity by forcing all graph modifications through these CLI commands. Such design stops the divergence between claimed and actual capabilities that plagues unverified registries, forcing a strict coupling between code execution and published metadata.

Executing Gaia Scan and Push Workflows for Skill Verification

Start the verification sequence by running `gaia scan` to detect local capabilities before any registry submission attempt. This command inspects the current directory structure to identify executable scripts and configuration files matching known agent patterns without altering source code. Developers working in mixed-language environments should note that Python constitutes 47.3% of the existing repository composition, suggesting a strong bias toward Python-based skill definitions during the initial scan phase. The tool generates a local manifest of candidate skills so operators can review inferred dependencies and entry points.

Validation of the local inventory allows the `gaia push` command to open a GitHub issue for review within the registry-for-review directory. This workflow enforces a strict separation between the pending `registry-for-review/` intake zone and the immutable `skill-trees/` where final per-user `skill-tree.json` files reside.

Failure often occurs when operators push skills lacking flexible verification evidence, as static analysis alone failed to detect mutable external link vulnerabilities in recent security audits. Every submitted capability must include proof of execution rather than just a static definition. A skill push remains blocked in the review queue until the associated GitHub issue contains links to reproducible test runs or benchmark results. This design prevents pollination of the graph with unverified claims, ensuring the public ledger reflects only demonstrated behaviors. Builders must treat the push operation as a request for evidence validation, not merely a file transfer mechanism.

Pre-Flight Checklist for Gaia Graph Generation and Fusion

Validate local directory structures before executing graph generation to prevent malformed node attribution during fusion. Developers managing capabilities across multiple environments should verify that symlinks resolve correctly, as real-world implementations like Skill Desktop demonstrate the operational necessity of a single source of truth. The skills explorer TUI displays disconnected fragments rather than a cohesive capability map without this alignment.

1. Confirm the repository root contains valid `skill-tree.json` files within the `skill-trees/` directory.
2. Ensure the `gaia graph` command can render output in html, svg, or json formats without parsing errors.
3. Verify that basic skills intended for combination are present before running the gaia fuse command.

Rapid iteration conflicts with graph integrity; fusing skills prematurely locks intermediate states into the public trust ledger before evidence aggregation completes. Operators must treat the fusion step as a commit boundary rather than a draft operation. The resulting skill graph accurately reflects executable proof rather than mutable claims when this validation sequence runs completely.

Strategic Value of Contributing to an open-source Agent Registry

Permanence of Attribution in the Gaia Public Trust Ledger

Private repositories vanish, taking claimed capabilities with them when owners delete accounts or switch to paid tiers. The ai agent skill registry secures capability attribution permanently against such losses. A persistent record of verified capabilities survives within the Gaia ledger regardless of individual hosting decisions. This public trust ledger attributes skills to the developers who proved them, creating a durable history independent of specific repository states. Centralized registries reduce search and discovery costs yet depend entirely on continuous host availability. Gaia decouples skill existence from these fragile states so the registry persists through community maintenance as long as developers create skills. The Apache 2.0 license guarantees these verified capabilities remain accessible even if original authors disengage. Permanent attribution demands active community curation to validate new entries against the G7 Trust Taxonomy. The ledger risks stagnation without ongoing peer review despite its structural permanence. Publishing to Gaia transforms transient code snippets into enduring, attributable assets for builders. This shifts the risk model from host-dependent fragility to community-sustained durability. AI Agents News recommends this path for maintainers seeking long-term credibility over temporary convenience.

Using Apache 2.0 Licensing for Open Agent Capability Maps

Engineers publish a shared map of agent capabilities without exposing proprietary logic by applying the Apache 2.0 license. This permissive framework allows curation of community skills while legally guaranteeing that the registry collects zero analytics or usage data. Encoding permissions directly into skill metadata prevents the silent data harvesting common in centralized agent marketplaces. The model mirrors successful decentralized efforts like the awesome-agent-skills repository, which curates over 1,000 compatible skills through similar open standards. Developers define these capabilities using plain Markdown files, specifically requiring a `SKILL.md` container to function as the metadata and instruction layer.

Gaia's Verified Skill Ledger Versus Unverified Marketplaces

Mutable capability claims give way to a permanent ledger of executable code runs when contributors prioritize Gaia. Unverified marketplaces often host over 1,000 agent skills that lack cryptographic proof of function, creating significant integration risk for production systems. The Gaia project maintains a verified registry of 235 skills where every entry requires successful local execution tests before inclusion.

Trusting math replaces trusting documentation as the strategic return on investment. Repositories like the awesome-agent-skills collection provide valuable breadth yet cannot guarantee that a listed skill functions as described without manual testing. Gaia enforces a higher standard where the trust magnitude of a skill depends on reproducible evidence rather than community upvotes. This approach eliminates the "link rot" failure mode common in decentralized ecosystems where skills vanish when maintainers delete private repos. Engineers gain a stable dependency graph where capability attribution persists independently of the original host's availability. A stricter contribution process yields a shared map where every node represents a proven, executable asset rather than a hopeful promise. This distinction determines whether an agent framework serves as a reliable tool or an experimental liability for teams building critical infrastructure.

References

• SWE-bench Verified tests agents against real GitHub issues, and