Turn Apify Actors and APIs into Hermes-ready agent skills

Paste a URL and get a skill package that agents can load, validate, and run.

Hermes Skill Builder converts:

• Apify Actors → executable connectors with verified input schemas
• OpenAPI / Swagger → validated schemas and examples
• GitHub READMEs → capability packs
• Public API docs → structured skill drafts

What you get each run

• SKILL.md - when to use the skill
• manifest.json - capabilities and cost safety
• input_schema.json - validated inputs
• tool_call_contract.json - how agents should call it
• examples.md and test_prompts.md
• Optional ZIP in Key-Value Store

60-second start

1. Click Try for free
2. Paste an Actor or API URL, such as any public Apify Actor page
3. Leave sourceType on auto, keep exportZip on
4. Run, then download the ZIP from Key-Value Store
5. Install it under ~/.hermes/skills/<category>/<skillName>/, or run hermes skills install <url>, then reload Hermes

Typical full package (no LLM) ≈ $0.23 on pay-per-event. Platform usage for this Actor is covered by the publisher when configured that way.

If the run worked, bookmark and rate the Actor. That helps others find it in the Store.

Writing skills by hand is easy to get wrong. The markdown can drift away from the real schema. For Apify sources, this Actor pulls official metadata, sets schemaVerified, and adds cost warnings to help agents avoid bad inputs and unnecessary spend.

The generated package provides Apify-verified executable skills, not just markdown copied from documentation. Each Apify skill includes Hermes frontmatter, its required APIFY_TOKEN declaration, a verified input schema, an executable tool-call contract, readiness levels, and cost-safety guidance.

Deterministic by default - no LLM API key required.

Supported sources

Apify Actors

Paste an Apify Actor URL, such as https://apify.com/solutionssmart/google-maps-lead-scraper. The Actor fetches its public metadata, input schema, and documentation, then generates an executable connector with input validation, cost guidance, and rules for agent interaction.

GitHub repositories

Paste a GitHub repository URL. The Actor reads the README and file structure, then builds a skill package with detected capabilities and usage examples.

OpenAPI/Swagger specifications

Paste a direct OpenAPI/Swagger JSON or YAML URL. The Actor validates the specification and generates schemas, examples, and connector guidance.

Generic API documentation

Paste a public API documentation URL. The Actor uses visible headings, tables, and code blocks to infer capabilities, inputs, and outputs.

Example input

{
  "sourceUrl": "https://apify.com/solutionssmart/fast-google-map-scraper",
  "sourceType": "auto",
  "skillName": "fast_google_maps_scraper",
  "includeExamples": true,
  "includeTestPrompts": true,
  "exportZip": true,
  "maxPages": 3,
  "useBrowser": false
}

Example output

{
  "sourceUrl": "https://apify.com/solutionssmart/fast-google-map-scraper",
  "sourceType": "apify_actor",
  "skillName": "fast_google_maps_scraper",
  "title": "Fast Google Map Scraper",
  "summary": "Hermes-ready skill package generated from the source.",
  "confidence": 0.95,
  "detectedCapabilities": ["Extract leads from a source workflow"],
  "files": {
    "SKILL.md": "# Fast Google Map Scraper\n...",
    "manifest.json": "{...}",
    "input_schema.json": "{...}",
    "tool_call_contract.json": "{...}",
    "examples.md": "...",
    "test_prompts.md": "...",
    "integration_notes.md": "..."
  },
  "zipKeyValueStoreUrl": "key-value-store://default/fast_google_maps_scraper.zip",
  "schemaVerified": true,
  "schemaSource": "apify_actor_metadata",
  "readiness": {
    "level": "executable",
    "canRunDirectly": true
  },
  "costSafetyProfile": {
    "recommendedTestInput": {...},
    "safeModeDefaults": {...}
  }
}

How it works

1. Source detection - The Actor identifies whether the URL points to an Apify Actor, GitHub, OpenAPI, or generic documentation.

2. Metadata extraction - For Apify Actors, it fetches public metadata and verified input schemas from the Apify API. For other sources, it parses HTML, README files, or specifications.

3. Skill generation - The Actor writes SKILL.md, manifest.json, input_schema.json, and the other package files.

4. Apify-specific details:

   • Executable tool_call_contract.json with Actor slug, API ID, run endpoints, and APIFY_TOKEN handling
   • Conditional input validation for mode-based Actors
   • Agent interaction policy (which fields to ask, which to hide, which need warnings)
   • Cost safety profile with recommended test inputs and safe defaults
   • Field classification into basic, advanced, internal, and high-cost categories
   • Readiness level assessment (executable, validated, or draft)

5. Optional files - Generate examples, test prompts, and a ZIP export.

Generation is deterministic and does not require an LLM API key. HTTP-first sources usually complete quickly and keep the run cost low.

For Apify Actors: Executable connectors

When the source is an Apify Actor, Hermes Skill Builder produces an executable agent-tool connector, not just a documentation draft.

The generated files include:

• Verified input schema - Uses official Apify Actor metadata when available, with schemaVerified: true and schemaSource: apify_actor_metadata

• Agent interaction policy - Tells agents which fields to ask for, hide, reserve for experts, or flag with a cost warning

• Conditional input requirements - Helps agents validate mode-specific inputs before making paid or long-running calls. For example, a Google Maps Actor might require query and searchLocation in search mode, but only placeId in place mode

• Cost safety profile - Lists fields that can increase run cost, provides safe test inputs, and recommends run-sync or async endpoints based on expected duration

• Field classification - Groups inputs as basic, advanced, internal/debug, or high-cost so agents can keep the user-facing choices focused

• Default mode and conditional-only fields - Keeps normal conversations focused. For example, the skill can default to search mode and ask for place-specific fields only when the user chooses place mode

The package reports one of three readiness levels:

• executable - Actor slug, endpoints, and verified input schema are available. The skill can run directly.
• validated - Actor slug and meaningful metadata are available, but schema is not fully verified.
• draft - Only heuristic extraction was possible (fallback for unavailable metadata).

How to add a skill to Hermes Agent

1. Download the generated ZIP or copy individual files from the dataset
2. Create ~/.hermes/skills/<category>/<skillName>/, or install the package with hermes skills install <url>
3. Place all generated files in that folder
4. Refresh the agent skill loader
5. Test with prompts from test_prompts.md

For Apify Actor skills, agents get guidance for:

• How to call the Actor with proper input validation
• Which inputs are required vs. optional
• Which fields might increase costs
• How to extract and handle results
• How to handle errors and retries

Tips

• Start with OpenAPI when available - OpenAPI/Swagger specs produce the most complete and validated schemas
• Test the skill early - Use the included prompts to check the skill with your agent before deployment
• Review cost warnings - For Actors with expensive operations, check the cost safety profile and adjust defaults if needed
• Export a ZIP for distribution - ZIP packages are easy to share, version, and import into multiple Hermes instances
• Read the integration notes - integration_notes.md contains source-specific details and troubleshooting guidance
• Check conditional requirements - For Actors with multiple modes, review tool_call_contract.json to see how agents should validate inputs

Is it legal to use Hermes Skill Builder?

Hermes Skill Builder creates packages from publicly available sources. Check the following before you use or distribute one:

• Respect API terms of service - Check the terms of any API or Apify Actor you're packaging. Some may restrict programmatic access or agent-based usage
• Personal data protection - Personal data is protected by GDPR in the European Union and by other regulations worldwide. Do not scrape or expose personal data unless you have a legitimate reason and proper consent
• Attribution - Some APIs and open-source projects require attribution. Check license requirements before distributing generated skills
• Commercial use - If you plan to monetize skills or the data they retrieve, ensure compliance with the underlying API's commercial use policy

For more guidance, read Apify's post on web scraping legality and ethics.

FAQ

Does this replace Apify MCP?

No. MCP connects agents to Apify live. This Actor packages a specific Actor/API into a reusable Hermes skill folder you can version and share.

How is this different from Hermes /learn?

Hermes /learn can author a general skill from a URL, folder, or conversation. Hermes Skill Builder is specialized for Apify: it extracts and verifies the Actor input schema, emits an executable tool_call_contract.json, reports readiness, and adds cost-safe defaults and warnings before a run.

Do I need an OpenAI key?

No. Generation is deterministic and does not use an LLM.

What sources work best?

OpenAPI specs and Apify Actor pages (best). GitHub READMEs and generic docs work, with lower confidence.

Is the Apify connector "executable"?

When metadata + input schema are available: yes (readiness.level = executable). Otherwise you get validated or draft.

Can I use the skills outside Hermes?

Yes, with any agent system that understands markdown skills + JSON schemas/manifests. Hermes is the primary target.

How do I try it safely?

Use a public Actor URL, exportZip: true, and useBrowser: false. Review costSafetyProfile before wiring paid Actors.

Limitations

• JavaScript-heavy docs may need useBrowser: true (higher cost). Browser mode is capped at three rendered pages per run and remains opt-in; default is HTTP-first.
• Generic API documentation is inferred from visible headings, tables, and code blocks (may miss complex behaviors)
• OpenAPI specs produce the highest-confidence schemas; HTML parsing is a fallback
• GitHub parsing focuses on README content in the MVP (full repo analysis coming later)
• LLM-based wording enhancement is not supported; output is deterministic