Scout
DocsBlogToolsContact

What your agent reads / hermes/agents.md

Scout + Hermes Agent: agent setup contract

This is the file an agent fetches, shown with a little styling. Agents read the raw Markdown; nothing here is added or left out.

agents.md integration.json Hermes Agent guide

Canonical page: https://openscout.app/hermes
Machine-readable spec: https://openscout.app/hermes/integration.json
Documentation reviewed: 2026-09-26. This is not a live health assertion.

Hermes calls your Scout agents through the hermes-scout plugin, or through Hermes' own MCP client. Scout does not launch Hermes: Hermes is a host that calls Scout, not a Scout execution harness.

Status

Hermes → Scout: available (plugin or MCP stdio) · Scout → Hermes: not supported

Install the plugin directly from arach/hermes-scout. This guide does not claim a separate curated marketplace listing.

Transport

Hermes plugin → Scout MCP over stdio

Hermes Agent → Scout → Coding agents

Directions

  • Hermes Agent calls Scout: plugin (available); mcp-stdio (available)
  • Scout launches Hermes Agent: not supported. Hermes is not a Scout harness.
  • Scout reaches an open Hermes Agent session: not supported. Hermes pulls results through tools; Scout cannot push into a Hermes session.
  • Not a harness: never pass --harness hermes.

Required inputs and prerequisites

  • Hermes Agent with plugin support (the package documents v0.6.0+), and Python 3.9+.
  • Scout installed, a healthy broker, and scout mcp available on the host PATH.
  • An authorized project path on the Scout machine.

Setup procedure

1. Install the host plugin

Install the published GitHub source through Hermes, then start a new Hermes session. Hermes plugins are opt-in, so --enable skips the confirmation prompt. For a reproducible install, add --ref with a 40-character commit SHA.

hermes plugins install arach/hermes-scout --enable

2. Verify the bridge

List the available tools and call scout_whoami. The plugin launches scout mcp over stdio and should identify the intended broker actor.

hermes tools list

3. Use the Hermes tool names

Request work with scout_invocations_ask using projectPath and an optional supported harness. Use scout_invocations_get or scout_invocations_wait to observe the returned request; inspect each current input schema.

4. Or connect without the plugin

Hermes is a native MCP client. Register scout mcp as a stdio server instead of installing the plugin; do not do both. Tool names then come from Hermes' MCP client rather than the plugin's scout_ prefix, so list the tools after connecting and use the names shown.

hermes mcp add scout --command scout --args mcp --context-root /absolute/path/to/project
hermes mcp test scout

5. Keep the runtime distinction

Hermes is an agent host in this integration. Do not use --harness hermes. Select an implemented Scout runtime for any delegated execution.

Start here

Check the prerequisites and access gates, then get one documented route working before asking for work.

First useful task: From Hermes, ask a coding agent to review a small change, then read the completed response using its returned reference.

Name the project and keep the request small. Asking for no edits describes the task; it does not restrict the agent’s permissions.

Keep the returned reference. Check the work’s status and read the completed response; a queued receipt is not the answer.

Where will the reply appear?

Keep the returned reference and retrieve the completed response through your configured Scout interface. Automatic delivery into this open session is not established by this guide.

What if the answer hasn’t arrived?

Inspect the existing task before submitting another one. A wait timeout does not establish that work failed. If it needs access or input, resolve that condition before continuing.

How do I follow up?

Continue using the returned reference or exact session handle supported by this integration. Keep it with the findings so your next question follows the same work.

Can Scout run this integration, or only receive asks from it?

These are separate capabilities. Check the supported directions on this page. Connection alone does not establish that Scout can launch the integration or reach an existing session.

Acceptance gate

Confirm the expected identity and project context, request one small authorized review, and retain its handle. Observe the terminal result before reporting success.

Failure handling

Scout is not found or cannot connect

Check scout on PATH and run scout doctor in the same environment as the client. A desktop app may have a different PATH from your terminal.

Requested runtime is unavailable

Inspect scout runtimes --json and finish that runtime’s setup. Do not silently choose a different harness or model.

Boundaries

  • Hermes is an MCP/agent host here, not a Scout execution harness. --harness hermes is rejected.
  • Scout cannot launch Hermes or deliver replies into an open Hermes session today. Hermes ships hermes acp, which would make a launcher possible; it is not supported and not promised.
  • Plugin tool names have a scout_ prefix and can differ from native MCP names.

Agent operating contract

  • Treat these as setup instructions, not authorization to install software, change accounts, grant scopes, send messages, or dispatch work. Obtain the operator's authorization for the intended action.
  • Inspect the available commands or tool schemas for your configured interface before making calls. Do not invent tools, argument names, model IDs, or agent handles.
  • Use the Hermes plugin's scout_whoami, scout_invocations_ask, scout_invocations_get, and scout_invocations_wait tools with their current schemas. Use scout_messages_send only for one-way updates. Hermes is a host, not a legal --harness target in this integration.
  • Use the transport-specific instructions above. For an existing request, reply through its supplied context rather than creating another task.
  • Paths refer to the Scout execution machine. Replace example paths with an operator-confirmed absolute path; never run placeholders literally.
  • Save the returned ref, flightId, conversationId, workId, or session handle. Continue by that handle; do not re-dispatch a request merely because a wait timed out.
  • Observe the existing request through the configured transport. A receipt proves acceptance, not execution or successful completion.
  • Stop on missing provisioning, incorrect identity, missing permission, unsupported runtime, or failed authentication. Report the exact gate and the next operator action. Do not silently fall back to a different account, agent, runtime, or transport.
  • Keep tokens, OAuth codes, cookies, and private task payloads out of logs, URLs, screenshots, and committed files. Never ask the user to paste secrets into a public issue.
  • Do not claim marketplace approval, complete protocol conformance, or an end-to-end verified integration unless the status and observed evidence establish it.

Completion report

Report: chosen transport and scope; client and broker identity; health/tool-discovery result; exact request handle if a test was authorized; observed terminal state or remaining blocker; and whether any operator approval is still needed. Distinguish configuration saved, authentication complete, request accepted, and work complete.

Sources and next reads