MeshPlugin gives AI agents a clean, consistent API for navigating and modifying the mesh data graph. Every path argument supports the @ shorthand prefix — @graph/org1 resolves to graph/org1.

Six tools give AI agents complete read, search, display, and write access to the mesh data graph.

Get

Reads a node from the mesh and returns its JSON representation.

Single node

Get('@path')

Returns the full MeshNode JSON, including all properties and the typed content object.

Children list

Get('@path/*')

Returns a JSON array of direct children, each with { path, name, nodeType, icon }. Useful for browsing a namespace before diving deeper.

Unified Path prefixes

Get understands reserved path prefixes that expose type metadata alongside node data:

These schema prefixes work on any address — not just NodeType paths. Use them before creating or updating a node to discover the exact fields expected.

For the complete Unified Path reference:

Examples

Get('@graph/org1')                      // Read a specific organisation node
Get('@NodeType/*')                      // List all available node types
Get('@ACME/ProductLaunch/schema/')      // Content schema for ProductLaunch
Get('@ACME/ProductLaunch/model/')       // Full data model

Search

Searches the mesh using a GitHub-style query syntax. Returns a JSON array of up to 50 matching nodes.

Parameters

Common patterns

Search('nodeType:Agent')                                         // All agents
Search('namespace:ACME')                                         // Direct children of ACME
Search('path:ACME scope:descendants')                            // Everything under ACME recursively
Search('namespace:Doc scope:descendants')                        // Browse all documentation
Search('name:*sales* nodeType:Organization sort:name')           // Complex filtered query
Search('laptop', '@graph')                                       // Free-text search within graph

Full query syntax

NavigateTo

Opens a node's visual layout area inside the chat UI — the mesh's equivalent of "Show me this page."

CRITICAL: When a user asks to "show", "display", or "view" something, always prefer NavigateTo over dumping raw JSON. Call it, then keep your text response short — just confirm what was displayed.

Workflow

1. Call NavigateTo('@path').
2. Respond with one sentence — e.g., "Here's the organisation chart."

Example

User: "Show me the organisation chart." Action: NavigateTo('@ACME/Organization') Response: "Here's the organisation chart."

RenderArea

MCP surface only. RenderArea is declared on McpMeshPlugin, not on the in-portal MeshPlugin — so it is available to an agent connected over MCP, and not in the tool set an in-portal agent round receives. In-portal, use NavigateTo or Get('.../area/Name').

Returns a live, interactive layout area as an MCP-UI embedded resource.

Hosts that support MCP-UI (Claude.ai web/desktop, ChatGPT Apps) render it inline as an iframe widget. Text-only hosts (such as the Claude Code CLI) receive a fallback URL instead.

Parameters

Choosing the right display tool

Example

RenderArea('@Systemorph/FutuRe/EuropeRe/AcmeSubmission2025', 'Triangle')

Create

Creates and persists a new node in the mesh. The node is validated before it is saved.

Parameter

node (string, required) — A JSON string representing a MeshNode object.

MeshNode schema

The node's path is derived as {namespace}/{id}, or simply {id} for root-level nodes.

Critical rules

id must be a simple slug — no slashes. Use only letters, numbers, and hyphens.

Correct: "id": "PricingTool", "namespace": "User/rbuergi" Wrong: "id": "User/rbuergi/PricingTool", "namespace": ""

• name must be a clear, descriptive title — not just the first few words of the content body.
• icon should be an inline SVG — a small, clean 24×24 image that visually represents the node's purpose. Use simple shapes and colours that match the content theme.
• 🚨 content field names must match the registered type EXACTLY — unknown fields are silently dropped. Deserialization ignores members it doesn't recognise (no error), so a mistyped or invented field name produces a node that reports created successfully but renders without values in every typed view — far harder to notice than a failure. Where the content is polymorphic, include the $type discriminator the schema shows. Two habits prevent it:
  • Copy a real node as a form template. Before creating instances of a type you have not written before, Get one existing node of that type and mirror its content structure — exact field names, reference-field shapes, and any $type — rather than guessing from the schema alone.
  • Read back after a batch. After creating a batch, Get one node per type and confirm the $type, the reference fields, and the value fields actually persisted. (Do not verify through Search immediately — the index is eventually consistent and can return zero right after a write; Get the exact path instead.)

Discovering the content schema

Before creating a node, check what content fields the target type expects:

Get('@Cornerstone/schema/')             // Schema for nodes in the Cornerstone namespace
Get('@path/schema/TypeName')            // Schema for a specific named type
Get('@path/model/')                     // Full data model with all registered types

Workflow

1. Find an existing node of the same type, or navigate to the target namespace.
2. Retrieve its content schema: Get('@path/schema/').
3. Build the MeshNode JSON with all required fields.
4. Call Create with the JSON string.

Example

Create('{"id": "NewProject", "namespace": "ACME", "name": "New Project", "nodeType": "Project", "content": {"status": "Active"}}')

Update

Replaces one or more existing nodes with new data. The entire node is replaced — this is not a merge/patch operation.

Prefer Patch or EditContent for anything small. Both are part of the same tool set:

• Patch(path, fields) — partial update of one node. Only the keys you send change; content deep-merges per RFC 7396, so you can set a single content field without resending the rest. A null member deletes that one key; setting the whole content to null is rejected.
• EditContent(path, oldText, newText, replaceAll) — anchored text edit inside a Markdown body or Code source. Send just the snippet plus enough surrounding context to be unique, instead of pushing a whole document through Update. Fails loudly when the text isn't found or isn't unique.

Update is the right tool only when you genuinely mean to replace the node wholesale.

Parameter

nodes (string, required) — A JSON array of MeshNode objects with updated fields.

Important

Always Get before Update to avoid accidentally erasing fields you did not intend to change. The node at the given path is completely replaced by what you provide.

Path is derived from namespace + id, same as for Create.

Workflow

1. Retrieve the current node with Get('@path') or Search('...').
2. Modify the returned JSON (change name, content fields, etc.).
3. Pass the modified node(s) to Update as a JSON array.

Example

// First: result = Get('@ACME/ExistingProject')
// Modify the JSON, then:
Update('[{"id": "ExistingProject", "namespace": "ACME", "name": "Renamed Project", "nodeType": "Project", "content": {"status": "Completed"}}]')

Delete

Removes one or more nodes from the mesh by their paths.

Delete is RECURSIVE. Deleting a parent removes every descendant — pass the subtree root, there is no need to enumerate children, and passing a namespace root removes everything under it.

Parameter

paths (string, required) — A JSON array of path strings to delete.

Example

Delete('["ACME/OldProject", "ACME/ArchivedTask"]')

Reading Documentation

To explore all available documentation, browse the Doc namespace and read any article with Get:

Search('namespace:Doc scope:descendants')
Get('@Doc/Architecture/SomeArticle')