{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-nousresearch--hermes-agent","slug":"nousresearch--hermes-agent","name":"hermes-agent","type":"agent","url":"https://hermes-agent.nousresearch.com","page_url":"https://unfragile.ai/nousresearch--hermes-agent","categories":["ai-agents"],"tags":["ai","ai-agent","ai-agents","anthropic","chatgpt","claude","claude-code","clawdbot","codex","hermes","hermes-agent","llm","moltbot","nous-research","openai","openclaw"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-nousresearch--hermes-agent__cap_0","uri":"capability://tool.use.integration.multi.provider.llm.orchestration.with.runtime.resolution","name":"multi-provider llm orchestration with runtime resolution","description":"Hermes abstracts LLM provider selection through a runtime resolution system that supports OpenAI-compatible endpoints, Anthropic, and local models. The architecture uses a provider registry pattern where model metadata (context windows, capabilities, pricing) is resolved at runtime, enabling fallback chains and dynamic provider switching without code changes. This decouples agent logic from specific LLM implementations, allowing users to swap providers via configuration or environment variables.","intents":["I want to use Claude for reasoning tasks but fall back to a local model if the API is down","I need to switch between OpenAI and Anthropic models without rewriting agent code","I want to run the same agent against multiple LLM providers to compare outputs"],"best_for":["teams building multi-model AI systems","developers prototyping with cost constraints","organizations with vendor lock-in concerns"],"limitations":["Provider-specific features (e.g., vision, function calling) may not be uniformly available across all backends","Fallback chains add latency overhead for provider health checks","Model metadata must be manually maintained for custom/local models"],"requires":["Python 3.9+","API keys for at least one provider (OpenAI, Anthropic, or compatible endpoint)","hermes_cli/providers.py and hermes_cli/runtime_provider.py modules"],"input_types":["configuration files (YAML)","environment variables","CLI arguments"],"output_types":["LLM responses","provider metadata","fallback routing decisions"],"categories":["tool-use-integration","provider-abstraction"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_1","uri":"capability://memory.knowledge.persistent.conversation.memory.with.honcho.integration","name":"persistent conversation memory with honcho integration","description":"Hermes implements persistent memory through Honcho, a memory management system that stores conversation history, context, and agent-learned patterns across sessions. The architecture maintains a session-based memory store where each conversation thread has associated metadata, allowing the agent to retrieve relevant historical context and build on previous interactions. Memory is indexed and queryable, enabling the agent to surface relevant past interactions during decision-making without exceeding context windows.","intents":["I want my agent to remember previous conversations and reference them in future interactions","I need to maintain conversation state across multiple sessions without losing context","I want the agent to learn from past interactions and improve its responses over time"],"best_for":["long-running agents serving persistent users","teams building multi-turn dialogue systems","applications requiring conversation continuity across deployments"],"limitations":["Memory retrieval adds latency to each agent step (context compression required for large histories)","No built-in memory pruning — requires manual cleanup of old sessions","Honcho integration requires external state store (database or API endpoint)"],"requires":["Honcho memory service (local or remote)","Database backend for Honcho (PostgreSQL recommended)","agent/auxiliary_client.py module for memory client initialization"],"input_types":["conversation messages","session identifiers","metadata tags"],"output_types":["retrieved memory summaries","relevant past interactions","context-compressed conversation history"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_10","uri":"capability://automation.workflow.cron.and.scheduled.task.execution","name":"cron and scheduled task execution","description":"Hermes supports scheduling agent tasks to run on a cron schedule or at specific intervals, enabling autonomous agents to perform periodic work (data collection, report generation, monitoring, etc.). The architecture uses a scheduler that manages task timing, handles missed executions, and logs task history. Scheduled tasks can access the full agent capabilities (tools, memory, subagents) and are executed in the same environment as interactive agent sessions.","intents":["I want my agent to run a daily report generation task without manual triggering","I need to monitor a system periodically and alert if issues are detected","I want to schedule agent tasks using standard cron syntax"],"best_for":["teams building autonomous monitoring/reporting systems","applications requiring periodic agent execution","organizations automating routine tasks"],"limitations":["Cron scheduling is timezone-dependent — requires careful configuration","Missed executions (e.g., due to downtime) are not automatically retried","Scheduler state must be persisted — requires external storage"],"requires":["Scheduler backend (APScheduler or similar)","Persistent storage for scheduler state","agent/scheduler.py module (inferred)"],"input_types":["cron schedule expressions","task definitions","task parameters"],"output_types":["task execution results","execution logs","missed execution alerts"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_11","uri":"capability://text.generation.language.voice.mode.with.tts.and.speech.transcription","name":"voice mode with tts and speech transcription","description":"Hermes supports voice interaction through speech-to-text transcription and text-to-speech synthesis, enabling agents to communicate via voice. The architecture integrates transcription services (Whisper, etc.) to convert user speech to text for agent processing, and TTS services to convert agent responses back to speech. Voice mode works across all deployment interfaces (CLI, messaging platforms) and maintains conversation context across voice turns.","intents":["I want to interact with my agent using voice instead of typing","I need my agent to respond with spoken audio for accessibility","I want to build voice-first agent applications"],"best_for":["accessibility-focused applications","voice-first user interfaces","mobile and hands-free agent interactions"],"limitations":["Speech transcription adds latency (typically 1-3 seconds per turn)","TTS quality varies by provider — may sound robotic","Accent and language support depends on transcription/TTS provider"],"requires":["Speech transcription service (Whisper API, etc.)","TTS service (Google Cloud TTS, Azure Speech, etc.)","Audio input/output hardware","agent/voice.py module (inferred from architecture)"],"input_types":["audio streams (WAV, MP3, etc.)","voice parameters (language, speaker)"],"output_types":["transcribed text","synthesized audio","voice metadata"],"categories":["text-generation-language","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_12","uri":"capability://data.processing.analysis.batch.processing.and.data.generation.for.rl.training","name":"batch processing and data generation for rl training","description":"Hermes includes a batch processing system that can run agents against large datasets, generating trajectories (sequences of agent actions and outcomes) for reinforcement learning training. The architecture supports parallel batch execution, result aggregation, and trajectory formatting for RL frameworks. Batch jobs can be configured with different agent configurations, toolsets, and model parameters to generate diverse training data.","intents":["I want to generate training data by running my agent against a dataset of tasks","I need to parallelize agent execution across multiple tasks for efficiency","I want to collect agent trajectories for fine-tuning or RL training"],"best_for":["research teams training agents with RL","organizations generating synthetic training data","teams optimizing agent behavior through fine-tuning"],"limitations":["Batch processing requires significant compute resources (parallel execution)","Trajectory generation is expensive (many LLM API calls)","Result aggregation and formatting requires custom code per RL framework"],"requires":["Batch job configuration (task dataset, agent config, parallelism)","Compute resources for parallel execution","agent/batch.py module (inferred from architecture)"],"input_types":["task datasets (JSON, CSV, etc.)","agent configurations","batch parameters (parallelism, timeout)"],"output_types":["execution results","agent trajectories","aggregated metrics"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_13","uri":"capability://tool.use.integration.acp.server.and.ide.integration","name":"acp server and ide integration","description":"Hermes implements the Agent Client Protocol (ACP) server, enabling integration with IDEs and code editors (VS Code, etc.) as a native extension. The ACP server exposes agent capabilities through a standardized protocol, allowing IDEs to invoke agent tools, request code generation, and display results inline. This enables developers to use Hermes agents directly within their development environment without context switching.","intents":["I want to use my Hermes agent as a VS Code extension","I need to invoke agent tools from within my IDE","I want to display agent results (code suggestions, explanations) inline in my editor"],"best_for":["developers using VS Code or other ACP-compatible IDEs","teams building IDE-integrated AI assistants","organizations standardizing on ACP for agent integration"],"limitations":["ACP protocol overhead adds latency to IDE interactions","IDE-specific features (inline suggestions, code lens) require custom IDE extensions","ACP server requires network connectivity (local or remote)"],"requires":["ACP server implementation","IDE with ACP support (VS Code 1.80+)","agent/acp_server.py module (inferred from architecture)"],"input_types":["ACP protocol messages","IDE context (file, selection, cursor position)"],"output_types":["ACP protocol responses","code suggestions","inline results"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_14","uri":"capability://automation.workflow.interactive.cli.with.tui.dashboard","name":"interactive cli with tui dashboard","description":"Hermes provides an interactive command-line interface (CLI) with a terminal user interface (TUI) dashboard that displays agent status, conversation history, tool execution, and memory state in real-time. The TUI uses keyboard navigation and mouse support for interactive control, and the CLI supports slash commands for agent control (e.g., `/clear` to reset memory, `/tools` to list available tools). The dashboard updates in real-time as the agent executes, providing visibility into agent behavior.","intents":["I want to interact with my agent through a user-friendly terminal interface","I need to monitor agent execution in real-time and see what tools it's using","I want to control the agent through keyboard commands without typing full prompts"],"best_for":["developers debugging agents locally","teams monitoring agent execution","users preferring terminal-based interfaces"],"limitations":["TUI rendering adds latency to agent responses (visual updates)","Terminal size constraints limit information display","Mouse support depends on terminal emulator capabilities"],"requires":["Terminal emulator with TUI support (most modern terminals)","Python 3.9+","cli.py and hermes_cli/main.py modules"],"input_types":["user text input","keyboard commands","mouse input"],"output_types":["agent responses","TUI dashboard updates","command execution results"],"categories":["automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_15","uri":"capability://automation.workflow.web.ui.dashboard.with.session.management","name":"web ui dashboard with session management","description":"Hermes includes a web-based dashboard UI that provides a browser-based interface for agent interaction, session management, and monitoring. The dashboard displays conversation history, agent status, memory state, and tool execution logs. Users can create multiple sessions, switch between them, and manage agent configurations through the web interface. The dashboard connects to the agent backend via WebSocket or HTTP API for real-time updates.","intents":["I want a web-based interface to interact with my agent","I need to manage multiple agent sessions from a browser","I want to monitor agent execution and view detailed logs"],"best_for":["teams deploying agents for non-technical users","organizations needing web-based agent interfaces","applications requiring multi-session management"],"limitations":["Web UI adds network latency compared to local CLI","Browser compatibility issues may affect some users","Real-time updates require WebSocket support (not all networks allow)"],"requires":["Web server (Flask, FastAPI, etc.)","WebSocket support for real-time updates","Modern web browser (Chrome, Firefox, Safari, Edge)"],"input_types":["user text input","session selection","configuration changes"],"output_types":["agent responses","session state","execution logs"],"categories":["automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_2","uri":"capability://tool.use.integration.agent.created.skills.system.with.security.sandboxing","name":"agent-created skills system with security sandboxing","description":"Hermes allows agents to create and register new skills (reusable tool functions) dynamically during execution, with a skills management system that validates, stores, and distributes skills across agent instances. The architecture includes a Skills Hub where agents can publish skills, and a security layer that requires explicit approval for skill execution. Skills are versioned and can be distributed as toolset packages, enabling agents to extend their own capabilities and share learned behaviors with other agents.","intents":["I want my agent to create new tools/functions based on patterns it discovers","I need to safely allow agents to extend their own capabilities without manual intervention","I want to share learned skills between multiple agent instances"],"best_for":["self-improving agent systems","multi-agent teams with shared knowledge","research environments exploring emergent agent behaviors"],"limitations":["Skill creation requires explicit approval workflow, adding latency to agent autonomy","No built-in skill versioning conflicts — multiple agents creating similar skills may cause duplication","Security sandboxing adds overhead to skill execution (command approval gates)"],"requires":["Skills Hub backend (local or remote)","Approval workflow system for skill validation","agent/skills.py module (inferred from architecture)"],"input_types":["skill definitions (Python functions or tool schemas)","skill metadata (name, description, parameters)"],"output_types":["registered skill identifiers","skill distribution packages","approval/rejection decisions"],"categories":["tool-use-integration","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_3","uri":"capability://automation.workflow.multi.interface.deployment.with.messaging.gateway","name":"multi-interface deployment with messaging gateway","description":"Hermes provides a messaging gateway architecture that abstracts the agent core from multiple user-facing interfaces (CLI, Telegram, Discord, WhatsApp, DingTalk, etc.) through platform adapters. The gateway handles session management, media handling, and platform-specific protocol translation, allowing a single agent instance to serve multiple messaging platforms simultaneously. Each platform adapter implements a standardized interface for message routing, user authentication, and response formatting.","intents":["I want to deploy my agent to Telegram, Discord, and WhatsApp without rewriting the core logic","I need to manage user sessions and authentication across multiple messaging platforms","I want to handle media (images, files) consistently across different messaging services"],"best_for":["teams deploying agents across multiple messaging platforms","organizations with existing Telegram/Discord/WhatsApp user bases","developers building omnichannel AI assistants"],"limitations":["Platform-specific features (e.g., Discord slash commands, Telegram inline keyboards) require custom adapter code","Media handling varies by platform — file size limits and format support differ","Session pairing and security setup required per platform (API keys, webhooks, etc.)"],"requires":["gateway/run.py module","Platform-specific API credentials (Telegram token, Discord bot token, etc.)","Webhook endpoints or polling infrastructure for message ingestion"],"input_types":["platform-specific message objects","user identifiers","media attachments"],"output_types":["formatted messages for each platform","media uploads","session state updates"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_4","uri":"capability://tool.use.integration.tool.registry.with.schema.based.function.calling","name":"tool registry with schema-based function calling","description":"Hermes implements a tool registry system where tools are registered with JSON schemas that describe parameters, return types, and execution constraints. The registry uses schema-based function calling to enable the LLM to invoke tools with type-safe arguments, supporting native function-calling APIs from OpenAI and Anthropic. Tools are organized into toolsets that can be selectively enabled/disabled per agent instance, and the registry validates tool invocations against their schemas before execution.","intents":["I want to define tools with strict type validation so the agent can't call them with invalid arguments","I need to enable/disable specific tools for different agent instances without code changes","I want to use native function-calling APIs from OpenAI/Anthropic instead of prompt-based tool invocation"],"best_for":["developers building production agents with strict tool contracts","teams managing multiple agent instances with different tool permissions","applications requiring deterministic tool behavior"],"limitations":["Schema validation adds ~50-100ms overhead per tool call","Complex nested schemas may exceed LLM context limits when serialized","Tool registry requires manual schema maintenance — no automatic schema generation from Python type hints"],"requires":["JSON schema definitions for each tool","Tool implementation functions matching schema signatures","agent/tool_registry.py module (inferred from architecture)"],"input_types":["tool definitions (Python functions or JSON schemas)","tool parameters (typed arguments)"],"output_types":["tool execution results","schema validation errors","tool availability metadata"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_5","uri":"capability://automation.workflow.terminal.and.file.operations.with.command.approval","name":"terminal and file operations with command approval","description":"Hermes provides tools for terminal command execution and file operations (read, write, delete, search) with a command approval system that requires explicit user consent before executing potentially dangerous operations. The architecture includes a security layer that parses commands, identifies risky operations (e.g., `rm -rf /`), and presents them to the user for approval. File operations are sandboxed to a configurable working directory, and command execution can be restricted to specific shells or command patterns.","intents":["I want my agent to execute shell commands but require approval for dangerous operations","I need to sandbox file operations to a specific directory to prevent accidental data loss","I want to audit all commands the agent executes for security and compliance"],"best_for":["developers building autonomous coding agents","teams deploying agents in production with security requirements","organizations needing command execution audit trails"],"limitations":["Command approval workflow adds latency (blocks agent execution until user responds)","Sandboxing to a working directory may break tools that need access to system directories","Command parsing heuristics may fail to detect all dangerous operations (e.g., obfuscated commands)"],"requires":["Interactive terminal or approval API for user consent","Configurable working directory for file sandboxing","agent/tools/terminal.py and agent/tools/file_ops.py modules (inferred)"],"input_types":["shell commands (strings)","file paths","file contents"],"output_types":["command execution results (stdout/stderr)","file contents","approval prompts"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_6","uri":"capability://code.generation.editing.code.execution.and.mcp.tool.integration","name":"code execution and mcp tool integration","description":"Hermes integrates the Model Context Protocol (MCP) for standardized tool communication and supports direct code execution (Python, JavaScript, shell) within sandboxed environments. The architecture allows agents to execute code snippets, interact with MCP-compliant tools, and receive structured results. Code execution is isolated from the main agent process, and MCP tools are registered in the tool registry alongside native Hermes tools, providing a unified interface for tool invocation.","intents":["I want my agent to execute Python code to solve problems without calling external APIs","I need to integrate MCP-compliant tools (e.g., from Claude's ecosystem) into my agent","I want code execution to be sandboxed so malicious code can't damage the host system"],"best_for":["research teams exploring code-generating agents","developers building agents that need computational capabilities","organizations integrating with MCP-compliant tool ecosystems"],"limitations":["Code execution sandboxing adds ~200-500ms overhead per execution","Sandboxed environments have limited access to system resources (network, file system)","MCP tool discovery and registration requires manual configuration"],"requires":["Sandbox runtime (Docker, local process isolation, or cloud execution environment)","MCP server implementations for integrated tools","agent/tools/code_execution.py and agent/tools/mcp.py modules (inferred)"],"input_types":["code snippets (Python, JavaScript, shell)","MCP tool invocations","tool parameters"],"output_types":["code execution results","MCP tool responses","error messages and stack traces"],"categories":["code-generation-editing","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_7","uri":"capability://planning.reasoning.subagent.delegation.with.hierarchical.task.decomposition","name":"subagent delegation with hierarchical task decomposition","description":"Hermes supports spawning subagents that can be delegated specific tasks, enabling hierarchical task decomposition where complex problems are broken into subtasks handled by specialized agents. The architecture allows the main agent to create subagents with specific toolsets, memory contexts, and model configurations, then coordinate their execution and aggregate results. Subagents can themselves spawn further subagents, creating multi-level hierarchies for complex problem-solving.","intents":["I want my agent to delegate specialized tasks to subagents (e.g., one for code review, one for documentation)","I need to parallelize work by spawning multiple subagents to solve different parts of a problem","I want subagents to have different tool permissions and model configurations than the parent agent"],"best_for":["teams building complex multi-agent systems","applications requiring specialized agent roles","research exploring hierarchical agent coordination"],"limitations":["Subagent spawning adds latency (new agent initialization, context setup)","Coordinating subagent results requires explicit aggregation logic in the parent agent","Subagent memory is isolated from parent — no automatic context sharing"],"requires":["Subagent configuration (toolsets, model, memory context)","Coordination logic in parent agent","agent/subagent.py module (inferred from architecture)"],"input_types":["task descriptions","subagent configurations","context/memory to pass to subagents"],"output_types":["subagent results","aggregated outputs","execution logs"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_8","uri":"capability://automation.workflow.execution.environment.abstraction.with.multiple.backends","name":"execution environment abstraction with multiple backends","description":"Hermes abstracts execution environments through a pluggable backend system that supports local execution, containerized execution (Docker), and cloud execution (AWS Lambda, etc.). The architecture defines a standard execution interface that all backends implement, allowing agents to execute code/commands in different environments without code changes. Environment selection is configurable per agent instance, and the system handles environment-specific setup (container image selection, cloud credentials, etc.).","intents":["I want to run my agent locally during development but deploy it to AWS Lambda in production","I need to execute untrusted code in isolated Docker containers","I want to scale agent execution across multiple cloud environments"],"best_for":["teams deploying agents across development/staging/production","organizations with strict isolation requirements","applications needing elastic scaling"],"limitations":["Cloud execution adds latency (container startup, network overhead)","Environment-specific setup (Docker images, cloud credentials) requires manual configuration","Debugging cloud-executed code is more difficult than local execution"],"requires":["Execution environment backend implementations (local, Docker, cloud)","Docker daemon (for containerized execution)","Cloud provider credentials (for cloud execution)","agent/execution_environments.py module (inferred)"],"input_types":["execution environment configuration","code/commands to execute","environment variables"],"output_types":["execution results","environment logs","resource usage metrics"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-nousresearch--hermes-agent__cap_9","uri":"capability://data.processing.analysis.context.compression.and.token.optimization","name":"context compression and token optimization","description":"Hermes implements context compression techniques to manage token usage and stay within LLM context windows, especially important for long-running agents with extensive conversation history. The system uses summarization, relevance filtering, and hierarchical compression to reduce context size while preserving critical information. Compression is applied to conversation history, memory retrievals, and tool outputs, with configurable compression levels per agent instance.","intents":["I want my agent to handle long conversations without exceeding the LLM's context window","I need to reduce token usage to lower API costs","I want to preserve important context while discarding irrelevant details"],"best_for":["teams running long-running agents with cost constraints","applications with extensive conversation histories","organizations optimizing LLM API spending"],"limitations":["Compression algorithms may lose important context (lossy compression)","Compression itself requires LLM calls, adding latency and cost","Optimal compression level varies by task — requires tuning"],"requires":["Compression algorithm implementations (summarization, filtering)","Configurable compression thresholds","agent/context_compression.py module (inferred from architecture)"],"input_types":["conversation history","memory retrievals","tool outputs"],"output_types":["compressed context","compression metadata","token usage estimates"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":54,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","API keys for at least one provider (OpenAI, Anthropic, or compatible endpoint)","hermes_cli/providers.py and hermes_cli/runtime_provider.py modules","Honcho memory service (local or remote)","Database backend for Honcho (PostgreSQL recommended)","agent/auxiliary_client.py module for memory client initialization","Scheduler backend (APScheduler or similar)","Persistent storage for scheduler state","agent/scheduler.py module (inferred)","Speech transcription service (Whisper API, etc.)"],"failure_modes":["Provider-specific features (e.g., vision, function calling) may not be uniformly available across all backends","Fallback chains add latency overhead for provider health checks","Model metadata must be manually maintained for custom/local models","Memory retrieval adds latency to each agent step (context compression required for large histories)","No built-in memory pruning — requires manual cleanup of old sessions","Honcho integration requires external state store (database or API endpoint)","Cron scheduling is timezone-dependent — requires careful configuration","Missed executions (e.g., due to downtime) are not automatically retried","Scheduler state must be persisted — requires external storage","Speech transcription adds latency (typically 1-3 seconds per turn)","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.9396392539232961,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.063Z","last_scraped_at":"2026-05-03T13:57:04.026Z","last_commit":"2026-05-03T13:54:26Z"},"community":{"stars":130590,"forks":19764,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=nousresearch--hermes-agent","compare_url":"https://unfragile.ai/compare?artifact=nousresearch--hermes-agent"}},"signature":"ur9k1diDIeuEJgg5cns8Sh7kLlJm1YEiEBh0ip98oLlIxbsVcdQ4NYgGNIv7Qs9esddbdozYOgtpUJXQR+juCw==","signedAt":"2026-06-22T09:42:50.699Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/nousresearch--hermes-agent","artifact":"https://unfragile.ai/nousresearch--hermes-agent","verify":"https://unfragile.ai/api/v1/verify?slug=nousresearch--hermes-agent","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}