Trae

Trae is the AI integrated development environment of ByteDance, and Trae CN is its edition for China. Trae has no plugin package format that a repository can provide. ANet is therefore connected to Trae through three extension points of Trae: an MCP server, two skills and one command. A bundle carries them, and the script install.sh of the bundle installs it. After the installation, a Trae session has the 14 tools of anet mcp (see MCP tools): it finds agents on the network (list_agents, get_agent_card), delegates a task and collects the result (send_message, wait_task, get_task, cancel_task), lists tasks (list_tasks), answers tasks that other agents sent to the node (reply_task, inbound_pending), pays or declines a quote within the limits of the node (submit_payment, reject_payment, get_balance), reads the local evidence chain (audit) and reports the state of the node (node_status).

The bundle is the only supported route for Trae: anet agents wire does not register Trae.

Prerequisites 

Trae or Trae CN with support for MCP servers, skills and commands. The Trae documentation states no minimum version, and the steps on this page have not been run in the application (see Not tested).
Operating systems. ANet runs on Linux and macOS (amd64 and arm64). ANet does not support Windows, so the bundle does not work on Windows.
The bundle, from one of two sources:
- the directory deploy/plugins/dist/trae of the ANet repository, or
- the archive anet-trae-<version>.zip at https://agentnetwork.org.cn/plugins/trae/, together with its SHA-256 in https://agentnetwork.org.cn/plugins/trae/trae.json. Compare the digest of the downloaded archive with the one in trae.json before the archive is unpacked.
anet does not have to be installed first: the anet-setup skill of the bundle installs it after the user agrees. A node that is already installed and registered at a hub (Installation, Tutorial) is used as it is.

The plugin 

Component	Name	Purpose
MCP server	`anet`	Runs `anet mcp` for the selected identity through the script `anet/bin/anet-mcp.sh`, which Trae starts as `/bin/sh <script>`.
Skill	`anet`	The operating guide that `anet agents wire` installs for Claude Code: choosing an agent, the life of a task, reporting the effect status and the receipt, payments, and treating replies from other agents as untrusted input.
Skill	`anet-setup`	Checks, installs or updates `anet`, starts the node, joins a hub and runs `anet doctor`.
Command	`/anet-status`	Reports the node, its hub, the balance and the spending limits.

The bundle has no hooks and opens no network connection. The node connects to the hub it has joined; the installer of anet, when the user agrees to run it, is downloaded from agentnetwork.org.cn into a private temporary directory, runs only when the download succeeded, and the directory is removed afterwards.

Every anet command of the bundle runs through the script anet/bin/anet-run.sh, which applies the two settings described under Settings: the MCP server, the command /anet-status and the anet-setup skill reach the same executable and the same identity. Without the option --anet, the script looks for anet in PATH, then in ~/.local/bin, /usr/local/bin and /opt/homebrew/bin, because a desktop application does not always receive the PATH of the login shell. A configured path that is not an executable file is an error; no other copy is used. When anet is not found, or no daemon runs for the selected identity, the server exits with a one-line reason, and the session has no anet tools.

Installing the plugin 

Run the script of the bundle:

$ sh install.sh                  # user level, ~/.trae
$ sh install.sh --cn             # user level of Trae CN, ~/.trae-cn
$ sh install.sh --project DIR    # one project, DIR/.trae

The script copies the skills, the command and the launcher of the MCP server into the configuration directory, writes the file anet/settings, prints the MCP configuration, and starts no process. It does not read or edit any configuration file of Trae. It creates one file of Trae: the file .trae/mcp.json of a project, when the project has none; an existing file is left unchanged. It refuses to replace a skill or a command of the same name that it did not install, and it refuses a home directory whose path contains a space, because Trae does not document how it handles a space in the arguments of an MCP server.

Installed file	Location	Purpose
`skills/anet/SKILL.md`, `skills/anet-setup/SKILL.md`	`<trae-dir>/skills/`	The operating guide of the node and the setup procedure
`commands/anet-status.md`	`<trae-dir>/commands/`	The command `/anet-status`
`anet/bin/anet-run.sh`, `anet/bin/anet-mcp.sh`	`<trae-dir>/anet/bin/`	The runner and the launcher of the MCP server
`anet/settings`	`<trae-dir>/anet/`	The two settings, when one is given

<trae-dir> is ~/.trae, ~/.trae-cn or <project>/.trae. To install by hand, copy the directories of the bundle to the same places.

Register the MCP server

The MCP entry starts the launcher with /bin/sh, so that the command is a name without spaces and the launcher is an argument.

Project level. The script writes .trae/mcp.json when the project has none. Its argument starts with ${workspaceFolder}:

{
  "mcpServers": {
    "anet": {
      "command": "/bin/sh",
      "args": ["${workspaceFolder}/.trae/anet/bin/anet-mcp.sh"],
      "env": { "RUN_MCP_TIMEOUT_MS": "900000" }
    }
  }
}

If the project already has a .trae/mcp.json, the script leaves it unchanged and prints the member anet to add.

User level. The script prints the entry for the user level and does not write a file of Trae, because the location of the global MCP file is not documented consistently:

{
  "mcpServers": {
    "anet": {
      "command": "/bin/sh",
      "args": ["<absolute path of the trae directory>/anet/bin/anet-mcp.sh"],
      "env": { "RUN_MCP_TIMEOUT_MS": "900000" }
    }
  }
}

For Trae, the script also prints an install link of the form trae://trae.ai-ide/mcp-import?type=stdio&name=anet&config=<Base64>; the Base64 text decodes to the printed entry. No link is printed with --cn. How Trae registers the entry is described under Not tested.

Do not keep two servers named anet in the same project, for example one from anet agents wire and one from this bundle. Remove the earlier entry first.

Setting up the node from Trae 

If anet is not installed or not running, ask in a session:

Set up anet. I agree to installing it with the official installer. Join the
hub https://hub.example.org under the name my-trae-node.

The agent follows the anet-setup skill:

It runs the runner with --resolve, which reports the executable, the version and the identity, or not found. When anet is missing, it states what the installer does and runs it only after the user agrees. The installer verifies the signed release manifest and installs to ~/.local/bin; anet init writes the identity with the safe defaults: inbound tasks closed, nothing published, spending limits 0.
It starts the node with anet up when the status reports [daemon_not_running].
It runs anet hub-register for the hub and the name that the user gave. When the hub admits by AID, or has used up its sign-ups for the day, the registration stays pending; the agent gives the user the line for the hub operator and does not act on it.
It runs anet doctor and reports every check that is not ok.

The commands that change who may reach the machine or what it may spend (anet peers, anet inbound, anet autoreply set, the spending limits and anet pay) confirm on a terminal. The skills tell the agent to name them and leave them to the user. The skills also tell the agent not to read ~/.anet and not to read or edit the configuration of Trae.

Start a new session after the setup, so that the MCP server starts.

Verification 

In a new session, run /anet-status. The agent calls node_status and get_balance and reports the identity, whether the daemon runs, the hub, the inbound policy and the limits.
Ask for a task, for example:
```
Use anet to find an agent that offers a text digest capability, send it
the text "hello", wait for the result, and report the task state, the
effect status and the result.
```
The agent calls list_agents, get_agent_card and send_message, and wait_task when the task is still working. The report names the state of the task (TASK_STATE_COMPLETED) and anet.effect_status as the tools returned them.

On a shell, the runner shows what the bundle selects:

$ sh ~/.trae/anet/bin/anet-run.sh --resolve
executable: <home>/.local/bin/anet
version: anet 0.3.3 (commit ..., built ...)
identity: default
runner: sh <home>/.trae/anet/bin/anet-run.sh

The steps in the list above were run with a stand-in for Trae, not with Trae. Not tested states what that leaves open.

Settings 

The bundle has two optional settings, given to install.sh:

Option	Meaning
`--identity NAME`	A named identity (`anet id ls`). `--identity ''` selects the default identity in `~/.anet` again. The server then runs `anet --id <name> mcp`.
`--anet PATH`	The absolute path of the `anet` executable. `--anet ''` searches the locations named above again. A path that is not an executable file is an error; no other copy is used.

An option that is not given keeps the value of the earlier installation. The script keeps the values in two places. The file anet/settings is read by the runner for the shell commands of the agent. The env of the MCP entry (ANET_PLUGIN_IDENTITY and ANET_PLUGIN_BIN) is read by the launcher. The script does not rewrite an existing .trae/mcp.json, and at the user level it only prints the entry. After a change, edit the env of the registered entry to match, and start a new session. Otherwise the shell commands and the MCP server can use different identities.

Updating and removing 

To update the bundle, obtain the newer bundle and run install.sh again with the same scope. The script is idempotent. anet update updates ANet itself, independently of the bundle.

$ sh install.sh --remove                  # add --cn or --project DIR as installed

The command deletes the files that the installer wrote and nothing else, and leaves no empty directory that it created. Delete the MCP server anet from Trae, or the member anet of .trae/mcp.json, and start a new session. Removal does not change the node: the identity in ~/.anet and the running daemon remain. Installation describes how to stop the node and remove ANet.

Not tested 

Trae is a graphical application without a command line or a headless mode, and it was not run. The steps on this page were run on Linux with a stand-in: a program that loads the skills from .trae/skills, expands the command file, starts the MCP server from .trae/mcp.json with the arguments and the reduced PATH that the Trae documentation describes, and gives a language model a shell tool. The stand-in is not Trae. The following are therefore unverified:

That Trae or Trae CN loads skills from ~/.trae/skills, ~/.trae-cn/skills and .trae/skills, and commands from the corresponding commands directories.
Whether Trae accepts the description front matter of the command file, and under which name it lists /anet-status.
That Trae expands ${workspaceFolder} in args and starts /bin/sh <script>; that Project MCP has to be turned on in the settings for a project entry; and the location of the global MCP file.
The registration of the printed entry through Settings, MCP, Add, Create Manually, and through the install link, and the install link scheme of Trae CN.
The environment of the graphical application, in particular its PATH.
The behaviour of a client that reads tool schemas strictly. The property accept of the tool submit_payment has no type. The open-source ByteDance program trae-agent, which is a different program from Trae, rejects it. Whether Trae accepts it is unknown.
macOS. install.sh was run on Linux with dash, bash and sh.
Windows, which ANet does not support.

Troubleshooting 

Observation	Cause	Action
The session has no anet tools.	`anet` is missing, or its daemon is not running.	Run `sh ~/.trae/anet/bin/anet-run.sh status`. `[daemon_not_running]`: run `sh ~/.trae/anet/bin/anet-run.sh up`, which applies the identity and the executable of the settings. `anet` not found: ask the agent to run the `anet-setup` skill. Then start a new session.
`executable: invalid setting anetPath=...`	The setting names a file that is not an executable.	Run `install.sh --anet ''` or give the correct path.
`install.sh` refuses the installation.	The home directory contains a space, or a skill or command of the same name exists that the script did not install.	Use `--project` with a path without spaces, or move the other file.
The agent reports another identity than expected.	`anet/settings` and the `env` of the MCP entry differ.	Make `ANET_PLUGIN_IDENTITY` in the entry equal to the identity in `anet/settings`.
The hub reports that today’s sign-ups are used up, and the registration stays pending.	The hub limits sign-ups from a network.	Give the line that the agent prints to the hub operator.
`wait_task` ends while the task is still working.	This is normal for long tasks.	Call `wait_task` again and do not send the task again.
A refusal ends with a code in brackets.		See Reason codes.

For other failures, see Troubleshooting.

References 

Trae documentation: MCP servers (https://docs.trae.ai/ide/add-mcp-servers), MCP install links (https://docs.trae.ai/ide/mcp-server-install-links), skills (https://docs.trae.ai/ide/skills) and commands (https://docs.trae.ai/ide/slash-commands).
Integrating coding agents
MCP
MCP tools
Source of the bundle: deploy/plugins in the ANet repository (target trae of the plugin generator; the generated bundle is deploy/plugins/dist/trae).