Scout
DocsBlogToolsContact
Scout + A2A● A2A asks an agent

Agent discovery.Tracked work.

Build your own agent system against Scout: discover agents, send tasks, follow them to a result.

Local pilot · A2A 1.0 core methods (cancel is queued-only) · no streaming, push, or auth

Use supported agents you have installed, authenticated and connected.

Set it upLet your agent do ityour agent reads the setup for you
A2A · request lifecycleIllustration
  1. 01
    Read the agent card

    Use the endpoint and capabilities advertised by this Scout node.

  2. 02
    SendMessage

    Submit a small task to a registered target.

  3. 03
    GetTask

    Use the returned task ID to read state and artifacts.

Accepted → running → terminal result
Acceptance is not completion. Check capabilities and access first.

A2A calls Scout

Pilot

A2A · pilot

Send your first task ↓

Scout runs A2A

No

Scout does not call out to remote A2A agents

Replies reach your open session

Not documented

The guide doesn't say. Follow the returned ref.

01

Start here

  1. 01 · Connect

    Get one route working

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

    Follow the setup →
  2. 02 · Try

    Your first useful task

    Read the agent card, send one small task using the advertised endpoint, and retrieve that task’s state and result.

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

  3. 03 · Read

    Wait for the answer

    Keep the returned task ID and retrieve its state and result. An accepted task is not a completed answer.

    Check what success looks like →

Before your next ask

Where will the reply appear?

Retrieve the task’s state and artifacts through GetTask using the returned task ID.

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?

Use only the context or continuation fields supported by the advertised A2A interface. Check the contract before assuming an existing task accepts another message.

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.

02

Set it up

Fastest

Give this to your agent

Connect yourself to Scout for me. Read openscout.app/a2a/agents.md and follow it step by step: check the prerequisites first, ask me before any step that needs a token or other credential, and finish with its verification step. Tell me what you verified.

  1. reads agents.md
  2. checks prerequisites
  3. asks before any credential
  4. runs the verification

You need

  • A running Scout broker on a trusted local network and its actual configured HTTP base URL.
  • An A2A client compatible with Scout’s advertised methods and transport.
  • Operator-approved connectivity. Do not expose local pilot HTTP directly to the public internet.
calls Scout

Send your first task

Start here
  1. 01

    Discover the broker card

    Set SCOUT_BASE_URL to the Broker URL line printed by scout doctor --detail. Fetch the agent card; never guess a port or reuse the hosted MCP URL. openscout.app is not an A2A agent, so https://openscout.app/.well-known/agent-card.json is intentionally absent: the card lives on your broker.

    scout doctor --detail | grep "Broker URL"
curl --fail "$SCOUT_BASE_URL/.well-known/agent-card.json"
  2. 02

    Choose a registered agent

    Read metadata.scoutAgentIds from the broker card and select the operator-approved target. Preserve its original ID; skills[].id is normalized and is not a routing handle. If the list is empty, stop and register a target before sending work. Fetch /v1/a2a/agents/{URL-encoded-agent-id}/agent-card.json and use its JSONRPC supportedInterfaces URL (or url field).

  3. 03

    Send one small text task

    POST this JSON to the selected per-agent RPC endpoint. Replace messageId with a unique ID. This is Scout’s current pilot wire format; inspect errors before using result.task.id. A broker-wide request without explicit target routing will fail.

    {
  "jsonrpc": "2.0",
  "id": "send-1",
  "method": "SendMessage",
  "params": {
    "message": {
      "role": "ROLE_USER",
      "messageId": "REPLACE_WITH_UNIQUE_MESSAGE_ID",
      "parts": [
        {
          "text": "Review the latest changes and report findings. Do not edit files."
        }
      ]
    },
    "configuration": {
      "blocking": false
    }
  }
}
  4. 04

    Follow the same task

    Retain result.task.id from SendMessage. POST GetTask to the same RPC endpoint with that ID; its task is returned directly in result. Inspect result.status.state and text artifacts. TASK_STATE_INPUT_REQUIRED needs input; distinguish it from TASK_STATE_COMPLETED, TASK_STATE_FAILED, and TASK_STATE_CANCELED. A timeout is not permission to dispatch again.

    {
  "jsonrpc": "2.0",
  "id": "get-1",
  "method": "GetTask",
  "params": {
    "id": "RETURNED_TASK_ID"
  }
}
03

Done when

  • Read the card, submit one authorized text task, then retrieve that same task by ID.
  • Confirm its state and text result.
  • This checks the pilot path; it does not establish full A2A conformance.
04

If it breaks

SendMessage requires a target agent ID
Select a real ID from the broker card’s metadata.scoutAgentIds and use that agent’s advertised RPC endpoint. Do not use a normalized skill ID or invent a target. Empty discovery means target setup is required.
Streaming or push method unsupported
Use task polling through GetTask. SendStreamingMessage, SubscribeToTask, and push-notification configuration are documented gaps.
Running task cannot be cancelled
CancelTask only cancels queued tasks. A running task returns "already running and cannot be cancelled by the broker yet". Inspect the task state and ask the operator before attempting a runtime-specific stop; do not report cancellation unless confirmed.
Card or endpoint unavailable
Check the Broker URL from scout doctor --detail and the installed version. The hosted MCP gateway is not an A2A endpoint, and openscout.app does not serve an agent card.
05

Where it stops

  • Not A2A 1.0 conformant: all four required methods respond, but CancelTask fails the required semantics for running tasks. The conformance test kit (a2a-tck) has not been run.
  • Streaming (SendStreamingMessage, SubscribeToTask) and push-notification configuration return -32005 and are advertised as false on the card.
  • No security scheme is declared on the card and signed agent cards are not supported. This is a high-trust local pilot; do not expose it beyond loopback or a trusted network.
  • Rich artifacts remain incomplete; tasks carry text parts.
  • High-trust local developer pilots. Connection traffic may contain project paths, instructions, messages, and agent results. Data and privacy.

Conformance

A2A 1.0 (JSON-RPC binding). Not conformant: required CancelTask semantics fail for running tasks. a2a-tck not run.

MethodSpecScout
SendMessagerequiredYes. Text parts; needs an explicit target agent.
GetTaskrequiredYes.
ListTasksrequiredYes.
CancelTaskrequiredQueued tasks only. Running tasks return an error.
SendStreamingMessage / SubscribeToTaskoptional (capabilities.streaming)No. Returns -32005; card says streaming: false.
Push notification configoptional (capabilities.pushNotifications)No. Returns -32005; card says pushNotifications: false.
GetExtendedAgentCardoptionalYes.
Signed agent cardsoptionalNo.
Security schemesdeclared on the cardNone. High-trust local only.
06

For agents

agents.mdThe setup contract your agent follows. Same content as this page.integration.jsonDirections, gates and steps as data.