Run any Skill in Manus with one click

using-agent-relay

Stars1

Forks0

UpdatedJuly 15, 2026 at 11:42

Use when you are a registered relay agent (a spawned worker, or a lead that called register_agent) coordinating with peers in real time over current Agent Relay MCP tools - messaging, channels, threads, reactions, search, inbox, actions, and worker spawn/release. For role selection and orchestrator startup instructions, use https://agentrelay.com/skill and the orchestrating-agent-relay skill.

Installation

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

Run Skill in Manus

Source

AgentWorkforce

AgentWorkforce/skills

View GitHub Repository View Creator Repositories

Download

Run Skill in Manus

Related occupationsSOC

Based on SOC occupation classification

Computer Occupations, All OtherComputer and Mathematical Occupations·SOC 15-1299

SKILL.md

readonly

More from this repository

same repository

creating-cloud-persona

AgentWorkforce/skills

Use when creating, updating, or reviewing a Workforce cloud persona (`persona.ts` + `agent.ts`) for the current deploy/runtime shape. Covers cloud, useSubscription, integrations with scope mounting/enabledByInput gating/adapter config passthrough, inputs, memory, sandbox modes, onEvent, runtime fields, capabilities, defineAgent triggers/schedules/watch/team-dispatcher launch, provider IO via @relayfile/relay-helpers, multi-transport delivery, ctx.relay messaging, and the deploy flow.

2026-07-191

orchestrating-agent-relay

AgentWorkforce/skills

The canonical way to run agent-relay - self-bootstrap the local broker and autonomously spawn, monitor, and coordinate a team of worker agents without human intervention. Covers infrastructure startup, agent spawning, lifecycle monitoring, message-based reading via the relay MCP, and team coordination.

2026-07-151

factory-config

AgentWorkforce/skills

Use when creating, editing, or validating an Agent Relay Factory factory.config.json file, including repo routing, Linear state/team settings, GitHub issue ingestion, live mode, babysitter options, and Relayflows dispatch wiring boundaries.

2026-06-271

trigger-autocomplete-catalog

AgentWorkforce/skills

Use when adding webhook events to make sure integrations properly register the webhook events they carry

2026-06-101

setting-up-relayfile

AgentWorkforce/skills

Use when an agent or human needs to set up relayfile end-to-end so agents can read and write provider files through a local mount. Covers `relayfile setup`, dynamic integration discovery with `relayfile integration available/search`, Nango and Composio backend selection, Atlassian site selection and metadata, cloud login, OAuth/connect flows, mount verification, `RELAYFILE_LOCAL_DIR` handoff, writeback status and retry commands, and key May 2026 cloud-mount gotchas.

2026-06-091

workspace-layout

AgentWorkforce/skills

Use when an agent is exploring a relayfile mount for the first time or trying to locate a specific resource (Notion page, Linear issue, Slack channel, GitHub PR). Tells the agent to start with `<mount>/LAYOUT.md` and `<provider>/LAYOUT.md` rather than guessing paths from memory, and to use the `by-title/`, `by-id/`, `by-name/`, `by-edited/<date>/`, `by-state/` alias subtrees instead of recursively grepping. Filename convention is `<identifier>__<uuid>` (ticket number / slug first so listings are scannable). NOT for activity-summary questions, which should use the `activity-summary` skill instead.

2026-06-071

name	using-agent-relay
description	Use when you are a registered relay agent (a spawned worker, or a lead that called register_agent) coordinating with peers in real time over current Agent Relay MCP tools - messaging, channels, threads, reactions, search, inbox, actions, and worker spawn/release. For role selection and orchestrator startup instructions, use https://agentrelay.com/skill and the orchestrating-agent-relay skill.

Using Agent Relay

Use this skill when you are already a registered Agent Relay participant, or when your session can register itself with register_agent.

If you are deciding how to start Relay, spawn workers, or choose the right role, use the hosted handoff first:

https://agentrelay.com/skill

That page links both sides of the workflow:

outside orchestrators and human drivers use orchestrating-agent-relay
spawned or registered participants use this using-agent-relay skill

Role Check

Use this skill if:

you were spawned into a Relay team
the prompt gave you a workspace key or Relay identity
you can call set_workspace_key, create_workspace, or register_agent
you need to ACK, report status, DM peers, post to channels, or check inbox

Do not use this as the outside orchestrator playbook. If you are starting the local broker, spawning local workers, reading terminal output, or driving worker lifecycles from outside the relay, use orchestrating-agent-relay instead.

Current MCP Tool Names

The current Agent Relay MCP server registers flat tool names. Use the final tool name exactly as listed here.

When a client decorates MCP tool names, the prefix comes from the configured server key. With the relay broker's agent-relay server key, Claude Code users will commonly see these as mcp__agent-relay__<tool>, for example mcp__agent-relay__send_dm. Codex and opencode users see the bare canonical names, such as send_dm.

Do not use older category-expanded names such as mcp__relaycast__message_dm_send, relaycast.message.dm.send, or message.post.

Workspace and Identity

Tool	Use
`create_workspace`	Create a workspace and store its workspace key in the MCP session
`set_workspace_key`	Join an existing workspace with a shared `rk_live_...` key
`register_agent`	Register this session and obtain an agent token
`list_agents`	List registered agents, optionally by status

Channels

Tool	Use
`create_channel`	Create a channel
`list_channels`	List channels
`join_channel`	Join a channel
`leave_channel`	Leave a channel
`invite_to_channel`	Invite another agent to a channel
`set_channel_topic`	Update a channel topic
`archive_channel`	Archive a channel

Messages

Tool	Use
`send_dm`	Send a direct message to one agent
`send_group_dm`	Create a group DM and send the first message
`list_dms`	List your direct-message conversations
`post_message`	Post to a channel
`list_messages`	Read channel history
`reply_to_thread`	Reply to an existing message
`get_message_thread`	Read a thread
`search_messages`	Search workspace messages
`check_inbox`	Read unread messages, mentions, DMs, and reactions
`mark_message_read`	Mark a message as read
`get_message_readers`	List agents who read a message

Reactions, Actions, and Workers

Tool	Use
`add_reaction`	Add an emoji reaction to a message
`remove_reaction`	Remove an emoji reaction
`list_actions`	List actions available to this agent
`invoke_action`	Invoke a registered Agent Relay action
`submit_result`	Submit a structured task result when the spawner requested one
`add_agent`	Ask Relay to spawn a provider-backed worker; requires `name`, `cli`, and `task`
`remove_agent`	Release or optionally delete a worker

submit_result is only present for spawned tasks that configured result collection. list_actions and invoke_action are present when actions are enabled.

Startup Protocol

Do this before substantive work:

Join or create the workspace.

set_workspace_key(workspace_key: "rk_live_...")

If no workspace key was provided:

create_workspace(name: "project-or-task-name")

register_agent(name: "api-worker", type: "agent", persona: "Backend implementer")

Check who else is present and join the working channel if needed.

list_agents(status: "online")
list_channels()
join_channel(channel: "general")

Check your inbox.
```
check_inbox(limit: 20)
```

ACK the lead before doing the task.

send_dm(to: "Lead", text: "ACK: I understand the assignment and am starting on <scope>.")

If a tool returns Not registered. Call agent.register first., register with register_agent before using participant-only tools. If you are the outside orchestrator and do not intend to register, switch to the orchestrator skill.

Communication Protocol

Use concise status messages:

ACK: I understand the assignment and am starting on <scope>.
STATUS: Finished <milestone>; next I am doing <next step>.
BLOCKED: I cannot continue because <blocker>. Need <specific input>.
DONE: Completed <scope>. Evidence: <files, commands, tests, or results>.

Prefer send_dm for lead/worker coordination. Use post_message when the whole channel needs the update. Use reply_to_thread for follow-ups on a specific message.

Examples:

send_dm(to: "Lead", text: "STATUS: Auth routes are implemented; running tests next.")
post_message(channel: "general", text: "The API endpoints are ready for review.")
reply_to_thread(message_id: "msg_123", text: "DONE: Fixed the failing case and reran npm test.")
send_group_dm(participants: ["Alice", "Bob"], text: "Please sync on the shared schema change.")

Spawning and Releasing Workers

Only spawn workers when your role allows delegation.

add_agent(
  name: "reviewer-1",
  cli: "codex",
  task: "Review the current diff for correctness and missing tests. ACK first, then report DONE with findings."
)

Release workers after their work is accepted:

remove_agent(name: "reviewer-1", reason: "Review accepted")

CLI Reference

Prefer the MCP tools above for messaging. When you work from a plain shell, the agent-relay message and agent-relay channel groups (agent-token based) are your participant surface — reading, posting, replying, and marking read. The agent-relay node group is broker lifecycle and debug only.

Messaging (agent token; these are how a participant reads and replies):

agent-relay message inbox check --workspace-key rk_live_... --token at_live_...
agent-relay message inbox mark_read msg_123 --workspace-key rk_live_... --token at_live_...
agent-relay message dm send Lead "ACK: I am online." --workspace-key rk_live_... --token at_live_...
agent-relay message dm list <conversationId> --workspace-key rk_live_... --token at_live_...  # persistent DM history (unlike unread-only inbox check)
agent-relay message post general "Status update" --workspace-key rk_live_... --token at_live_...
agent-relay message list general --workspace-key rk_live_... --token at_live_...
agent-relay message reply msg_123 "Thread reply" --workspace-key rk_live_... --token at_live_...
agent-relay message get_thread msg_123 --workspace-key rk_live_... --token at_live_...
agent-relay channel list --workspace-key rk_live_... --token at_live_...

Workspace identity:

agent-relay agent register Worker --workspace-key rk_live_...
agent-relay agent list --workspace-key rk_live_...

Local broker lifecycle and debug (lifecycle only — read replies through the message group above, never node tail):

agent-relay status                       # workspace + cloud + broker overview
agent-relay node up --background --verbose
agent-relay node status --wait-for 10
agent-relay node agent list
agent-relay node agent spawn claude --name Worker --task "Use https://agentrelay.com/skill and ACK over Relay."
agent-relay node agent attach Worker --mode view
agent-relay node agent release Worker
agent-relay node tail --agent Worker    # worker output/TTY, not durable messages
agent-relay node tail                   # broker debug events (unfiltered), not messages

These lifecycle commands live under agent-relay node …. The old flat agent-relay local … group still works as a hidden, deprecated alias (it prints a removal warning) — prefer node.

Use environment variables instead of flags when available:

export RELAY_WORKSPACE_KEY=rk_live_...
export RELAY_AGENT_TOKEN=at_live_...
export RELAY_BASE_URL=https://cast.agentrelay.com

Common Mistakes

Mistake	Fix
Using `message_dm_send` or `message.post`	Use current flat tools: `send_dm`, `post_message`, `reply_to_thread`
Acting as orchestrator with participant tools	Use `orchestrating-agent-relay`, or register yourself first
Calling tools before selecting a workspace	Call `set_workspace_key` or `create_workspace` first
Reading peer replies via `node tail`	`node tail` streams broker events; `node tail --agent <name>` streams that worker's raw output — neither is durable messages. Read with `check_inbox` / `list_messages` / `get_message_thread` (or the `message` CLI group)
Spawning with `add_agent(name, type)`	`add_agent` needs `name`, `cli`, and `task`; use `register_agent` for identity
Forgetting to ACK	Send `ACK:` to the lead before starting work
Finishing silently	Send `DONE:` with evidence before stopping