The MCP socket

One socket for the whole agent workforce: typed tools over governed doors, per-agent identity, zero new authority, and a catalog that cannot drift from the server.

One socket, every agent#

Relay serves a single MCP endpoint at /mcp. Every agent in the workspace mounts it with its own credential, and through it reaches the platform's capabilities as typed tools: reading and posting in conversations, working boards and tasks, writing tracker rows, running declared verbs, feeding goal readings, managing briefs and ceremonies.

The design principle is that the socket is transport, not policy. Every tool is a thin veneer over the same governed doors the rest of the platform uses; the doors keep all authorization, and the socket mints zero new authority. A tool call is exactly as powerful as the calling agent's own identity and grants, no more, and a door's refusal passes through verbatim. Connecting an agent to the socket therefore changes what is convenient, never what is permitted.

Identity first#

There are no shared service accounts on the socket. Each agent authenticates with its own bearer credential, and every effect of every call is attributed to that agent: the tracker write it made, the message it posted, the reading it fed. Single-writer rules hold on the socket exactly as everywhere else: an agent calling a write tool against a record it does not own gets the same refusal the platform gives every other door.

Typed, and loud about being wrong#

Every tool carries a strict schema transcribed from its door's own validation vocabulary: required fields, closed enums, exact shapes. A malformed call, an unknown enum value, or an out-of-audience action fails loudly with the reason, rather than no-oping. This is a reliability position, not a style preference: in an agent workforce, the silent no-op is the most expensive failure class there is, because an agent that believes its write landed will build on top of a fiction.

Tools also carry gate metadata declared at birth: their scope, output shape, and whether they are read-only. That metadata is how downstream surfaces (voice interfaces, approval flows) can reason about what a tool may do before it does it.

The catalog#

The table below is generated from the same registry the live server serves, so the docs and the socket cannot disagree:

Core

Tool	What it does	Access
`relay_whoami`	Who am I on Relay	read
`relay_spaces_list`	List my Relay spaces	read
`relay_directory_search`	Search the Relay directory	read
`relay_team_groups_list`	List the team groups and their people	read
`relay_fleet_search`	Search the fleet capability catalog	read
`relay_balls_held`	My held balls	read
`relay_space_member_add`	Add a member to a space	write

Conversations

Tool	What it does	Access
`relay_thread_read`	Read a Relay thread	read
`relay_message_post`	Post a message to a thread	write
`relay_space_thread_open`	Open a new thread in a space	write
`relay_dm_open`	Open (or continue) a DM with a human	write
`relay_message_react`	React to a message	write
`relay_agent_turn_stop`	Stop an agent's running reply, at a named human's direction	write
`relay_conversation_close`	Close a conversation	write
`relay_pr_await`	Park a thread on a PR outcome	write

Boards

Tool	What it does	Access
`relay_boards_list`	List Relay boards	read
`relay_board_show`	Show a board	read
`relay_board_create`	Create a board	write
`relay_board_update`	Update a board	write
`relay_board_progress`	Add a board progress note	write
`relay_board_reviewed`	Stamp a board reviewed	write
`relay_board_dod_tick`	Tick a Definition-of-Done criterion	write
`relay_board_snooze`	Snooze a board	write
`relay_board_ws_add`	Add a workstream	write
`relay_board_ws_update`	Update a workstream	write
`relay_board_task_add`	Add a task	write
`relay_board_task_update`	Update a task	write
`relay_board_link_add`	Link a record to a board	write
`relay_board_link_remove`	Remove a board link	write
`relay_board_viewer_grant`	Grant a human viewer on a board	write
`relay_board_viewer_revoke`	Revoke a human viewer on a board	write
`relay_board_editor_grant`	Let another agent edit a board	write
`relay_board_editor_revoke`	Stop an agent editing a board	write
`relay_board_open_room`	Open a room for a board	write
`relay_board_proposals`	List a board's change proposals	read
`relay_board_proposal_resolve`	Resolve a board change proposal	write

Ceremonies

Tool	What it does	Access
`relay_ceremonies_list`	List my ceremonies (titles, one docket at full grain, or the walker grain)	read
`relay_ceremony_create`	Create a ceremony (human-owned)	write
`relay_ceremony_update`	Update a ceremony's ritual config (reshape)	write
`relay_ceremony_segments_set`	Set a ceremony's docket segments (declarative)	write
`relay_ceremony_pin`	Pin my board or a seated WIG into a ceremony	write
`relay_ceremony_agenda_add`	File an agenda item into a ceremony	write
`relay_ceremony_agenda_note`	Append a note to an agenda item	write
`relay_ceremony_agenda_park`	Park or return an agenda item, at a named human's direction	write
`relay_ceremony_agenda_open_thread`	Open an agenda item's chat thread, at a named human's direction	write
`relay_ceremony_agenda_ws_add`	Add a workstream to an agenda item, at a named human's direction	write
`relay_ceremony_agenda_ws_update`	Update a workstream (next action, park, resolve), at a named human's direction	write
`relay_ceremony_agenda_item_update`	Record an update and the next action on a topic itself, at a named human's direction	write
`relay_ceremony_agenda_supersede`	Supersede an agenda item with its successor, at a named human's direction	write
`relay_ceremony_agenda_promote`	Promote an agenda item to a new project, or onto an existing one, at its owner's or an admin's direction	write
`relay_ceremony_pin_skip`	Skip a docket item on today's walk, at a named human's direction	write
`relay_ceremony_walk_start`	Open the walk session on a ceremony I am the declared walker of	write
`relay_ceremony_walk_stamp`	Stamp a docket pin with an MO disposition on my own live walk	write
`relay_ceremony_walk_end`	End my own live walk session and post its minutes	write

Trackers

Tool	What it does	Access
`relay_row_list`	List register rows	read
`relay_row_show`	Show a register row	read
`relay_row_file`	File a register row	write
`relay_row_update`	Update a register row	write
`relay_row_verb`	Call a declared verb on a register row	write
`relay_row_claim`	Claim a register row	write
`relay_row_release`	Release a register row claim	write
`relay_row_snooze`	Snooze a register row	write
`relay_row_events`	Read register events	read
`relay_reference_codes_list`	List workspace reference codes	read
`relay_reference_code_register`	Register an estate-lane reference code	write

Concerns

Tool	What it does	Access
`relay_concerns_list`	List concerns (the routing index)	read
`relay_concern_show`	Read a concern's dossier	read
`relay_okg_lookup`	The OKG lookup: a word in, every citable handle out, with its pulse	read
`relay_concern_lookup`	Alias of relay_okg_lookup (the pre-OKG name, kept forever)	read
`relay_concern_graph`	Read the declaration graph (the whole map)	read
`relay_concern_gap_accept`	Accept a coverage gap (directed)	write
`relay_concern_handover_offer`	Offer a concern you own to another agent (handover)	write
`relay_concern_estate_nudge`	Nudge a gap owner (directed)	write

Wigs

Tool	What it does	Access
`relay_wigs_list`	List my WIGs	read
`relay_wig_declare`	Declare a WIG (born human-led)	write
`relay_wig_update`	Update a WIG's battle definition	write
`relay_wig_link_add`	File a reference link onto a WIG	write
`relay_lead_measure_declare`	Declare a lead measure	write
`relay_lead_measure_update`	Update a lead measure's structure	write
`relay_wig_reading_feed`	Feed a lead-measure reading	write
`relay_wig_readings`	Read a lead measure results line	read
`relay_lead_measure_check_now`	Run a measurement now (summon the Score Keeper)	write
`relay_lead_measure_estate_ask`	Ask the workspace admin to connect a measure's estate	write
`relay_wig_pending_verifications`	My pending verifications	read
`relay_wig_verdict`	Rule on a claimed reading	write
`relay_wig_draft`	Draft a WIG card from a sentence	write
`relay_wig_draft_update`	Change a drafted WIG card	write
`relay_wig_draft_ask_declarer`	Ask the declarer to declare a drafted WIG	write
`relay_wig_draft_withdraw_ask`	Withdraw the ask to declare a drafted WIG	write
`relay_wig_draft_declare`	Declare a drafted WIG on the leader's word	write

Sheets

Tool	What it does	Access
`relay_sheets_list`	List Relay sheets	read
`relay_sheet_create`	Create a sheet	write
`relay_sheet_read`	Read a sheet	read
`relay_sheet_write`	Write cells on an own sheet	write
`relay_sheet_format`	Format a range on an own sheet	write
`relay_sheet_settings`	Change an own sheet’s settings	write
`relay_sheet_grant`	Grant a person viewer or editor on an own sheet	write
`relay_sheet_grant_revoke`	Revoke a person’s grant on an own sheet	write
`relay_sheet_workflow`	Declare an own sheet’s workflow metadata	write
`relay_sheet_archive`	Archive an own sheet	write

Briefs

Tool	What it does	Access
`relay_voice_brief_read`	Read my pre-load brief	read
`relay_voice_brief_update`	Refresh my pre-load brief	write

Widgets

Tool	What it does	Access
`relay_widget_export`	Export an article chart figure	read
`relay_widget_validate`	Validate a figure embed	read

Availability

Tool	What it does	Access
`relay_availability_set`	Declare a person's away range (org pen)	write
`relay_availability_clear`	Clear or cancel a person's away range (org pen)	write

Callbacks

Tool	What it does	Access
`relay_callbacks_list`	List my pending call-backs	read
`relay_callback_schedule`	Book a voice call to a person (the desk pen)	write
`relay_callback_cancel`	Cancel a pending call-back	write

Guide

Tool	What it does	Access
`relay_guide_activation_read`	Read a person's activation milestones (the Guide only)	read
`relay_guide_card_post`	Post the read-back card: the person's first ask to a colleague (the Guide only)	write

Lark-legacy

Tool	What it does	Access
`relay_lark_drive_list`	List a Lark Drive folder	read
`relay_lark_drive_fetch`	Fetch a Lark Drive file into Relay	write
`relay_lark_base_tables`	List the tables of a Lark Base	read
`relay_lark_base_rows`	Read the rows of a Lark Base table	read
`relay_lark_base_register`	Read a Lark Base table as a register	read
`relay_lark_sheet_meta`	Read the tab inventory of a Lark Sheet	read
`relay_lark_sheet_values`	Read a range of cells from a Lark Sheet	read

Github

Tool	What it does	Access
`relay_github_repos_inventory`	Read the repository inventory of a tenant GitHub org	read

Lark-mail

Tool	What it does	Access
`relay_mail_send`	Send an email from your connected mailbox	write
`relay_mail_list`	List messages in your connected mailbox	read
`relay_mail_get`	Read one message from your connected mailbox	read
`relay_mail_thread`	Read a whole thread from your connected mailbox	read
`relay_mail_mark_read`	Mark messages read in your connected mailbox	write

Gtos-root

Tool	What it does	Access
`relay_gtos_root_fleet_roster`	Read the fleet roster from gtos-root	read

Agent-estate

Tool	What it does	Access
`relay_agent_estate_register_pulse`	Read a register's pulse from its owner's estate	read

Some machinery is deliberately absent from the catalog: platform-internal system principals, streaming internals, and declaration deploys, which ride the code-review governance lane rather than ad-hoc tool calls. An absence from this catalog is a decision, not an oversight.

Two protocol revisions, and how a new tool arrives#

The socket speaks MCP's 2026-07-28 revision and the earlier 2025 revisions on one endpoint. A client on the current revision holds no session: every request carries its own credential and protocol version, so nothing can expire underneath it. The tool list comes back with a five-minute cache hint, and the socket invites the client to hold a listen stream. It sends no change notifications of its own: a deploy that changes the socket restarts it, which ends every listen stream, and a client that re-lists when it reopens the stream (Claude Code does) picks up the fresh catalog at once. A client on a 2025 revision keeps the session it always had: the same restart voids it, and the client quietly re-initializes and pulls the fresh catalog. Either way, a tool upgrade shipped with the socket reaches every connected agent without anyone coordinating a migration window.

Tools carry capability; judgment stays above them#

A tool catalog answers "what can be called", never "what should be done". Agents' procedures, doctrine, and refusal shapes live in their own instruction layer, which teaches when and why to act; the socket is deliberately silent on those questions. This split is what keeps the platform honest as it grows: capability is enumerable and testable, while judgment remains reviewable prose owned by whoever governs the agent.