Hermes Skill Builder for Apify & APIs

What does Hermes Skill Builder for Apify & APIs do?

Hermes Skill Builder transforms any Apify Actor, public API documentation page, GitHub repository, or OpenAPI specification into a production-ready agent skill package compatible with Hermes Agent and similar AI agent systems.

Instead of creating generic documentation summaries, this Actor generates structured, executable skill files that agents can understand, validate, and integrate immediately.

Hermes Skill Builder can generate skill packages for:

• Apify Actors with verified input schemas and executable connectors
• Public APIs with OpenAPI/Swagger specifications
• GitHub repositories with comprehensive README documentation
• Generic API documentation pages
• Custom services with structured specifications

Why use Hermes Skill Builder?

Modern AI agents need more than documentation - they need structured, validated interfaces to external tools. Converting Apify Actors and APIs into skill packages makes them discoverable, testable, and reusable across agent workflows.

Here are some of the ways you could use Hermes Skill Builder:

• Build portable skill libraries for Hermes Agent without manual documentation work
• Create executable connectors for Apify Actors with verified schemas and cost safety profiles
• Convert OpenAPI specs into agent-ready packages with validation guidance
• Generate test prompts and examples for agent integration testing
• Package APIs as skill bundles for distribution across teams and organizations
• Create agent-native interfaces for legacy or undocumented services

If you would like more inspiration on how skill packages could help your AI agent workflows, check out the Hermes Agent documentation.

What does Hermes Skill Builder generate?

For each run, the Actor produces a dataset item containing:

• SKILL.md - Human-readable skill documentation with capabilities, usage, and warnings
• manifest.json - Skill metadata, capabilities, and cost safety profile
• input_schema.json - Validated JSON Schema for skill inputs
• tool_call_contract.json - Executable connector with run endpoints, secrets, validation rules, and agent interaction policy
• examples.md - Real-world usage examples
• test_prompts.md - Agent test prompts for skill validation
• integration_notes.md - Technical notes for integration and troubleshooting
• Optional ZIP package - All files bundled and stored in the default Key-Value Store
• Stable output links - Direct URLs to each file and the summary

The output is designed for Hermes Agent skill workflows and is compatible with other agent systems that use markdown instructions, JSON schemas, and structured manifests.

How to use Hermes Skill Builder

It's easy to turn any Apify Actor or API into a Hermes-ready skill package. Just follow these steps:

1. Click Try for free
2. Paste your source URL (Apify Actor page, GitHub repo, API docs, or OpenAPI spec)
3. Choose optional settings like ZIP export and test prompt generation
4. Click Run
5. When complete, download files from the Dataset tab or import the ZIP into your Hermes Agent skills directory

Supported sources

Apify Actors

Paste any Apify Actor URL, such as https://apify.com/solutionssmart/google-maps-lead-scraper. The Actor fetches public metadata, input schemas, and documentation to generate an executable connector with verified inputs, cost safety guidance, and agent interaction rules.

GitHub repositories

Paste a GitHub repo URL. The Actor extracts README content and file structure to build 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 spec and generates schemas, examples, and connector guidance.

Generic API documentation

Paste any public API documentation URL. The Actor parses 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,
  "llmProvider": "none"
}

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 analyzes your URL and identifies the source type (Apify Actor, GitHub, OpenAPI, or generic docs)

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

3. Skill generation - The Actor generates all required files: SKILL.md, manifest.json, input_schema.json, and more

4. For Apify Actors, enhanced output:

   • 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 enhancements - Generate examples, test prompts, and ZIP export

All generation is deterministic and doesn't require an LLM API key. The Actor completes quickly on HTTP-first sources and stays cost-effective.

For Apify Actors: Executable connectors

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

The generated files include:

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

• Agent interaction policy - Tells agents which fields to ask by default, which to hide, which are expert-only, and which should trigger cost warnings

• 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 which fields can increase run cost, provides safe test inputs, and recommends using run-sync or async endpoints based on expected duration

• Field classification - Categorizes inputs as basic user fields, advanced fields, internal/debug fields, or high-cost fields so agents don't overwhelm users with options

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

Readiness levels are:

• 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 integrate skills into Hermes Agent

1. Download the generated ZIP or copy individual files from the dataset
2. Create a folder named after skillName in your Hermes Agent skills directory
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 will automatically understand:

• 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 for using Hermes Skill Builder

• Use OpenAPI specs for the highest quality output - OpenAPI/Swagger specs produce the most complete and validated schemas
• Test the skill immediately - Use the included test prompts to verify the skill works with your agent before deploying
• Review cost warnings - For Apify Actors with expensive operations, check the cost safety profile and adjust defaults if needed
• Export ZIP for easy distribution - ZIP packages are easy to share, version, and integrate across multiple Hermes instances
• Check integration notes - The integration_notes.md file contains important technical details for your specific source
• Use conditional requirements for complex Actors - If your Actor has multiple modes or conditional inputs, review the tool_call_contract.json to understand how agents should validate inputs

Is it legal to use Hermes Skill Builder?

Hermes Skill Builder creates skill packages from publicly available sources. However, be aware:

• 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 our blog post on web scraping legality and ethics.

Limitations

• JavaScript-heavy documentation may be incomplete without future browser support (currently HTTP-first only)
• 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)
• Optional LLM enhancement is reserved for future improvements and not required for useful output

What makes this useful?

Hermes Skill Builder bridges the gap between existing developer tools and modern AI agent workflows. It turns static documentation, APIs, and Apify Actors into executable, validated, reusable skill packages. The result is:

• Faster integration - Agents understand your tool immediately without manual schema work
• Safer execution - Cost warnings, conditional validation, and safety profiles prevent expensive mistakes
• Better agent behavior - Structured interaction policies guide agents to ask better questions
• Easier distribution - ZIP packages and stable URLs make sharing skills simple
• Portable skills - Generated files work with Hermes Agent and other compatible agent systems