6 min

SkillLedger 0.1.0: A Verified Marketplace for Agent Skills

Open Source Agents MCP Ruby on Rails Marketplace API Infrastructure Agent Skills
Digital marketplace interface showing verified agent skill packages flowing between autonomous AI agents with a central glowing ledger book

github.com/ghassan-ai-projects/skill-ledger - MIT license, shipping today.

Last week I watched an agent hire another agent to scrape a site. The first agent paid five credits. The second one took the money and returned garbage. Malformed JSON, missing fields, no error handling. The first agent had no way to verify what it was buying, no recourse, no receipt. Just a failed pipeline and a drained balance.

That is the state of the agent economy right now. Agents are starting to hire each other, but there is no contract, no verification, no receipt. A web scraping skill gets published. Another agent finds it, integrates it, and hopes it does what it says. If it breaks, there is no accountability. Just a cascading failure up the chain.

That gap is what SkillLedger fills.

SkillLedger is a marketplace and entitlement layer for agent skills. Authors publish skills as priced listings, attach versioned artifacts with a manifest, and those artifacts get verified by a verification service before they go live. Buyers discover skills, purchase a verified version, and acquire the packaged artifact for local execution. Every transaction creates a ledger entry and an entitlement token. Everyone knows who bought what, from whom, and when.

It is a Rails 8.1 API-only application that exposes both REST and MCP endpoints. Open source today under MIT.

What SkillLedger Is (And Is Not)

SkillLedger does four things:

  1. Stores agent accounts - each agent identity has a balance and an API key
  2. Manages skill listings - authors create, version, and publish skills with manifest-based artifacts
  3. Verifies artifacts - a verification service checks manifest structure, required fields, runtime constraints, and checksum integrity before marking a version as verified
  4. Records purchases in a ledger - every paid acquisition creates an accounting entry and a stable entitlement token

What SkillLedger does not do: execute third-party skills, sandbox untrusted code, scan artifacts for malware, or manage real-money settlement rails. The artifact is acquired for local execution. SkillLedger is the storefront, not the runtime.

Why not just an API marketplace?

Most marketplace APIs stop at listing and discovery. You browse, you pick, you hope it works. SkillLedger adds the verification gate and the purchase ledger as core primitives, not bolt-on features. An author cannot list a skill until at least one version has passed verification. A buyer cannot acquire a skill without a recorded purchase and an entitlement token. The verification model is explicit and inspectable. It is not a review score or a star rating. It is a deterministic check against a manifest contract. You can read exactly what was verified and how.

How It Works

The Author Side

Say you built a solid web scraping skill. You create a draft listing in SkillLedger. Name, description, price. Then you publish a version with an artifact manifest: a structured payload that describes the entrypoint, the runtime it needs, the input and output schemas, and optionally some bundled files.

The verification service runs through a series of checks:

  • Does the artifact exist and is the type supported?
  • Is the manifest a well-formed hash with all required fields?
  • Is runtime set to client? (No hosted execution. You run it locally.)
  • Does the manifest version match the SkillLedger version record?
  • If there are bundled files, do they include path, content, and media_type?
  • Does the checksum match the canonicalized manifest?

All six pass? The version gets marked verified. Now you can flip the listing status to listed. Until you do, it stays in draft, invisible to buyers. No shortcuts.

The Buyer Side

An agent builder browses listed skills via REST or MCP, finds your scraping skill, inspects a specific verified version. They hit purchase. The system records the transaction, deducts from the buyer balance, credits your author account, and issues an entitlement token. The buyer can then acquire the artifact payload and run it locally. No strings attached to your infrastructure.

The library endpoint gives each account three grouped views: favorites, purchased skills, and authored skills. Each purchased entry includes version and acquisition metadata, so the client knows whether they already downloaded the artifact or just paid for access.

The MCP Surface

SkillLedger exposes a JSON-RPC endpoint at POST /api/v1/mcp that mirrors the same authoring and buyer flows. If your agents speak MCP, they can interact directly:

skills/create          - Create a draft skill listing
skills/mine.list       - List my authored skills
skills/version.publish - Publish a version with artifact
skills/version.get     - Inspect a specific version
skills/listing.set_status - Toggle draft/listed/suspended
skills/list            - Browse all listed skills
skills/get             - Inspect a skill
skills/purchase        - Purchase a verified version
skills/acquire         - Download the artifact

The same operations are available through REST, so agents can choose whichever transport they speak.

What Ships in 0.1.0

This is the initial public release. The core publishing and acquisition path is tested and ready to run.

  • Rails 8.1 API-only application (Ruby 3.3.11)
  • SQLite-backed local development, Docker Compose with PostgreSQL for production-style use
  • API key authentication via X-API-Key header
  • REST endpoints for skills, versions, favorites, library, ledger, reports, and analytics
  • MCP-compatible JSON-RPC endpoint so agents can interact directly
  • Verification service with deterministic checks on artifact manifests
  • Purchase ledger with entitlement tokens and author payouts
  • Seeded demo data so you can start testing immediately
  • OpenAPI description (openapi.yaml)
  • Minitest coverage across controllers, services, models, and E2E flows
  • Dockerfile, Dockerfile.dev, docker-compose.yml for containerized workflows
  • Full docs under documentation/. 12 guides covering product, getting started, architecture, REST API, MCP API, security, operations, development
  • CI via GitHub Actions (test, RuboCop, Brakeman, bundle-audit)

Quick Start

git clone https://github.com/ghassan-ai-projects/skill-ledger
cd skill-ledger
gem install bundler:4.0.12
bundle install
bin/rails db:prepare
bin/rails db:seed
bin/rails server

The API starts on http://127.0.0.1:3000.

With Docker Compose (PostgreSQL):

docker compose up --build

Verify with:

curl -s http://127.0.0.1:3000/api/v1/skills \
  -H "X-API-Key: ***"

The seed creates two listed skills, a verified version, a demo purchase, and favorites. Enough data to exercise all flows immediately.

The Vision Behind It

The agent ecosystem is growing fast. Agents talk to each other, coordinate, share data, and increasingly, trade capabilities. What they do not do yet is buy and sell with confidence. Most of the conversation around agent marketplaces is about discovery. Finding the right skill. That is solved. The next question is harder: once you find it, how do you trust it, pay for it, and prove you own it?

This release is intentionally grounded. No blockchain, no ZK proofs, no bonded stake. Those conversations are interesting, but the agent economy does not need cryptographic complexity on day one. It needs a deterministic verification model, a clean purchase flow, and a ledger that proves the transaction happened. If the ecosystem needs more sophisticated trust mechanisms later, the architecture is designed to absorb them without a rewrite.

SkillLedger is the storefront for verified agent capabilities. Start with verification and a ledger. Let the community figure out what comes next.

What's Next

0.1.0 covers the core path end-to-end. Here is what I want to harden next:

  • Artifact packaging conventions - the manifest format works, but it needs community input to stabilize. If you build agent skills, I want to hear what your packaging looks like
  • Verification strictness - more checkpoints, clearer rejection messages, pluggable verifiers for different artifact types
  • Release/versioning policy - SemVer for skills, deprecation flows, migration paths
  • Operational maturity - rate limiting, audit logging, multi-tenant isolation for production use at scale
  • Real-money settlement - not yet, but the ledger model is designed for it. When the time comes, we will add Stripe or whatever makes sense

Clone it. Run the seed. Make your first purchase. If the manifest format does not fit your use case, open an issue. If you want to contribute a verifier or a new artifact type, PRs are open.

The agent economy needs a storefront that does not run on hope. Let us build it.

Repository: github.com/ghassan-ai-projects/skill-ledger
License: MIT
Release: 0.1.0 - June 15, 2026
Docs: documentation/ in the repo

Working on agent infrastructure? Let's talk about how I can help your team.

Get in Touch