Reference

Use this page when you need exact tool names, permissions, lifecycle states, or trace fields.

Memory MCP tools

These tools let an AI client discover available tools, load governed team context, and work with team memory without bypassing Wato governance.

Discovery and agent context

Tool	What it does	When to use it
`wato_get_usage_guide`	Returns the current team, recommended first calls, memory permissions, and Wato best practices.	Call first when working through a Wato MCP server.
`mesh_search_tools`	Searches MCP tools visible to the current team by name, connector, description, regex, and optionally schema.	When checking what tools are currently available to the team.
`mesh_get_tool_schemas`	Returns the complete input schemas for specific team-visible connector tools.	When you need exact arguments before calling a tool.
`mesh_execute_tool`	Executes one team-visible connector tool found with `mesh_search_tools`, through the governed gateway.	To actually run an approved connector tool.
`wato_search_agent_context`	Searches rules, skills, plugins, and authorized memory summaries in the current Wato agent context package.	Before acting when team-specific context may matter.
`wato_list_skills`	Lists published portable Wato skills available to the current team.	When discovering reusable team workflows.
`wato_get_skill`	Fetches one published Wato skill by id or slug as Markdown.	After finding a skill that should guide the task.

Memory read and search

Tool	What it does	When to use it
`mesh_search_memory`	Searches Markdown files in the current team's reviewed memory wiki.	When looking for exact text, headings, keywords, references, or relevant files.
`mesh_list_memory_files`	Lists files and folders in the current team's memory wiki.	When browsing the memory structure.
`mesh_read_memory_file`	Reads a specific Markdown memory file. Defaults to reviewed main memory; can read the current user's draft branch when requested.	When the agent knows the file path and needs exact Markdown.

Memory draft writes

Tool	What it does	When to use it
`mesh_patch_memory_file`	Applies an exact find-and-replace edit to a Markdown file in the current user's draft branch.	For small edits to an existing memory page.
`mesh_write_memory_file`	Writes the full contents of a Markdown file in the current user's draft branch.	When creating a new page or replacing a full page.
`mesh_update_memory_branch_from_main`	Merges reviewed main memory into the current user's unsubmitted draft branch.	Before continuing draft work if reviewed memory may have changed.

Memory review and history

Tool	What it does	When to use it
`mesh_submit_memory_branch_for_review`	Submits the current user's draft branch as a memory proposal. Calling it again after more edits updates the existing pending proposal snapshot.	After draft changes are ready for review.
`mesh_list_memory_proposals`	Lists pending memory proposals for the current team.	When a reviewer or agent needs to see what is waiting for review.
`mesh_get_memory_proposal`	Opens one pending memory proposal and returns metadata and diff.	To inspect a proposed change before review or approval.
`mesh_refresh_memory_proposal`	Refreshes a pending proposal from reviewed main memory.	Before merge or review when the proposal may be stale.
`mesh_merge_memory_proposal`	Merges one clean pending proposal into reviewed memory, if the caller has merge access.	Only when MCP merge access is available and the proposal is clean.
`mesh_list_memory_changes`	Lists recent memory changes and proposal history with metadata and touched files.	For audit/history or to find a change ID.
`mesh_get_memory_change`	Fetches one memory change, optionally scoped to one file, with before/after Markdown and compact diff.	After `mesh_list_memory_changes` when you need the actual diff.

Skills MCP tools

Read and manage skills — reusable units of capability — over MCP.

Tool	What it does	When to use it
`wato_list_skills`	Lists published team skills (pass `includeDrafts=true` for drafts and proposed).	When discovering reusable team workflows.
`wato_get_skill`	Fetches one skill's current `SKILL.md` by id/slug, plus a listing of its bundled files.	After finding a skill that should guide the task.
`wato_get_skill_file`	Fetches one bundled file (script, reference doc) by relative path.	After `wato_get_skill`, to load only the files the task needs.
`wato_search_agent_context`	Keyword-searches published skills, plugins, and structured memory documents.	Before acting, to find relevant skills or context.
`wato_save_skill_draft`	Creates or updates a skill draft from full `SKILL.md`; can set bundled files and submit for review.	When authoring or editing a skill over MCP.
`wato_publish_skill`	Publishes a skill by id/slug.	To make a reviewed skill live (requires `skills:publish` or team admin).

Automation MCP tools

Build and refine automations from a connected agent, over MCP. These create and edit drafts only — publishing stays gated in the app.

Tool	What it does	When to use it
`wato_create_automation_from_chat`	Distills the connector actions taken in the current conversation (`observedToolCalls`) plus a plain-English `description` into a reusable automation draft, and returns a review link.	After doing a task by hand with connector tools, to turn it into an automation.
`wato_get_automation_draft`	Reads a draft's steps in flow order; for each connector-tool step it tags every field as `value` (a literal), `wire` (a `{{previous.x}}` reference), or `unset`.	Before editing, to see the exact steps and fields.
`wato_edit_automation_draft`	Applies a plain-English `instruction` to a draft via a deterministic operation engine — change a tool field, wire a field to a prior step's output, adjust the schedule, rewrite an agent prompt, rename, or add/remove a step.	To refine a draft without regenerating the canvas.

Creating or editing a draft requires team membership; it never publishes a live automation. Use the returned step numbers from wato_get_automation_draft to target edits precisely.

Live artifact MCP tools

These tools help agents create live artifacts without putting connector credentials, provider tokens, or broad MCP access into browser code.

Tool	What it does	When to use it
`wato_get_live_artifact_primitives`	Returns the current live artifact authoring contract, including the SDK script, HTML declaration pattern, binding expectations, and common runtime states.	Before creating or updating an artifact that needs live data.
`wato_bind_dashboard_view`	Scans generated HTML for declared live calls and binds approved calls to a server-side live view policy.	For local dashboards or custom-hosted artifacts before testing live connector calls.
`mesh_search_tools`	Searches the connector tools visible to the current team.	Before writing `data-wato-call` so the artifact declares real approved connector tools.

Dashboard runtime concepts

Live artifacts use a small runtime model so browser pages can refresh from approved systems while Wato keeps sensitive access server-side.

Concept	Meaning
Live artifact	A hosted HTML artifact that can request fresh data at runtime through Wato.
Live view	The server-side policy that defines which declared connector calls an artifact may make.
`data-wato-call`	An HTML attribute that declares a requested connector call, such as a team-approved search or list operation.
`data-wato-id`	A stable identifier for one declared live call in the artifact.
`data-wato-defaults`	Optional fixed defaults for a declared call. Use for safe defaults, not secrets or broad permissions.
Dashboard SDK	The browser SDK that initializes the live view session and sends approved calls back through Wato.
Allowed origin	An exact browser origin allowed to run the live view, such as a hosted artifact domain or a `localhost` origin used during development.
Live data team	The Wato team whose approved connector policy powers the artifact's live data.
Runtime session	A short-lived browser session scoped to one live view and its approved calls.
Connector call	A request routed through Wato to a team-approved connector tool. The browser does not receive provider credentials.

Live artifact HTML should declare what it needs, not grant itself permissions. Wato evaluates the declarations against the current team's approved connector catalog, creates or updates the live view policy, and enforces that policy at runtime.

Permission model

Wato separates workspace access, team membership, MCP access, and review permissions.

Permission area	What it controls
Workspace access	Whether a user can sign in to the Wato workspace.
Team membership	Which team memory, connectors, traces, and context a user can access.
Team role	Whether a user is a team member or team admin.
Connector access	Which MCP connectors a team can use.
Tool access	Which individual MCP tools are allowed for a team or role.
Review access	Who can review and approve memory proposals.

A user can belong to the workspace without automatically seeing every team's private memory. Team membership controls team-level access.

Memory review lifecycle

Memory changes move through a review flow before they become trusted context.

State	Meaning
Draft	A user or agent has saved changes, but they have not been submitted for review.
Submitted	The draft has been submitted as a memory proposal.
Pending review	A reviewer can inspect the proposed changes.
Ready to merge	Wato has checked that the proposal can be merged cleanly.
Has conflicts	The proposal cannot be merged until conflicts are resolved.
Merged	The proposal was approved and is now trusted team memory.

Typical flow:

A user or agent writes a memory change.
Wato saves the change as a draft.
The draft is submitted for review.
A reviewer inspects the proposal.
If the proposal is ready, the reviewer merges it.
The change becomes trusted team memory.

Trace fields

Wato records traces for MCP activity so teams can inspect what happened.

Field	Meaning
Tool called	The MCP tool that was used.
User	The user or agent identity associated with the call.
Team	The team context the call ran under.
Input	The request sent to the tool.
Result	Whether the call succeeded or failed.
Timestamp	When the call happened.

Traces help with debugging, compliance, security review, usage monitoring, and understanding agent behavior.

Reference

On this page