From repeated work to a trusted skill

Turn a real workflow into a tested, installable agent skill.

Bring the spreadsheet, report, SOP, link, screenshot, or script you already use. The platform turns it into a reusable workflow your team can inspect, verify, install, and improve.

Build it once. Prove it works. Reuse it safely.

  1. Workflow evidence
  2. Proposed skill
  3. Human confirms business meaning
  4. Evals + security checks
  5. Representative dry run
  6. Deploy across tools
  7. Corrections become governed improvement evidence
Turn a workflow into a skill See a verified example

Live API workflow verified

Current weather briefing

Input
São Paulo, Brazil
Result
21.1 °C · clear sky
Reliability
6 regression checks passed
Use it
/live-weather-briefing-skill

live API request passed · local Codex package install recorded · other runtime compatibility requires separate evidence

View verification evidence
5required decision fields
17supported targets
4visible steps
MITopen source

Start where you are

One platform, three clear paths

Pick the outcome you need—not an implementation detail.

  1. 01

    I have a workflow

    Turn examples of real work into a tested skill without writing a technical specification.

    Create your first skill
  2. 02

    I run an AI team

    Review, approve, publish, update, roll back, and quarantine skills through a governed marketplace.

    Run a marketplace
  3. 03

    I need evidence

    Inspect validation, security, evaluation, and representative-run evidence before you depend on a skill.

    Review trust boundaries

What is an Agent Skill?

A workflow package for reaching a verified outcome

An Agent Skill is a reusable workflow package that guides an agent from a recognized situation to a verified outcome. It can use retrieved knowledge, MCP tools, APIs, deterministic scripts, and agent judgment, but it is not itself a RAG system, MCP server, or agent runtime.

RAG supplies knowledge. MCP supplies capabilities. The harness supplies execution. A skill organizes them into a governed path toward a verified outcome.

Reason where interpretation is necessary. Execute and verify with deterministic controls where reproducibility matters.

Agent Skills Platform combines LLM reasoning with human-authorized meaning, executable scripts, pinned dependencies, validation, and evals. External models, APIs, and changing data may still vary; the product governs those conditions rather than promising identical outputs.

The whole process

What happens after you bring the work

The engineering stays available for inspection. It does not become homework.

  1. 01

    Understand

    The creator reads everything and summarizes the consequential question, trigger, supported decision, required evidence, success measure, and any unresolved business meaning.

    Behind the scenes: evidence, data structures, semantics, and authority
  2. 02

    Recon

    For every external or structured source, Semantic Recon probes the system and creates a pinned contract before implementation begins.

    Behind the scenes: source semantics, refusal rules, health and provenance
  3. 03

    Build

    It chooses the implementation, writes functional scripts and instructions, and packages the workflow for your agent tools.

    Behind the scenes: design, architecture, detection, implementation
  4. 04

    Check

    The skill is checked as one connected system, then proved with a useful example result.

    Behind the scenes: structural requirements and four parallel checks in the skill graph
  5. 05

    Try

    The skill installs in your detected tool and runs once using supplied material or a safe local example. You inspect the result.

    No real emails, publishing, purchases, or production writes for proof

Every skill is checked as one connected system. The skill graph links its instructions, scripts, evaluations, and expected outputs. Two structural requirements confirm that every expected result is tested and every predictable multi-step workflow has one reliable entry point. Four checks—specification, pipeline, security, and evaluation schema—run in parallel. Finally, a representative run proves that the skill produces a useful result.

The release path underneath Check One graph connects what exists to the evidence required for release.
  1. 01 Artifacts Instructions, scripts, evals, expected outputs
  2. 02 Skill graph Typed nodes, dependencies, and content hashes
  3. 03 Structural requirements Reachable evidence and reliable orchestration
  4. 04 Parallel checks SpecificationPipelineSecurityEvaluation schema
  5. 05 Representative run A result a person can inspect and correct

Start here

Choose your tool

Pick the tool you already use. The page shows where to paste one install action.

Paste in Terminal

Then paste this in your AI tool

/agent-skills-platform

This is just for me.
Every Friday I clean the CRM export, calculate regional totals, and email a PDF sales report.

No perfect prompt required: first say “This is just for me” for a private skill, or “My team will install or reuse this skill” to route it through a governed marketplace. Teammates receiving a report or queue does not require a marketplace. The creator then inspects your files, APIs, schemas, and examples; tracks evidence and unresolved meanings; and asks one bounded decision question at a time. Agent proposals cannot silently become organizational truth.

Success looks like: an identified human confirms consequential meaning and risk, the interview gate becomes ready, and the creator finishes with an inspectable result or one exact verification blocker.

Open the worker runbook: prompts, expected results, corrections, and escalation

From incomplete problem to governed skill The agent carries investigation and structure. Humans retain authority over meaning and risk.
  1. 01Messy problemStart with the work, evidence, and uncertainty you actually have.
  2. 02Inspect evidenceThe agent reads files, APIs, schemas, examples, and available tools first.
  3. 03Expose meaningInferences stay proposed; supported disagreements stay conflicting.
  4. 04Human decisionAn identified owner confirms consequential meaning and risk.
  5. 05Interview READYMissing evidence or authority remains BLOCKED and resumable.
  6. 06Build, prove, publishCompile the confirmed state into a tested, governed skill.

The governed skill lifecycle

One control plane from human workflow to reusable capability

Agent Skills Platform governs portable skill packages. It does not replace your agent runtime, MCP registry, IAM, secret manager, or endpoint controls.

  1. 01

    Capture

    Inspect evidence, expose competing meanings, and ask one bounded human decision at a time before compiling a contract.

  2. 02

    Compile

    Package portable instructions, deterministic helpers, and environment contracts.

  3. 03

    Prove

    Bind evals, safety checks, compatibility, and representative outcomes to the release.

  4. 04

    Govern

    Enforce ownership, semantic freshness, approval, versioning, rollback, quarantine, and retirement.

  5. 05

    Deliver + learn

    Install exact versions and improve them from consented, privacy-safe usage evidence.

Initialize an ACME marketplace

python3 scripts/team_marketplace.py init --name "ACME Skills" --repository ACME/acme-skills --marketplace ./acme-skills

What it creates: department namespaces, bundle manifests, question-first skill pages, CODEOWNERS, lifecycle policy, scheduled health checks, and provider-native CI. Installation does not imply readiness: each skill declares capabilities, permissions, risk tier, mutation boundaries, blocking preflight checks, and whether human-approved semantics apply. Overdue semantic definitions block release.

Portfolio proofpython3 scripts/team_marketplace.py portfolio-check --marketplace ./acme-skillsTests positive routing, non-triggering, and coexistence across published skills.
Department proofpython3 scripts/team_marketplace.py onboarding-report --marketplace ./acme-skillsReports ownership, separation of duties, readiness, and cross-team reuse evidence.

Open the complete command timeline

Trust through evidence

What the checks prove—and what they do not

Structure

The package follows the required format and names every referenced file.

Execution

Scripts compile, dependencies are declared, and examples can be scored again later.

Meaning + authority

When business meaning matters, the skill records who owns the definition, which source wins, and when review expires.

Known risks

The scanner checks secrets, dangerous patterns, instruction injection, and undeclared endpoints.

Honest limit

A clean scan means no known pattern matched. It is not proof that software is safe.

Human authority remains final: agents may structure, document, test, and apply organizational meaning. They do not establish it.

Semantic Recon is the default source gate: external and structured data are contract-bound before a generated skill can use them. No accuracy improvement is claimed from synthetic scores; no accuracy improvement is claimed unless isolated live evidence supports it.

Received a skill from somewhere else? Ask /agent-skills-platform --audit ./downloaded-skill/ before installing it.

Go deeper when you need it

The technical system is still here

Five-phase pipeline Evals and evolution Skill auditing Semantic-contract experiment Product scope and boundaries Worker runbook Team marketplace timeline GitLab marketplace backend All 17 platforms

Your first skill is done when you can inspect its first result.

Choose your tool