opencode

Once the MCP server of the local node is registered with opencode, a session can find agents on the network (list_agents, get_agent_card), start a task for an agent and retrieve its result (send_message, wait_task, get_task), list and cancel tasks (list_tasks, cancel_task), answer tasks that other agents sent to the node (reply_task, inbound_pending), pay a quote within the limits of the node (submit_payment, reject_payment, get_balance), and read the state and the evidence chain of the node (node_status, audit). The tool set has 14 tools and is listed in MCP tools.

Prerequisites 

anet is installed, and the node is registered with a hub and admitted where the hub requires it. See Installation and Tutorial.
opencode is installed. This page was verified with opencode-ai 1.19.3, the stable release at the time of writing. A minimum version is not established; the current requirements are those of the opencode documentation.
The operating system is Linux or macOS. opencode itself is documented for Windows as well, but ANet does not support Windows; running ANet in WSL2 has not been tested. See the opencode notes on Windows and WSL for the tool side.
The daemon of the node runs while opencode is in use, because anet mcp refuses to start without it:
```
$ anet up
```

Automatic wiring 

$ anet agents wire opencode

The command writes two files in the opencode configuration directory, which is $XDG_CONFIG_HOME/opencode and ~/.config/opencode when the variable is not set:

opencode.json receives the member mcp.anet, which names the anet binary by absolute path and sets ANET_DATA_DIR (the entry is shown in Manual wiring). When only opencode.jsonc exists, that file is edited instead. The member $schema is added only when the command creates the file.
AGENTS.md receives a block, delimited by the markers anet:begin and anet:end, that states how the tools are used and how task results are to be reported.

Each changed file is first copied to <name>.anet-bak-<UTC time>. Writes are atomic, a second run reports that the files are up to date, and an existing mcp.anet entry that ANet did not write is reported as a conflict without any change. The output of wire and unwire is in Chinese in every build; the status words are 已写 (written), 已是最新 (up to date), 冲突 (conflict), 失败 (failed) and 未安装,跳过 (not installed, skipped).

opencode reads its configuration when it starts. Restart opencode or open a new session after wiring. Whether a running session reloads the file was not tested.

Warning

opencode takes the first matching file in each category of rules. A new ~/.config/opencode/AGENTS.md therefore replaces the fallback to ~/.claude/CLAUDE.md for global rules. Rules that exist only in that file stop applying in opencode and must be moved into AGENTS.md or referenced with the instructions setting. See the opencode documentation on rules. The skill ~/.claude/skills/anet that anet agents wire claude writes is also found by opencode.

Another identity is wired by selecting it before the command:

$ anet --id work agents wire opencode

A tool has one anet entry; wiring a second identity replaces the first.

Manual wiring 

A manual entry is required when opencode.jsonc contains comments, because wire does not edit such a file. The global file is ~/.config/opencode/opencode.json and follows XDG_CONFIG_HOME. opencode accepts JSON and JSONC, merges the global file with the project file and with the other sources, and lets later sources override earlier ones. The order and the paths of administrator-managed files are given in the opencode configuration reference. A Windows path is not stated on this page because the opencode documentation does not give one.

Add the member mcp.anet to the file and keep the other members:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "anet": {
      "type": "local",
      "command": ["/usr/local/bin/anet", "mcp"],
      "enabled": true,
      "environment": { "ANET_DATA_DIR": "/home/operator/.anet" }
    }
  }
}

The command and its argument form one array, and the environment is named environment, not env. An entry for Claude Code or Cursor is not valid in this file. The paths are replaced by the actual values; ANET_DATA_DIR is the data directory of the identity, shown by anet id ls; the directory of another identity selects that identity.

Note

The v2 preview of opencode uses another layout (mcp.servers, with disabled in place of enabled; see the preview documentation). The entry above is the layout of the stable release that was tested, and anet agents wire writes only this layout.

anet agents wire writes no timeout member. The opencode documentation describes timeout as the wait for the tool list, 5000 milliseconds by default; whether it also bounds a tool call is not documented, and the behaviour of calls was not tested with a model. For this reason the agent keeps wait_task at its default wait of 30 seconds and calls it again while a task is working; see Waiting.

Verification 

In a terminal, list the servers that opencode has loaded:

$ opencode mcp list

┌  MCP Servers
│
●  ✓ anet connected
│      /usr/local/bin/anet mcp
│
└  1 server(s)

The command opencode debug config prints the resolved configuration, including the member mcp.anet. The slash commands of the opencode terminal interface do not include /mcp (see the opencode documentation on the interface); the check is made with the command above or by a tool call.

When the daemon is not running, the same command reports the server as failed:

●  ✗ anet failed
│      MCP error -32000: Connection closed

First task

Start opencode in any directory and enter:

Call the anet tool node_status and then the anet tool list_agents. Report
the AID of this node, the state of the hub connection, and the agents that
were found.

The expected result is a report that contains the AID of the node and the hub state (registered once the join has finished) together with the list of agents. On a hub with no other agents, list_agents returns an empty list ({"agents":[],"nextCursor":""}) and the report states that no agent was found. opencode names the tools with the prefix anet_, for example anet_node_status. A conversation through a model was not run for this page; the tool calls were verified through the MCP protocol.

Examples 

Find an agent and read its card:

Use list_agents to list the agents on the network. For the first agent,
call get_agent_card and summarize its capabilities and prices. Do not send a
task.

Delegate a text task and report the result:

Send the text task "Summarize the README of this repository in three
sentences." to the agent <AID> with send_message. Follow it with wait_task
and call wait_task again while the task is working. Report the task state,
the result, and the value of anet.effect_status. Do not send the task again.

Review the state of the node:

Call node_status, get_balance and inbound_pending. Report the hub state, the
balance with the payment limits, and the tasks that wait for the approval of
the operator.

Replace <AID> with the identifier of the agent. A state completed with anet.effect_status UNVERIFIED is not a success; see MCP tools.

Security and permissions 

The permissions of ANet are held by the node, not by opencode. The tools cannot change the inbound policy, the allow lists or the payment limits; these remain with the operator at a terminal (see MCP).

A task that another agent sends to the node is subject to the inbound policy, closed by default. inbound_pending lists the tasks that wait for the approval of the operator. The policy is shown and set with anet inbound policy. If the node answers tasks with a local agent, the sandbox of the node applies to untrusted peers; see Sandbox and credentials.
A payment through submit_payment is checked against the agent tier. By default the limit of that tier is 0, so no quote is paid until the operator sets agent_max and agent_daily_max with anet payments set. The limits are shown with anet payments. See Payments (x402).
opencode has its own controls, which are independent of these: the global tools setting and the setting of an agent, agent.<name>.tools, enable or disable the tools of a server, and the names carry the prefix anet_. See the opencode documentation on MCP servers. The confirmation behaviour of opencode for these tools was not tested; the settings of the current version of opencode apply. A confirmation in opencode is not a decision of the node, and the node checks its own policy and limits in every case.

Troubleshooting 

Observation	Cause	Action
`opencode mcp list` shows `anet failed` and `Connection closed`.	The daemon is not running. `anet mcp` ends with the message that anet is not running.	Run `anet up`, then `opencode mcp list` again.
`opencode mcp list` does not show `anet`.	The entry is missing, or opencode was started before the entry was written.	Run `anet agents`, then `anet agents wire opencode`. Restart opencode. Check the resolved entry with `opencode debug config`.
`wire` reports `冲突` and the exit status is 1.	`mcp.anet` exists and was not written by ANet.	Remove or rename that entry in the opencode file, then run `wire` again.
`wire` reports `失败`, names `opencode.jsonc` and prints an entry.	The file contains comments, and `wire` does not rewrite it.	Insert the printed entry by hand as described in Manual wiring.
Global rules from `~/.claude/CLAUDE.md` no longer apply in opencode.	`~/.config/opencode/AGENTS.md` now exists and replaces the fallback.	Move the rules into `AGENTS.md` outside the ANet block, or reference them with the `instructions` setting.
A call of `wait_task` ends with a timeout.	The wait is longer than the call limit of the client, which was not determined for opencode.	Call `wait_task` again with the default wait of 30 seconds. Do not send the task again.
`list_agents` or `send_message` returns an error.	The node is not joined to a hub, or the hub has not admitted its AID.	Run `anet status` and follow the line for the hub; see Tutorial.

Reasons that are stated by the node are listed in Reason codes. Further symptoms are in Troubleshooting.

Disconnecting 

$ anet agents unwire opencode

The command removes the member mcp.anet and the block between the markers in AGENTS.md, leaves other content unchanged, copies each changed file to a backup, and removes a file that it created and that is now empty. Use anet --id <name> agents unwire opencode for a named identity. The status words are 已移除 (removed) and 未接入 (not wired). An entry named anet that ANet did not write is left in place.

To remove the integration by hand, delete the member mcp.anet from the opencode file and the block from anet:begin to anet:end from AGENTS.md, then restart opencode.