MCP Tool Catalog

Every WorkMemory MCP tool — name, description, inputSchema, scope, and example usage. Auto-generated from the canonical tool definitions; never edited by hand.

SDK reference: https://workweaver.ai/memory/docs/sdk

Streamable HTTP endpoint: POST https://workweaver.ai/memory/mcp · protocol 2025-06-18

READ: 60 · WRITE: 101 · SESSION: 3 · ADMIN: 11 · 175 tools

get_session_state

SESSION

Retrieve session metadata — status, segment count, agent/tool identity, timestamps. Use to check if a session exists and its current state before operating on it. [Extended tool — not a canonical verb: remember, observe, search, recall_context, forget]

Parameters

ParameterTypeRequiredDescription
session_idstringrequiredSession ID to look up.

inputSchema

{
  "properties": {
    "session_id": {
      "description": "Session ID to look up.",
      "type": "string"
    }
  },
  "required": [
    "session_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("get_session_state", session_id="<session_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("get_session_state", { session_id: "<session_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/get_session_state/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "session_id": "<session_id>"
  }
}'

memory_company_context

READ

Derive the org-scope CompanyContextView — a structured projection of organisational memory (decisions_made, preferences_observed, precedents_relied_on, skills_applied) built by walking the relation graph from the org/role entity node. Use once per session to pre-load org-level context instead of polling per-user profiles. Returns empty slots (never an error) for an empty or unknown org. [Extended tool — not a canonical verb: remember, observe, search, recall_context, forget]

Parameters

ParameterTypeRequiredDescription
max_hopsintegeroptionalMaximum graph hops to traverse (default 2). default: 2
org_entity_idstringoptionalOrg/role entity node to seed the walk from. Defaults to the tenant root node (ORG#<tenant_id>).
rolestringoptionalOptional role filter.

inputSchema

{
  "properties": {
    "max_hops": {
      "default": 2,
      "description": "Maximum graph hops to traverse (default 2).",
      "type": "integer"
    },
    "org_entity_id": {
      "description": "Org/role entity node to seed the walk from. Defaults to the tenant root node (ORG#<tenant_id>).",
      "type": "string"
    },
    "role": {
      "description": "Optional role filter.",
      "type": "string"
    }
  },
  "required": [],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_company_context")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_company_context");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_company_context/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

memory_consolidate

ADMIN

Trigger memory consolidation — merge duplicates, prune low-relevance items, and compact memory. Use after bulk ingestion or periodically to keep memory clean. Returns count of items merged, pruned, and total remaining. [Extended tool — not a canonical verb: remember, observe, search, recall_context, forget]

Parameters

ParameterTypeRequiredDescription
dry_runbooleanoptionalIf true, report what would change without modifying anything. default: false

inputSchema

{
  "properties": {
    "dry_run": {
      "default": false,
      "description": "If true, report what would change without modifying anything.",
      "type": "boolean"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_consolidate")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_consolidate");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_consolidate/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

memory_corpus_import

WRITE

Import a revision-pinned document corpus over authoritative source bytes. Returns a durable CorpusIngestJob immediately. Does not copy corpus bodies into WorkMemory facts.

Parameters

ParameterTypeRequiredDescription
filesarrayrequiredMarkdown files as {filename, text}.
corpus_idstringoptionalCorpus identifier.

inputSchema

{
  "properties": {
    "corpus_id": {
      "description": "Corpus identifier.",
      "type": "string"
    },
    "files": {
      "description": "Markdown files as {filename, text}.",
      "items": {
        "properties": {
          "filename": {
            "type": "string"
          },
          "text": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "type": "array"
    }
  },
  "required": [
    "files"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_corpus_import", files=[])
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_corpus_import", { files: [] });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_corpus_import/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "files": []
  }
}'

memory_corpus_status

READ

Read a corpus ingest job's revision, coverage, and status.

Parameters

ParameterTypeRequiredDescription
job_idstringrequiredCorpus ingest job id.

inputSchema

{
  "properties": {
    "job_id": {
      "description": "Corpus ingest job id.",
      "type": "string"
    }
  },
  "required": [
    "job_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_corpus_status", job_id="<job_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_corpus_status", { job_id: "<job_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_corpus_status/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "job_id": "<job_id>"
  }
}'

memory_cross_reference

READ

Find all entity relations for a given entity — outbound edges (what it relates to), inbound edges (what relates to it), with traversal depth 1. Use to explore the knowledge graph around any entity. [Extended tool — not a canonical verb: remember, observe, search, recall_context, forget]

Parameters

ParameterTypeRequiredDescription
entity_idstringrequiredThe entity ID to cross-reference (e.g. person name, project ID).
limitintegeroptionalMaximum relations per direction (default 50). default: 50

inputSchema

{
  "properties": {
    "entity_id": {
      "description": "The entity ID to cross-reference (e.g. person name, project ID).",
      "type": "string"
    },
    "limit": {
      "default": 50,
      "description": "Maximum relations per direction (default 50).",
      "type": "integer"
    }
  },
  "required": [
    "entity_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_cross_reference", entity_id="<entity_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_cross_reference", { entity_id: "<entity_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_cross_reference/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "entity_id": "<entity_id>"
  }
}'

memory_expose

WRITE

Copy one authorized Vault fact into Circle or Company with a provenance receipt. The source Vault row remains unchanged.

Parameters

ParameterTypeRequiredDescription
destinationstringrequiredNew revision destination. enum: circle, company
item_idstringrequiredSource Vault memory item id.
function_idstringoptionalOptional Work Function id when exposing into Circle.

inputSchema

{
  "properties": {
    "destination": {
      "description": "New revision destination.",
      "enum": [
        "circle",
        "company"
      ],
      "type": "string"
    },
    "function_id": {
      "description": "Optional Work Function id when exposing into Circle.",
      "type": "string"
    },
    "item_id": {
      "description": "Source Vault memory item id.",
      "type": "string"
    }
  },
  "required": [
    "item_id",
    "destination"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_expose", destination="circle", item_id="<item_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_expose", { destination: "circle", item_id: "<item_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_expose/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "destination": "circle",
    "item_id": "<item_id>"
  }
}'

memory_forget

WRITE

Remove outdated or incorrect information from memory. Prefer target_type + target_id. Legacy memory_id/query inputs still work.

Parameters

ParameterTypeRequiredDescription
hard_deletebooleanoptionalWhen true, delete the record instead of tombstoning it.
memory_idstringoptionalLegacy item ID to forget (if known).
querystringoptionalLegacy query to find the best-matching item to forget.
reasonstringoptionalWhy this record should be forgotten.
target_idstringoptionalCanonical target identifier.
target_typestringoptionalCanonical target type: item, resource, or job.

inputSchema

{
  "properties": {
    "hard_delete": {
      "description": "When true, delete the record instead of tombstoning it.",
      "type": "boolean"
    },
    "memory_id": {
      "description": "Legacy item ID to forget (if known).",
      "type": "string"
    },
    "query": {
      "description": "Legacy query to find the best-matching item to forget.",
      "type": "string"
    },
    "reason": {
      "description": "Why this record should be forgotten.",
      "type": "string"
    },
    "target_id": {
      "description": "Canonical target identifier.",
      "type": "string"
    },
    "target_type": {
      "description": "Canonical target type: item, resource, or job.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_forget")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_forget");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_forget/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

memory_observe_hook

WRITE

Capture a completed agent turn through ObservationHookService.on_turn_complete — the same primitive `ww memory capture` and POST /v1/observe/hook use. Extracts salient observations, persists them under the tenant capture policy, and emits one Mission-calendar TimeBlock for the turn. Pass turn_id for idempotent retries. Capture-policy denied turns return a visible skip (no persist, no TimeBlock).

Parameters

ParameterTypeRequiredDescription
turn_contentstringrequiredFull text of the completed turn.
actor_typestringoptionalCalendar actor type stamped on the emitted TimeBlock metadata. enum: zara, granted_agent
peer_idstringoptionalAgent/user identifier for provenance.
rolestringoptionalTurn role. Default assistant. enum: assistant, user
session_idstringoptionalSession to pin observations to.
started_atstringoptionalOptional ISO 8601 turn start; defaults to server receive time minus processing latency.
turn_idstringoptionalOptional caller turn identity. Retrying with the same turn_id is idempotent: no duplicate observations or TimeBlocks.

inputSchema

{
  "properties": {
    "actor_type": {
      "description": "Calendar actor type stamped on the emitted TimeBlock metadata.",
      "enum": [
        "zara",
        "granted_agent"
      ],
      "type": "string"
    },
    "peer_id": {
      "description": "Agent/user identifier for provenance.",
      "type": "string"
    },
    "role": {
      "description": "Turn role. Default assistant.",
      "enum": [
        "assistant",
        "user"
      ],
      "type": "string"
    },
    "session_id": {
      "description": "Session to pin observations to.",
      "type": "string"
    },
    "started_at": {
      "description": "Optional ISO 8601 turn start; defaults to server receive time minus processing latency.",
      "type": "string"
    },
    "turn_content": {
      "description": "Full text of the completed turn.",
      "type": "string"
    },
    "turn_id": {
      "description": "Optional caller turn identity. Retrying with the same turn_id is idempotent: no duplicate observations or TimeBlocks.",
      "type": "string"
    }
  },
  "required": [
    "turn_content"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_observe_hook", turn_content="<turn_content>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_observe_hook", { turn_content: "<turn_content>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_observe_hook/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "turn_content": "<turn_content>"
  }
}'

memory_profile

READ

Get pre-compiled user profile — static facts (long-term preferences, role, context) and dynamic context (recent activity, current state). Returns cached profile for fast context priming (<100ms on cache hit). Use for agent context priming at conversation start. [Extended tool — not a canonical verb: remember, observe, search, recall_context, forget]

Parameters

ParameterTypeRequiredDescription
user_idstringrequiredUser ID to get profile for (e.g. 'USER#alice').
include_search_resultsbooleanoptionalInclude semantic search results alongside profile facts. default: false
querystringoptionalOptional query for relevant search results alongside profile.

inputSchema

{
  "properties": {
    "include_search_results": {
      "default": false,
      "description": "Include semantic search results alongside profile facts.",
      "type": "boolean"
    },
    "query": {
      "description": "Optional query for relevant search results alongside profile.",
      "type": "string"
    },
    "user_id": {
      "description": "User ID to get profile for (e.g. 'USER#alice').",
      "type": "string"
    }
  },
  "required": [
    "user_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_profile", user_id="<user_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_profile", { user_id: "<user_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_profile/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "user_id": "<user_id>"
  }
}'

memory_recall

READ

Find relevant context from memory. Ask naturally, like asking a colleague. Optionally set max_tokens for token-budgeted context. Every response carries a completeness ENVELOPE (#6900): `recall_completeness` (hot_complete | deep_pending | degraded | timed_out), `deadline_ms` (the effective deadline honored), `why` (a human-facing verdict), and `continuation_id` (present iff deep_pending — poll it with `ww.memory.recall.continue` to fetch deep results, or stop waiting).

Parameters

ParameterTypeRequiredDescription
querystringrequiredWhat you want to recall — ask naturally.
company_widebooleanoptionalExplicit company-wide override (#10769). Skips user default and function_id source pack filters. default: false
department_idsarrayoptionalVerified caller department memberships for department-partitioned recall.
function_idstringoptionalWork Function / Circle source pack id (#10769). Filters recall to that pack's sources. Omitted ⇒ user default pack if set, else company-wide.
include_coveragebooleanoptionalWhen true, the result carries a compact `coverage` list of per-source `{source, elapsed_ms, contributed_count}` rows so a client can render 'recall · Xms · N facts' per source. Off by default — the default recall result stays lean (#7014). default: false
max_tokensintegeroptionalIf provided, returns token-budgeted formatted context. If omitted, returns raw search results.
memory_tierstringoptionalFilter by memory tier. Returns items from this tier plus parent tiers. E.g. 'task' returns task + mission + institutional. enum: institutional, mission, task, session
min_tierstringoptionalOptional minimum epistemic trust tier for recall filtering. enum: working, shared, durable, verified
mission_idstringoptionalFilter memories to a specific mission (e.g. 'MISSION#abc').
planestringoptionalCustomer-facing product plane (#10700): me / circle / company / vault. Filter recall to one plane of the 4-word visibility vocabulary instead of the 15-label scope set. enum: me, circle, company, vault
team_idsarrayoptionalVerified caller team memberships for team-partitioned recall.
tool_idstringoptionalFilter memories by tool identity. Returns memories created by this tool_id plus all universal-scope memories. Omit to return all memories.
vault_idstringoptionalExplicit Vault target (#11385). Omitted keeps recall on Company/Me; when set, selects one Vault only when the authenticated principal is on its guest list — never elevates.

inputSchema

{
  "properties": {
    "company_wide": {
      "default": false,
      "description": "Explicit company-wide override (#10769). Skips user default and function_id source pack filters.",
      "type": "boolean"
    },
    "department_ids": {
      "description": "Verified caller department memberships for department-partitioned recall.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "function_id": {
      "description": "Work Function / Circle source pack id (#10769). Filters recall to that pack's sources. Omitted \u21d2 user default pack if set, else company-wide.",
      "type": "string"
    },
    "include_coverage": {
      "default": false,
      "description": "When true, the result carries a compact `coverage` list of per-source `{source, elapsed_ms, contributed_count}` rows so a client can render 'recall \u00b7 Xms \u00b7 N facts' per source. Off by default \u2014 the default recall result stays lean (#7014).",
      "type": "boolean"
    },
    "max_tokens": {
      "description": "If provided, returns token-budgeted formatted context. If omitted, returns raw search results.",
      "type": "integer"
    },
    "memory_tier": {
      "description": "Filter by memory tier. Returns items from this tier plus parent tiers. E.g. 'task' returns task + mission + institutional.",
      "enum": [
        "institutional",
        "mission",
        "task",
        "session"
      ],
      "type": "string"
    },
    "min_tier": {
      "description": "Optional minimum epistemic trust tier for recall filtering.",
      "enum": [
        "working",
        "shared",
        "durable",
        "verified"
      ],
      "type": "string"
    },
    "mission_id": {
      "description": "Filter memories to a specific mission (e.g. 'MISSION#abc').",
      "type": "string"
    },
    "plane": {
      "description": "Customer-facing product plane (#10700): me / circle / company / vault. Filter recall to one plane of the 4-word visibility vocabulary instead of the 15-label scope set.",
      "enum": [
        "me",
        "circle",
        "company",
        "vault"
      ],
      "type": "string"
    },
    "query": {
      "description": "What you want to recall \u2014 ask naturally.",
      "type": "string"
    },
    "team_ids": {
      "description": "Verified caller team memberships for team-partitioned recall.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "tool_id": {
      "description": "Filter memories by tool identity. Returns memories created by this tool_id plus all universal-scope memories. Omit to return all memories.",
      "type": "string"
    },
    "vault_id": {
      "description": "Explicit Vault target (#11385). Omitted keeps recall on Company/Me; when set, selects one Vault only when the authenticated principal is on its guest list \u2014 never elevates.",
      "type": "string"
    }
  },
  "required": [
    "query"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_recall", query="<query>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_recall", { query: "<query>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_recall/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "query": "<query>"
  }
}'

memory_recall_continue

WRITE

Poll a deferred deep-recall handle (#6900). When `memory_recall` returns `recall_completeness=deep_pending` it issues a `continuation_id`; pass it here to fetch the deep results once ready. Returns the same completeness envelope plus a `status` (ready | still_pending | not_found) and `items`. Tenant-scoped: a handle is only resolvable by the tenant it was issued to. Until non-blocking deep recall (R6) defers Tier-2, a registered handle honestly reports `still_pending`.

Parameters

ParameterTypeRequiredDescription
continuation_idstringrequiredThe rc_… poll handle from a deep_pending recall.

inputSchema

{
  "properties": {
    "continuation_id": {
      "description": "The rc_\u2026 poll handle from a deep_pending recall.",
      "type": "string"
    }
  },
  "required": [
    "continuation_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_recall_continue", continuation_id="<continuation_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_recall_continue", { continuation_id: "<continuation_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_recall_continue/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "continuation_id": "<continuation_id>"
  }
}'

memory_remember

WRITE

Save a fact, preference, decision, or observation to persistent memory. Bind exactly one grant: Me, Circle, Company, or Vault. Be specific — one fact per call. Auto-categorizes, deduplicates, and redacts PII.

Parameters

ParameterTypeRequiredDescription
contentstringrequiredThe fact or observation to remember.
memory_tierstringoptionalMemory hierarchy tier: 'institutional' (permanent org-wide), 'mission' (project-scoped), 'task' (single task, default), 'session' (ephemeral). enum: institutional, mission, task, session
mission_idstringoptionalMission ID to scope this memory to (e.g. 'MISSION#abc').
planestringoptionalThe single public grant (#11383): me / circle / company / vault. Defaults to company. enum: me, circle, company, vault default: "company"
tool_idstringoptionalIdentifies the tool saving this memory (e.g. 'claude-code', 'cursor', 'langchain'). Used for per-tool memory scoping.
vault_idstringoptionalRequired when plane='vault'. Selects one existing Vault where the authenticated actor is a current guest.

inputSchema

{
  "properties": {
    "content": {
      "description": "The fact or observation to remember.",
      "type": "string"
    },
    "memory_tier": {
      "description": "Memory hierarchy tier: 'institutional' (permanent org-wide), 'mission' (project-scoped), 'task' (single task, default), 'session' (ephemeral).",
      "enum": [
        "institutional",
        "mission",
        "task",
        "session"
      ],
      "type": "string"
    },
    "mission_id": {
      "description": "Mission ID to scope this memory to (e.g. 'MISSION#abc').",
      "type": "string"
    },
    "plane": {
      "default": "company",
      "description": "The single public grant (#11383): me / circle / company / vault. Defaults to company.",
      "enum": [
        "me",
        "circle",
        "company",
        "vault"
      ],
      "type": "string"
    },
    "tool_id": {
      "description": "Identifies the tool saving this memory (e.g. 'claude-code', 'cursor', 'langchain'). Used for per-tool memory scoping.",
      "type": "string"
    },
    "vault_id": {
      "description": "Required when plane='vault'. Selects one existing Vault where the authenticated actor is a current guest.",
      "type": "string"
    }
  },
  "required": [
    "content"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_remember", content="<content>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_remember", { content: "<content>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_remember/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "content": "<content>"
  }
}'

memory_session

SESSION

Manage rolling context sessions for long conversations. Actions: start, flush, recall, pin, end. [Extended tool — not a canonical verb: remember, observe, search, recall_context, forget]

Parameters

ParameterTypeRequiredDescription
actionstringrequiredSession action to perform. enum: start, flush, recall, pin, end
agent_idstringoptionalAgent identifier (for start).
factstringoptionalFact to pin (for pin).
factsarrayoptionalExtracted facts from segment (for flush).
modelstringoptionalLLM model (for start).
querystringoptionalWhat to recall from this session (for recall).
session_idstringoptionalSession ID (required for flush/recall/pin/end).
summarystringoptionalCompressed summary of the segment (for flush).
token_countintegeroptionalToken count of original content (for flush).
topic_tagsarrayoptionalTopic tags for segment (for flush).

inputSchema

{
  "properties": {
    "action": {
      "description": "Session action to perform.",
      "enum": [
        "start",
        "flush",
        "recall",
        "pin",
        "end"
      ],
      "type": "string"
    },
    "agent_id": {
      "description": "Agent identifier (for start).",
      "type": "string"
    },
    "fact": {
      "description": "Fact to pin (for pin).",
      "type": "string"
    },
    "facts": {
      "description": "Extracted facts from segment (for flush).",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "model": {
      "description": "LLM model (for start).",
      "type": "string"
    },
    "query": {
      "description": "What to recall from this session (for recall).",
      "type": "string"
    },
    "session_id": {
      "description": "Session ID (required for flush/recall/pin/end).",
      "type": "string"
    },
    "summary": {
      "description": "Compressed summary of the segment (for flush).",
      "type": "string"
    },
    "token_count": {
      "description": "Token count of original content (for flush).",
      "type": "integer"
    },
    "topic_tags": {
      "description": "Topic tags for segment (for flush).",
      "items": {
        "type": "string"
      },
      "type": "array"
    }
  },
  "required": [
    "action"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_session", action="start")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_session", { action: "start" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_session/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "action": "start"
  }
}'

memory_status

READ

Check WorkMemory health, connection status, storage usage, and memory count. Optionally inspect a specific handle's status when handle_id is provided. [Extended tool — not a canonical verb: remember, observe, search, recall_context, forget]

Parameters

ParameterTypeRequiredDescription
handle_idstringoptionalOptional job/resource/item handle to inspect.

inputSchema

{
  "properties": {
    "handle_id": {
      "description": "Optional job/resource/item handle to inspect.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_status")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_status");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_status/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

memory_synthesize

WRITE

Synthesize a structured wiki-like artifact from memory items on a topic. Compiles scattered atomic facts into a persistent, section-structured document with source citations. Use for building knowledge bases, project briefs, or person profiles from existing memories. [Extended tool — not a canonical verb: remember, observe, search, recall_context, forget]

Parameters

ParameterTypeRequiredDescription
topicstringrequiredThe topic to synthesize a wiki page for.
artifact_typestringoptionalType of artifact to produce. Defaults to wiki_page. enum: wiki_page, topic_summary, project_brief, person_profile

inputSchema

{
  "properties": {
    "artifact_type": {
      "description": "Type of artifact to produce. Defaults to wiki_page.",
      "enum": [
        "wiki_page",
        "topic_summary",
        "project_brief",
        "person_profile"
      ],
      "type": "string"
    },
    "topic": {
      "description": "The topic to synthesize a wiki page for.",
      "type": "string"
    }
  },
  "required": [
    "topic"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_synthesize", topic="<topic>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_synthesize", { topic: "<topic>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_synthesize/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "topic": "<topic>"
  }
}'

memory_vault_create

WRITE

Create a need-to-know Vault and auto-add the caller to its guest list (#10709).

Parameters

ParameterTypeRequiredDescription
namestringrequiredHuman-readable vault name.
guest_member_idsarrayoptionalOptional additional guest member ids (USER#…).

inputSchema

{
  "properties": {
    "guest_member_ids": {
      "description": "Optional additional guest member ids (USER#\u2026).",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "name": {
      "description": "Human-readable vault name.",
      "type": "string"
    }
  },
  "required": [
    "name"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_vault_create", name="<name>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_vault_create", { name: "<name>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_vault_create/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "name": "<name>"
  }
}'

memory_vault_guest_add

WRITE

Admit a member to a Vault guest list.

Parameters

ParameterTypeRequiredDescription
member_idstringrequired
vault_idstringrequired

inputSchema

{
  "properties": {
    "member_id": {
      "type": "string"
    },
    "vault_id": {
      "type": "string"
    }
  },
  "required": [
    "vault_id",
    "member_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_vault_guest_add", member_id="<member_id>", vault_id="<vault_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_vault_guest_add", { member_id: "<member_id>", vault_id: "<vault_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_vault_guest_add/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "member_id": "<member_id>",
    "vault_id": "<vault_id>"
  }
}'

memory_vault_guest_remove

WRITE

Revoke a member from a Vault guest list.

Parameters

ParameterTypeRequiredDescription
member_idstringrequired
vault_idstringrequired

inputSchema

{
  "properties": {
    "member_id": {
      "type": "string"
    },
    "vault_id": {
      "type": "string"
    }
  },
  "required": [
    "vault_id",
    "member_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_vault_guest_remove", member_id="<member_id>", vault_id="<vault_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_vault_guest_remove", { member_id: "<member_id>", vault_id: "<vault_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_vault_guest_remove/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "member_id": "<member_id>",
    "vault_id": "<vault_id>"
  }
}'

memory_vault_list

WRITE

List tenant Vaults with guest counts (full guest list loads on detail).

Parameters

No parameters.

inputSchema

{
  "properties": {},
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_vault_list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_vault_list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_vault_list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

memory_who_knows

WRITE

Find people with demonstrated expertise on a topic (#10768). Returns ranked peers with evidence chips (peer observations, cards, skill ownership) — never bare names without why.

Parameters

ParameterTypeRequiredDescription
querystringrequiredTopic to find experts for (e.g. 'NFS checkpoint').
top_kintegeroptionalMax experts to return (default 5).

inputSchema

{
  "properties": {
    "query": {
      "description": "Topic to find experts for (e.g. 'NFS checkpoint').",
      "type": "string"
    },
    "top_k": {
      "description": "Max experts to return (default 5).",
      "type": "integer"
    }
  },
  "required": [
    "query"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("memory_who_knows", query="<query>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("memory_who_knows", { query: "<query>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/memory_who_knows/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "query": "<query>"
  }
}'

update_context

SESSION

Update team memory session context variables, summary, or current step.

Parameters

ParameterTypeRequiredDescription
session_idstringrequired
tenant_idstringrequired
context_varsobjectoptional
conversation_summarystringoptional
current_stepstringoptional

inputSchema

{
  "properties": {
    "context_vars": {
      "type": "object"
    },
    "conversation_summary": {
      "type": "string"
    },
    "current_step": {
      "type": "string"
    },
    "session_id": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "tenant_id",
    "session_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("update_context", session_id="<session_id>", tenant_id="<tenant_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("update_context", { session_id: "<session_id>", tenant_id: "<tenant_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/update_context/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "session_id": "<session_id>",
    "tenant_id": "<tenant_id>"
  }
}'

workmemory_correct

WRITE

W13 user correction. Supersede an existing memory item with new content + rationale; writes a corrected_by relation edge and a decision-trace audit row. Mirrors POST /v1/memory/items/<id>/correct.

Parameters

ParameterTypeRequiredDescription
new_contentstringrequiredCorrected text for the new item.
old_item_idstringrequiredMemory item id to supersede.
rationalestringrequiredWhy the correction is being made (required).
actor_idstringoptionalActing principal id; defaults to 'system:mcp'. default: "system:mcp"

inputSchema

{
  "properties": {
    "actor_id": {
      "default": "system:mcp",
      "description": "Acting principal id; defaults to 'system:mcp'.",
      "type": "string"
    },
    "new_content": {
      "description": "Corrected text for the new item.",
      "type": "string"
    },
    "old_item_id": {
      "description": "Memory item id to supersede.",
      "type": "string"
    },
    "rationale": {
      "description": "Why the correction is being made (required).",
      "type": "string"
    }
  },
  "required": [
    "old_item_id",
    "new_content",
    "rationale"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("workmemory_correct", new_content="<new_content>", old_item_id="<old_item_id>", rationale="<rationale>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("workmemory_correct", { new_content: "<new_content>", old_item_id: "<old_item_id>", rationale: "<rationale>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/workmemory_correct/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "new_content": "<new_content>",
    "old_item_id": "<old_item_id>",
    "rationale": "<rationale>"
  }
}'

workmemory_forget

WRITE

W13 filter-based forget. Tombstones every fact matching subject_id, fact_id, actor_id, or scope under the caller's tenant; writes an audit row and a 30-day recovery snapshot. **dry_run defaults to true** -- set false to actually delete. Mirrors POST /v1/memory/forget.

Parameters

ParameterTypeRequiredDescription
actor_idstringoptionalFILTER dimension: forget every fact WRITTEN BY this actor. This is NOT the requesting actor; see requesting_actor_id.
dry_runbooleanoptionalPreview the affected items without writing. Defaults to true for safety. default: true
fact_idstringoptionalForget a single fact by id.
rationalestringoptionalAudit-only reason for the forget request.
requesting_actor_idstringoptionalPrincipal performing the forget (analog of REST x-actor-id header). Defaults to 'system:mcp'. default: "system:mcp"
scopestringoptionalForget facts in this memory scope.
subject_idstringoptionalForget every fact about this subject.

inputSchema

{
  "properties": {
    "actor_id": {
      "description": "FILTER dimension: forget every fact WRITTEN BY this actor. This is NOT the requesting actor; see requesting_actor_id.",
      "type": "string"
    },
    "dry_run": {
      "default": true,
      "description": "Preview the affected items without writing. Defaults to true for safety.",
      "type": "boolean"
    },
    "fact_id": {
      "description": "Forget a single fact by id.",
      "type": "string"
    },
    "rationale": {
      "description": "Audit-only reason for the forget request.",
      "type": "string"
    },
    "requesting_actor_id": {
      "default": "system:mcp",
      "description": "Principal performing the forget (analog of REST x-actor-id header). Defaults to 'system:mcp'.",
      "type": "string"
    },
    "scope": {
      "description": "Forget facts in this memory scope.",
      "type": "string"
    },
    "subject_id": {
      "description": "Forget every fact about this subject.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("workmemory_forget")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("workmemory_forget");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/workmemory_forget/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

workmemory_why_recalled

READ

W13 why-recalled lookup. Returns the persisted recall provenance (source_actor, source_event_id, source_policy_version) and a deterministic WhyRecalled synthesized from stored signals (pinned, important). Admin-readable, side-effect-free, no live recall. Mirrors GET /v1/memory/items/<id>/why-recalled.

Parameters

ParameterTypeRequiredDescription
item_idstringrequiredMemory item id whose lineage + recall trace to fetch.

inputSchema

{
  "properties": {
    "item_id": {
      "description": "Memory item id whose lineage + recall trace to fetch.",
      "type": "string"
    }
  },
  "required": [
    "item_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("workmemory_why_recalled", item_id="<item_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("workmemory_why_recalled", { item_id: "<item_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/workmemory_why_recalled/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "item_id": "<item_id>"
  }
}'

ww.agent.di

WRITE

Return an agent's Developmental Intelligence score and self-organization gate.

Parameters

ParameterTypeRequiredDescription
agent_idstringrequiredAgent ID to score.

inputSchema

{
  "properties": {
    "agent_id": {
      "description": "Agent ID to score.",
      "type": "string"
    }
  },
  "required": [
    "agent_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.agent.di", agent_id="<agent_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.agent.di", { agent_id: "<agent_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.agent.di/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "agent_id": "<agent_id>"
  }
}'

ww.benchmark.run

WRITE

Re-run WorkMemory's published internal-evaluation benchmark scoped to your own tenant data (#6266). Returns the published vs reproduced memscore and the ±2pp delta. The call checks runner availability before any usage debit; if the runner cannot execute in this environment, it returns a no-debit `benchmark_runner_unavailable` envelope with `reason` and `message`. When runnable, it consumes usage and is metered before compute like any other action, not a standalone product. Stays Pending until the live panel has run.

Parameters

ParameterTypeRequiredDescription
modestringoptionalRepro profile: 'canonical' (full pinned datasets) or 'local' (baseline sample). Default 'canonical'. enum: canonical, local

inputSchema

{
  "properties": {
    "mode": {
      "description": "Repro profile: 'canonical' (full pinned datasets) or 'local' (baseline sample). Default 'canonical'.",
      "enum": [
        "canonical",
        "local"
      ],
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.benchmark.run")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.benchmark.run");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.benchmark.run/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.budget.ceilings.list

READ

List hierarchical spend ceilings for the tenant (workspace → member → skill) with dual projections: WW reference/list rated USD and optional raw token budgets (#11714). Read-only policy surface; BYOK ceilings use reference rates, never private vendor invoices.

Parameters

ParameterTypeRequiredDescription
tenant_idstringoptionalTenant id (TENANT#<id>). Defaults to the authenticated MCP context.

inputSchema

{
  "properties": {
    "tenant_id": {
      "description": "Tenant id (TENANT#<id>). Defaults to the authenticated MCP context.",
      "type": "string"
    }
  },
  "required": [],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.budget.ceilings.list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.budget.ceilings.list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.budget.ceilings.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.budget.remaining.show

READ

Show remaining dual-projection spend envelope (reference USD + tokens) for a member and optional skill, with honest cost_state (#11714). Never exposes private cost data.

Parameters

ParameterTypeRequiredDescription
member_idstringoptionalMember id whose envelope to inspect.
periodstringoptionalPeriod key YYYY-MM or YYYY-MM-DD (default: current month UTC).
skill_idstringoptionalOptional skill id for nested skill ceiling.
tenant_idstringoptionalTenant id (TENANT#<id>). Defaults to the authenticated MCP context.

inputSchema

{
  "properties": {
    "member_id": {
      "description": "Member id whose envelope to inspect.",
      "type": "string"
    },
    "period": {
      "description": "Period key YYYY-MM or YYYY-MM-DD (default: current month UTC).",
      "type": "string"
    },
    "skill_id": {
      "description": "Optional skill id for nested skill ceiling.",
      "type": "string"
    },
    "tenant_id": {
      "description": "Tenant id (TENANT#<id>). Defaults to the authenticated MCP context.",
      "type": "string"
    }
  },
  "required": [],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.budget.remaining.show")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.budget.remaining.show");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.budget.remaining.show/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.budget.show

READ

Show the per-tenant AI budget summary: total spend, percentage of ceiling, per-surface breakdown, kill-switch state (#4839).

Parameters

ParameterTypeRequiredDescription
periodstringoptionalYYYY-MM period (default: current month UTC).
tenant_idstringoptionalTenant id (TENANT#<id>). Defaults to the authenticated MCP context.

inputSchema

{
  "properties": {
    "period": {
      "description": "YYYY-MM period (default: current month UTC).",
      "type": "string"
    },
    "tenant_id": {
      "description": "Tenant id (TENANT#<id>). Defaults to the authenticated MCP context.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.budget.show")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.budget.show");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.budget.show/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.capabilities.get

READ

Get full detail for one capability_id from the canonical registry SSOT. Returns capability_not_found or capability_not_entitled when the row is missing or not disclosable to the authenticated tenant.

Parameters

ParameterTypeRequiredDescription
capability_idstringrequiredCanonical capability_id (e.g. agent.manual).

inputSchema

{
  "properties": {
    "capability_id": {
      "description": "Canonical capability_id (e.g. agent.manual).",
      "type": "string"
    }
  },
  "required": [
    "capability_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.capabilities.get", capability_id="<capability_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.capabilities.get", { capability_id: "<capability_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.capabilities.get/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "capability_id": "<capability_id>"
  }
}'

ww.capabilities.list

READ

List Workweaver capabilities from the canonical registry SSOT (docs/reference/runtime/capabilities.registry.yaml). Returns tenant-entitled rows only; founder_admin / developer_governance audience rows are omitted. Optional filters: family, surface (cli|api|mcp|dashboard|acp), include_sunsetted.

Parameters

ParameterTypeRequiredDescription
familystringoptionalOptional capability family filter (e.g. agent, memory).
include_sunsettedbooleanoptionalWhen true, include sunsetted capabilities. Default false. default: false
surfacestringoptionalOnly include capabilities that declare this surface. enum: cli, api, mcp, dashboard, acp

inputSchema

{
  "properties": {
    "family": {
      "description": "Optional capability family filter (e.g. agent, memory).",
      "type": "string"
    },
    "include_sunsetted": {
      "default": false,
      "description": "When true, include sunsetted capabilities. Default false.",
      "type": "boolean"
    },
    "surface": {
      "description": "Only include capabilities that declare this surface.",
      "enum": [
        "cli",
        "api",
        "mcp",
        "dashboard",
        "acp"
      ],
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.capabilities.list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.capabilities.list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.capabilities.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.capability.balance_sheet.show

READ

Return the tenant Capability Balance Sheet: one statement-date read projection over the capability position with four capitals (skill/execution/memory/quality), exact epistemic states, gross liabilities, and a server-side Watch projection. No composite score and no client math (#11059).

Parameters

ParameterTypeRequiredDescription
tenant_idstringoptional
window_daysintegeroptionalComparative-period length in days; seven days is the default, never the only allowed period.

inputSchema

{
  "properties": {
    "tenant_id": {
      "type": "string"
    },
    "window_days": {
      "description": "Comparative-period length in days; seven days is the default, never the only allowed period.",
      "type": "integer"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.capability.balance_sheet.show")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.capability.balance_sheet.show");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.capability.balance_sheet.show/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.capability.position.compare

WRITE

Compare matched windows of a workload definition and derive movement verdicts plus native and (when applicable) relative compounding rates. Family change yields not_comparable (#12086).

Parameters

ParameterTypeRequiredDescription
closing_window_closed_atstringrequired
closing_window_opened_atstringrequired
definition_idstringrequired
opening_window_closed_atstringrequired
opening_window_opened_atstringrequired
closing_definition_idstringoptionalOptional closing definition; different family means not comparable.
tenant_idstringoptional
time_unitstringoptionalPer-day, per-hour, etc.; default day.

inputSchema

{
  "properties": {
    "closing_definition_id": {
      "description": "Optional closing definition; different family means not comparable.",
      "type": "string"
    },
    "closing_window_closed_at": {
      "type": "string"
    },
    "closing_window_opened_at": {
      "type": "string"
    },
    "definition_id": {
      "type": "string"
    },
    "opening_window_closed_at": {
      "type": "string"
    },
    "opening_window_opened_at": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    },
    "time_unit": {
      "description": "Per-day, per-hour, etc.; default day.",
      "type": "string"
    }
  },
  "required": [
    "definition_id",
    "opening_window_opened_at",
    "opening_window_closed_at",
    "closing_window_opened_at",
    "closing_window_closed_at"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.capability.position.compare", closing_window_closed_at="<closing_window_closed_at>", closing_window_opened_at="<closing_window_opened_at>", definition_id="<definition_id>", opening_window_closed_at="<opening_window_closed_at>", opening_window_opened_at="<opening_window_opened_at>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.capability.position.compare", { closing_window_closed_at: "<closing_window_closed_at>", closing_window_opened_at: "<closing_window_opened_at>", definition_id: "<definition_id>", opening_window_closed_at: "<opening_window_closed_at>", opening_window_opened_at: "<opening_window_opened_at>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.capability.position.compare/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "closing_window_closed_at": "<closing_window_closed_at>",
    "closing_window_opened_at": "<closing_window_opened_at>",
    "definition_id": "<definition_id>",
    "opening_window_closed_at": "<opening_window_closed_at>",
    "opening_window_opened_at": "<opening_window_opened_at>"
  }
}'

ww.capability.position.movements

WRITE

List tenant capability movement receipts. Bounded page; verdicts are improved/regressed/unchanged/not_comparable/insufficient_evidence (#12086).

Parameters

ParameterTypeRequiredDescription
limitintegeroptional
tenant_idstringoptional

inputSchema

{
  "properties": {
    "limit": {
      "type": "integer"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.capability.position.movements")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.capability.position.movements");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.capability.position.movements/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.capability.position.show

READ

Return the tenant capability position: movement, positions, and liabilities derived from verified outcome receipts. Exact epistemic states, no composite score (#12086).

Parameters

ParameterTypeRequiredDescription
tenant_idstringoptional
watermarkstringoptionalOptional derivation watermark; latest when omitted.

inputSchema

{
  "properties": {
    "tenant_id": {
      "type": "string"
    },
    "watermark": {
      "description": "Optional derivation watermark; latest when omitted.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.capability.position.show")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.capability.position.show");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.capability.position.show/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.channel.normalize_inbound

WRITE

Normalize a raw inbound channel message into the canonical envelope.

Parameters

ParameterTypeRequiredDescription
channelstringrequiredInbound channel kind.
raw_messageobjectrequiredRaw provider message payload.

inputSchema

{
  "properties": {
    "channel": {
      "description": "Inbound channel kind.",
      "type": "string"
    },
    "raw_message": {
      "description": "Raw provider message payload.",
      "type": "object"
    }
  },
  "required": [
    "channel",
    "raw_message"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.channel.normalize_inbound", channel="<channel>", raw_message={})
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.channel.normalize_inbound", { channel: "<channel>", raw_message: {} });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.channel.normalize_inbound/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "channel": "<channel>",
    "raw_message": {}
  }
}'

ww.channel.route

WRITE

Resolve the routing decision for an inbound channel message.

Parameters

ParameterTypeRequiredDescription
source_channelstringrequiredOriginating channel kind.
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.
entity_scopestringoptionalOptional entity scope.
intent_typestringoptionalOptional intent classification.

inputSchema

{
  "properties": {
    "entity_scope": {
      "description": "Optional entity scope.",
      "type": "string"
    },
    "intent_type": {
      "description": "Optional intent classification.",
      "type": "string"
    },
    "source_channel": {
      "description": "Originating channel kind.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "source_channel"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.channel.route", source_channel="<source_channel>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.channel.route", { source_channel: "<source_channel>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.channel.route/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "source_channel": "<source_channel>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.channel.rule.propose

WRITE

Propose a channel routing rule for review.

Parameters

ParameterTypeRequiredDescription
source_channelstringrequiredOriginating channel kind.
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.
conditionobjectoptionalOptional rule condition payload.
decision_trace_reasonstringoptionalOptional rationale for the proposal.
entity_scopestringoptionalOptional entity scope.
intent_typestringoptionalOptional intent classification.
priorityintegeroptionalOptional rule priority.
redaction_levelstringoptionalOptional redaction level.
target_channelstringoptionalDestination channel kind.

inputSchema

{
  "properties": {
    "condition": {
      "description": "Optional rule condition payload.",
      "type": "object"
    },
    "decision_trace_reason": {
      "description": "Optional rationale for the proposal.",
      "type": "string"
    },
    "entity_scope": {
      "description": "Optional entity scope.",
      "type": "string"
    },
    "intent_type": {
      "description": "Optional intent classification.",
      "type": "string"
    },
    "priority": {
      "description": "Optional rule priority.",
      "type": "integer"
    },
    "redaction_level": {
      "description": "Optional redaction level.",
      "type": "string"
    },
    "source_channel": {
      "description": "Originating channel kind.",
      "type": "string"
    },
    "target_channel": {
      "description": "Destination channel kind.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "source_channel"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.channel.rule.propose", source_channel="<source_channel>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.channel.rule.propose", { source_channel: "<source_channel>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.channel.rule.propose/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "source_channel": "<source_channel>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.channel.send

WRITE

Send a message through the unified Channel actor.

Parameters

ParameterTypeRequiredDescription
bodystringrequiredMessage body.
channelstringrequiredChannel kind (e.g. email, sms, whatsapp, slack).
recipientstringrequiredRecipient address/handle.
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.
message_idstringoptionalOptional message id for idempotency.
metadataobjectoptionalOptional message metadata.
senderstringoptionalOptional sender address/handle.

inputSchema

{
  "properties": {
    "body": {
      "description": "Message body.",
      "type": "string"
    },
    "channel": {
      "description": "Channel kind (e.g. email, sms, whatsapp, slack).",
      "type": "string"
    },
    "message_id": {
      "description": "Optional message id for idempotency.",
      "type": "string"
    },
    "metadata": {
      "description": "Optional message metadata.",
      "type": "object"
    },
    "recipient": {
      "description": "Recipient address/handle.",
      "type": "string"
    },
    "sender": {
      "description": "Optional sender address/handle.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "channel",
    "recipient",
    "body"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.channel.send", body="<body>", channel="<channel>", recipient="<recipient>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.channel.send", { body: "<body>", channel: "<channel>", recipient: "<recipient>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.channel.send/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "body": "<body>",
    "channel": "<channel>",
    "recipient": "<recipient>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.channel.send_batch

WRITE

Send a batch of messages through the unified Channel actor.

Parameters

ParameterTypeRequiredDescription
messagesarrayrequiredMessages to send.
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "messages": {
      "description": "Messages to send.",
      "items": {
        "type": "object"
      },
      "type": "array"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "messages"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.channel.send_batch", messages=[], workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.channel.send_batch", { messages: [], workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.channel.send_batch/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "messages": [],
    "workspace_id": "<workspace_id>"
  }
}'

ww.channel.template.send

WRITE

Send a templated message through the unified Channel actor.

Parameters

ParameterTypeRequiredDescription
bodystringrequiredRendered template body.
recipientstringrequiredRecipient address/handle.
source_channelstringrequiredOriginating channel kind.
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.
entity_scopestringoptionalOptional entity scope.
intent_typestringoptionalOptional intent classification.
message_idstringoptionalOptional message id for idempotency.
metadataobjectoptionalOptional message metadata.
senderstringoptionalOptional sender address/handle.

inputSchema

{
  "properties": {
    "body": {
      "description": "Rendered template body.",
      "type": "string"
    },
    "entity_scope": {
      "description": "Optional entity scope.",
      "type": "string"
    },
    "intent_type": {
      "description": "Optional intent classification.",
      "type": "string"
    },
    "message_id": {
      "description": "Optional message id for idempotency.",
      "type": "string"
    },
    "metadata": {
      "description": "Optional message metadata.",
      "type": "object"
    },
    "recipient": {
      "description": "Recipient address/handle.",
      "type": "string"
    },
    "sender": {
      "description": "Optional sender address/handle.",
      "type": "string"
    },
    "source_channel": {
      "description": "Originating channel kind.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "source_channel",
    "recipient",
    "body"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.channel.template.send", body="<body>", recipient="<recipient>", source_channel="<source_channel>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.channel.template.send", { body: "<body>", recipient: "<recipient>", source_channel: "<source_channel>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.channel.template.send/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "body": "<body>",
    "recipient": "<recipient>",
    "source_channel": "<source_channel>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.channels.messages_list

WRITE

List rendered ChannelMessages for a channel.

Parameters

ParameterTypeRequiredDescription
channel_idstringrequiredChannel id to list messages for.
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "channel_id": {
      "description": "Channel id to list messages for.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "channel_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.channels.messages_list", channel_id="<channel_id>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.channels.messages_list", { channel_id: "<channel_id>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.channels.messages_list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "channel_id": "<channel_id>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.channels.messages_send

WRITE

Send a rendered ChannelMessage (blocks + fallback text) to a channel.

Parameters

ParameterTypeRequiredDescription
blocksarrayrequiredRendered message blocks.
channel_idstringrequiredDestination channel id.
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.
confidence_levelstringoptionalOptional confidence annotation.
fallback_textstringoptionalOptional plain-text fallback.

inputSchema

{
  "properties": {
    "blocks": {
      "description": "Rendered message blocks.",
      "items": {
        "type": "object"
      },
      "type": "array"
    },
    "channel_id": {
      "description": "Destination channel id.",
      "type": "string"
    },
    "confidence_level": {
      "description": "Optional confidence annotation.",
      "type": "string"
    },
    "fallback_text": {
      "description": "Optional plain-text fallback.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "channel_id",
    "blocks"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.channels.messages_send", blocks=[], channel_id="<channel_id>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.channels.messages_send", { blocks: [], channel_id: "<channel_id>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.channels.messages_send/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "blocks": [],
    "channel_id": "<channel_id>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.code.index

WRITE

Index a repository's code blocks into the code knowledge graph.

Parameters

ParameterTypeRequiredDescription
repository_idstringrequiredOpaque repository selector. Not a server filesystem path.

inputSchema

{
  "properties": {
    "repository_id": {
      "description": "Opaque repository selector. Not a server filesystem path.",
      "minLength": 1,
      "title": "Repository Id",
      "type": "string"
    }
  },
  "required": [
    "repository_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.code.index", repository_id="<repository_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.code.index", { repository_id: "<repository_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.code.index/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "repository_id": "<repository_id>"
  }
}'

ww.code.search

WRITE

Search the indexed code graph for relevant symbols and code blocks.

Parameters

ParameterTypeRequiredDescription
acl_epochanyoptional default: null
allow_stalebooleanoptional default: false
cursoranyoptional default: null
generation_pinanyoptional default: null
grant_epochanyoptional default: null
identifierstringoptionalQualified name or path for exact/symbol/relation ops. default: ""
opstringoptional enum: exact, search, symbol, references, dependencies, impact default: "search"
querystringoptionalNatural-language or symbol-oriented code search query. default: ""
repository_idanyoptionalOpaque repository selector. default: null
source_set_idanyoptional default: null
top_kintegeroptionalMaximum anchors to return. default: 5

inputSchema

{
  "properties": {
    "acl_epoch": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Acl Epoch"
    },
    "allow_stale": {
      "default": false,
      "title": "Allow Stale",
      "type": "boolean"
    },
    "cursor": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Cursor"
    },
    "generation_pin": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Generation Pin"
    },
    "grant_epoch": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Grant Epoch"
    },
    "identifier": {
      "default": "",
      "description": "Qualified name or path for exact/symbol/relation ops.",
      "title": "Identifier",
      "type": "string"
    },
    "op": {
      "default": "search",
      "enum": [
        "exact",
        "search",
        "symbol",
        "references",
        "dependencies",
        "impact"
      ],
      "title": "Op",
      "type": "string"
    },
    "query": {
      "default": "",
      "description": "Natural-language or symbol-oriented code search query.",
      "title": "Query",
      "type": "string"
    },
    "repository_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "description": "Opaque repository selector.",
      "title": "Repository Id"
    },
    "source_set_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Source Set Id"
    },
    "top_k": {
      "default": 5,
      "description": "Maximum anchors to return.",
      "maximum": 50,
      "minimum": 1,
      "title": "Top K",
      "type": "integer"
    }
  },
  "required": [],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.code.search")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.code.search");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.code.search/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.code.symbol

WRITE

Fetch a single fully-qualified symbol and its inbound references.

Parameters

ParameterTypeRequiredDescription
qualified_namestringrequiredFully-qualified symbol name.
generation_pinanyoptional default: null
repository_idanyoptional default: null
source_set_idanyoptional default: null

inputSchema

{
  "properties": {
    "generation_pin": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Generation Pin"
    },
    "qualified_name": {
      "description": "Fully-qualified symbol name.",
      "minLength": 1,
      "title": "Qualified Name",
      "type": "string"
    },
    "repository_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Repository Id"
    },
    "source_set_id": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "default": null,
      "title": "Source Set Id"
    }
  },
  "required": [
    "qualified_name"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.code.symbol", qualified_name="<qualified_name>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.code.symbol", { qualified_name: "<qualified_name>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.code.symbol/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "qualified_name": "<qualified_name>"
  }
}'

ww.connect.harness_install_session

ADMIN

One-click harness install session. Mints a scoped WorkMemory API key, returns the harness-specific config snippet, and records install trust state. Same payload shape as ``POST /v1/workmemory/harness-install-session`` (#5022). Supports all 12 canonical harnesses (claude-desktop, claude-code, cursor, opencode, codex, gemini, openclaw, hermes, goose, grok, grok-build, generic-mcp). Plaintext key is returned exactly ONCE — clients must persist it themselves. ADMIN-scoped.

Parameters

ParameterTypeRequiredDescription
harnessstringrequiredPublic kebab-case harness name. enum: claude-desktop, claude-code, cursor, opencode, codex, gemini, openclaw, hermes, goose, grok, grok-build, generic-mcp
base_urlstringoptionalOptional canonical public base URL the snippet embeds. Defaults to WORKMEMORY_PUBLIC_BASE_URL or https://api.workweaver.ai.
namestringoptionalDisplay name for the issued scoped API key. default: "harness-install"
scopesarrayoptionalScopes to mint on the issued API key. Allowed: READ, WRITE. ADMIN/SESSION are rejected (defence in depth — see #5022 codex review).
task_scopestringoptionalOptional per-task persistent-context key (#6275). Pins the harness to a super-app task tab so recall + capture are task-coherent. Omitted ⇒ tenant-wide.
tenant_idstringoptionalTenant id. Defaults to the authenticated MCP context; cross-tenant param values are rejected.

inputSchema

{
  "properties": {
    "base_url": {
      "description": "Optional canonical public base URL the snippet embeds. Defaults to WORKMEMORY_PUBLIC_BASE_URL or https://api.workweaver.ai.",
      "type": "string"
    },
    "harness": {
      "description": "Public kebab-case harness name.",
      "enum": [
        "claude-desktop",
        "claude-code",
        "cursor",
        "opencode",
        "codex",
        "gemini",
        "openclaw",
        "hermes",
        "goose",
        "grok",
        "grok-build",
        "generic-mcp"
      ],
      "type": "string"
    },
    "name": {
      "default": "harness-install",
      "description": "Display name for the issued scoped API key.",
      "type": "string"
    },
    "scopes": {
      "description": "Scopes to mint on the issued API key. Allowed: READ, WRITE. ADMIN/SESSION are rejected (defence in depth \u2014 see #5022 codex review).",
      "items": {
        "enum": [
          "READ",
          "WRITE"
        ],
        "type": "string"
      },
      "type": "array"
    },
    "task_scope": {
      "description": "Optional per-task persistent-context key (#6275). Pins the harness to a super-app task tab so recall + capture are task-coherent. Omitted \u21d2 tenant-wide.",
      "type": "string"
    },
    "tenant_id": {
      "description": "Tenant id. Defaults to the authenticated MCP context; cross-tenant param values are rejected.",
      "type": "string"
    }
  },
  "required": [
    "harness"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.connect.harness_install_session", harness="claude-desktop")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.connect.harness_install_session", { harness: "claude-desktop" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.connect.harness_install_session/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "harness": "claude-desktop"
  }
}'

ww.edge.devices.register

WRITE

Register a tenant edge device for ACP job claim (#10749).

Parameters

ParameterTypeRequiredDescription
supported_harnessesarrayrequired
labelsobjectoptional
parallelismintegeroptional

inputSchema

{
  "properties": {
    "labels": {
      "type": "object"
    },
    "parallelism": {
      "type": "integer"
    },
    "supported_harnesses": {
      "items": {
        "type": "string"
      },
      "type": "array"
    }
  },
  "required": [
    "supported_harnesses"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.edge.devices.register", supported_harnesses=[])
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.edge.devices.register", { supported_harnesses: [] });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.edge.devices.register/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "supported_harnesses": []
  }
}'

ww.edge.jobs.dispatch

WRITE

Dispatch an ACP/coding job to a tenant edge device (#10749).

Parameters

ParameterTypeRequiredDescription
goalstringrequired
harnessstringrequired
admission_idstringoptional
budgetobjectoptional
calling_skill_idstringoptional
card_idstringoptional
device_idstringoptional
labelsobjectoptional
mission_idstringoptional
orchestration_instructions_packetobjectoptional

inputSchema

{
  "properties": {
    "admission_id": {
      "type": "string"
    },
    "budget": {
      "type": "object"
    },
    "calling_skill_id": {
      "type": "string"
    },
    "card_id": {
      "type": "string"
    },
    "device_id": {
      "type": "string"
    },
    "goal": {
      "type": "string"
    },
    "harness": {
      "type": "string"
    },
    "labels": {
      "type": "object"
    },
    "mission_id": {
      "type": "string"
    },
    "orchestration_instructions_packet": {
      "type": "object"
    }
  },
  "required": [
    "goal",
    "harness"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.edge.jobs.dispatch", goal="<goal>", harness="<harness>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.edge.jobs.dispatch", { goal: "<goal>", harness: "<harness>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.edge.jobs.dispatch/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "goal": "<goal>",
    "harness": "<harness>"
  }
}'

ww.edge.jobs.status

READ

Get status of one Cloud→Edge ACP job (#10749).

Parameters

ParameterTypeRequiredDescription
job_idstringrequired

inputSchema

{
  "properties": {
    "job_id": {
      "type": "string"
    }
  },
  "required": [
    "job_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.edge.jobs.status", job_id="<job_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.edge.jobs.status", { job_id: "<job_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.edge.jobs.status/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "job_id": "<job_id>"
  }
}'

ww.email.list_threads

WRITE

List recent agent email threads.

Parameters

ParameterTypeRequiredDescription
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.
limitintegeroptionalMaximum threads to return.

inputSchema

{
  "properties": {
    "limit": {
      "description": "Maximum threads to return.",
      "type": "integer"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.email.list_threads", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.email.list_threads", { workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.email.list_threads/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "workspace_id": "<workspace_id>"
  }
}'

ww.email.reply

WRITE

Reply to an email thread.

Parameters

ParameterTypeRequiredDescription
bodystringrequiredReply body.
thread_idstringrequiredEmail thread id to reply to.
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "body": {
      "description": "Reply body.",
      "type": "string"
    },
    "thread_id": {
      "description": "Email thread id to reply to.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "thread_id",
    "body"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.email.reply", body="<body>", thread_id="<thread_id>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.email.reply", { body: "<body>", thread_id: "<thread_id>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.email.reply/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "body": "<body>",
    "thread_id": "<thread_id>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.email.send

WRITE

Send an agent email.

Parameters

ParameterTypeRequiredDescription
bodystringrequiredEmail body.
subjectstringrequiredEmail subject.
tostringrequiredRecipient address.
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.
bccstringoptionalOptional BCC address(es).
ccstringoptionalOptional CC address(es).
from_aliasstringoptionalOptional from-alias.
reply_tostringoptionalOptional reply-to address.

inputSchema

{
  "properties": {
    "bcc": {
      "description": "Optional BCC address(es).",
      "type": "string"
    },
    "body": {
      "description": "Email body.",
      "type": "string"
    },
    "cc": {
      "description": "Optional CC address(es).",
      "type": "string"
    },
    "from_alias": {
      "description": "Optional from-alias.",
      "type": "string"
    },
    "reply_to": {
      "description": "Optional reply-to address.",
      "type": "string"
    },
    "subject": {
      "description": "Email subject.",
      "type": "string"
    },
    "to": {
      "description": "Recipient address.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "to",
    "subject",
    "body"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.email.send", body="<body>", subject="<subject>", to="<to>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.email.send", { body: "<body>", subject: "<subject>", to: "<to>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.email.send/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "body": "<body>",
    "subject": "<subject>",
    "to": "<to>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.eval.anti_theater

WRITE

Evaluate 5-clause anti-theater gate for a capability case (#9020).

Parameters

ParameterTypeRequiredDescription
caseobjectoptional

inputSchema

{
  "properties": {
    "case": {
      "type": "object"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.eval.anti_theater")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.eval.anti_theater");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.eval.anti_theater/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.eval.certificate

WRITE

Model-switch compatibility certificate (#9020).

Parameters

ParameterTypeRequiredDescription
instruction_manifest_shastringrequired
modelstringrequired
providerstringrequired
tenant_idstringrequired
cert_gold_kintegeroptional
cert_gold_passesintegeroptional
coverage_regressionbooleanoptional
replay_on_candidatebooleanoptional

inputSchema

{
  "properties": {
    "cert_gold_k": {
      "type": "integer"
    },
    "cert_gold_passes": {
      "type": "integer"
    },
    "coverage_regression": {
      "type": "boolean"
    },
    "instruction_manifest_sha": {
      "type": "string"
    },
    "model": {
      "type": "string"
    },
    "provider": {
      "type": "string"
    },
    "replay_on_candidate": {
      "type": "boolean"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "tenant_id",
    "provider",
    "model",
    "instruction_manifest_sha"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.eval.certificate", instruction_manifest_sha="<instruction_manifest_sha>", model="<model>", provider="<provider>", tenant_id="<tenant_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.eval.certificate", { instruction_manifest_sha: "<instruction_manifest_sha>", model: "<model>", provider: "<provider>", tenant_id: "<tenant_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.eval.certificate/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "instruction_manifest_sha": "<instruction_manifest_sha>",
    "model": "<model>",
    "provider": "<provider>",
    "tenant_id": "<tenant_id>"
  }
}'

ww.eval.consume_store

WRITE

Load orchestration store.json into saturate-ready eval cases (#9020).

Parameters

ParameterTypeRequiredDescription
store_pathstringoptional

inputSchema

{
  "properties": {
    "store_path": {
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.eval.consume_store")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.eval.consume_store");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.eval.consume_store/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.eval.coverage

WRITE

Honest stratified eval coverage census (#9020).

Parameters

ParameterTypeRequiredDescription
tenant_idstringoptional

inputSchema

{
  "properties": {
    "tenant_id": {
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.eval.coverage")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.eval.coverage");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.eval.coverage/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.eval.red_team

WRITE

Schedule red-team eval categories (#9020).

Parameters

ParameterTypeRequiredDescription
suitestringrequired
categoriesarrayoptional
tenant_idstringoptional

inputSchema

{
  "properties": {
    "categories": {
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "suite": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "suite"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.eval.red_team", suite="<suite>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.eval.red_team", { suite: "<suite>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.eval.red_team/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "suite": "<suite>"
  }
}'

ww.eval.revise_rubric

WRITE

Revise a rubric draft before human review (#9020).

Parameters

ParameterTypeRequiredDescription
case_idstringrequired
rubricobjectoptional
tenant_idstringoptional

inputSchema

{
  "properties": {
    "case_id": {
      "type": "string"
    },
    "rubric": {
      "type": "object"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "case_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.eval.revise_rubric", case_id="<case_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.eval.revise_rubric", { case_id: "<case_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.eval.revise_rubric/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "case_id": "<case_id>"
  }
}'

ww.eval.run_suite

WRITE

Run an eval suite with tiered scheduling (#9020).

Parameters

ParameterTypeRequiredDescription
suitestringrequired
tenant_idstringoptional
triggerstringoptionalsave|activate|merge|model_switch|nightly

inputSchema

{
  "properties": {
    "suite": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    },
    "trigger": {
      "description": "save|activate|merge|model_switch|nightly",
      "type": "string"
    }
  },
  "required": [
    "suite"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.eval.run_suite", suite="<suite>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.eval.run_suite", { suite: "<suite>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.eval.run_suite/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "suite": "<suite>"
  }
}'

ww.fs.cat

READ

Read a WorkMemoryFS virtual file (#5012).

Parameters

ParameterTypeRequiredDescription
pathstringrequiredVirtual file path: /profile.md, /company.md, /entities/<name>.md, /recent/<id>.md, /precedents/<event_id>.md (#9840).
task_scopestringoptionalOptional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).
tool_idstringoptionalOptional requester tool id for tool-scoped memory visibility.

inputSchema

{
  "properties": {
    "path": {
      "description": "Virtual file path: /profile.md, /company.md, /entities/<name>.md, /recent/<id>.md, /precedents/<event_id>.md (#9840).",
      "type": "string"
    },
    "task_scope": {
      "description": "Optional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).",
      "type": "string"
    },
    "tool_id": {
      "description": "Optional requester tool id for tool-scoped memory visibility.",
      "type": "string"
    }
  },
  "required": [
    "path"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.fs.cat", path="<path>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.fs.cat", { path: "<path>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.fs.cat/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "path": "<path>"
  }
}'

ww.fs.echo

WRITE

Append content to WorkMemoryFS /inbox/ through the canonical ingestion path (#5012).

Parameters

ParameterTypeRequiredDescription
contentstringrequired
pathstringrequired
task_scopestringoptionalOptional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).

inputSchema

{
  "properties": {
    "content": {
      "type": "string"
    },
    "path": {
      "type": "string"
    },
    "task_scope": {
      "description": "Optional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).",
      "type": "string"
    }
  },
  "required": [
    "path",
    "content"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.fs.echo", content="<content>", path="<path>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.fs.echo", { content: "<content>", path: "<path>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.fs.echo/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "content": "<content>",
    "path": "<path>"
  }
}'

ww.fs.find

READ

Find WorkMemoryFS virtual entries by name (#5012).

Parameters

ParameterTypeRequiredDescription
namestringoptional default: "*"
pathstringoptional default: "/"
task_scopestringoptionalOptional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).
tool_idstringoptionalOptional requester tool id for tool-scoped memory visibility.

inputSchema

{
  "properties": {
    "name": {
      "default": "*",
      "type": "string"
    },
    "path": {
      "default": "/",
      "type": "string"
    },
    "task_scope": {
      "description": "Optional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).",
      "type": "string"
    },
    "tool_id": {
      "description": "Optional requester tool id for tool-scoped memory visibility.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.fs.find")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.fs.find");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.fs.find/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.fs.grep

READ

Search WorkMemoryFS content (#5012).

Parameters

ParameterTypeRequiredDescription
patternstringrequired
lexicalbooleanoptional default: false
limitintegeroptional default: 20
pathstringoptionalVirtual folder to confine the search: /sources/<connector> scopes to a connector, /recent to the recency view, / is tenant-wide. An unknown path returns an error rather than a global recall (#6878). default: "/"
task_scopestringoptionalOptional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).
tool_idstringoptionalOptional requester tool id for tool-scoped memory visibility.

inputSchema

{
  "properties": {
    "lexical": {
      "default": false,
      "type": "boolean"
    },
    "limit": {
      "default": 20,
      "type": "integer"
    },
    "path": {
      "default": "/",
      "description": "Virtual folder to confine the search: /sources/<connector> scopes to a connector, /recent to the recency view, / is tenant-wide. An unknown path returns an error rather than a global recall (#6878).",
      "type": "string"
    },
    "pattern": {
      "type": "string"
    },
    "task_scope": {
      "description": "Optional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).",
      "type": "string"
    },
    "tool_id": {
      "description": "Optional requester tool id for tool-scoped memory visibility.",
      "type": "string"
    }
  },
  "required": [
    "pattern"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.fs.grep", pattern="<pattern>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.fs.grep", { pattern: "<pattern>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.fs.grep/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "pattern": "<pattern>"
  }
}'

ww.fs.ls

READ

List a WorkMemoryFS virtual directory (#5012).

Parameters

ParameterTypeRequiredDescription
pathstringoptionalVirtual directory path: / (root), /recent, /sources, /entities, /skills, /precedents (#9840). default: "/"
task_scopestringoptionalOptional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).
tool_idstringoptionalOptional requester tool id for tool-scoped memory visibility.

inputSchema

{
  "properties": {
    "path": {
      "default": "/",
      "description": "Virtual directory path: / (root), /recent, /sources, /entities, /skills, /precedents (#9840).",
      "type": "string"
    },
    "task_scope": {
      "description": "Optional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).",
      "type": "string"
    },
    "tool_id": {
      "description": "Optional requester tool id for tool-scoped memory visibility.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.fs.ls")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.fs.ls");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.fs.ls/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.fs.rm

WRITE

Soft-delete a WorkMemoryFS entity through the canonical forget path (#5012).

Parameters

ParameterTypeRequiredDescription
pathstringrequired

inputSchema

{
  "properties": {
    "path": {
      "type": "string"
    }
  },
  "required": [
    "path"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.fs.rm", path="<path>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.fs.rm", { path: "<path>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.fs.rm/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "path": "<path>"
  }
}'

ww.function.archive

ADMIN

Archive a Work Function through the REST route. Emits Decision Trace action work_function.archive.

Parameters

ParameterTypeRequiredDescription
function_idstringrequiredWork Function id.
actor_idstringoptionalActing principal id for Decision Trace emission. default: "mcp"
drainstringoptionalIn-flight work drain policy. enum: drain_to_completion, drain_in_flight, cancel_with_trace, cancel_in_flight, reassign, reject_if_running default: "drain_to_completion"
reasonstringoptionalDecision Trace reason. default: "Archived from MCP"
tenant_idstringoptionalOptional workspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "actor_id": {
      "default": "mcp",
      "description": "Acting principal id for Decision Trace emission.",
      "type": "string"
    },
    "drain": {
      "default": "drain_to_completion",
      "description": "In-flight work drain policy.",
      "enum": [
        "drain_to_completion",
        "drain_in_flight",
        "cancel_with_trace",
        "cancel_in_flight",
        "reassign",
        "reject_if_running"
      ],
      "type": "string"
    },
    "function_id": {
      "description": "Work Function id.",
      "type": "string"
    },
    "reason": {
      "default": "Archived from MCP",
      "description": "Decision Trace reason.",
      "type": "string"
    },
    "tenant_id": {
      "description": "Optional workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "function_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.function.archive", function_id="<function_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.function.archive", { function_id: "<function_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.function.archive/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "function_id": "<function_id>"
  }
}'

ww.function.capacity.set

ADMIN

Set Work Function capacity and/or source pack through the REST update route (#10769). Emits Decision Trace action work_function.update.

Parameters

ParameterTypeRequiredDescription
function_idstringrequiredWork Function id.
max_cloud_workersintegerrequiredMaximum concurrent Work Function workers; maps to REST capacity max_concurrent. default: 5
actor_idstringoptionalActing principal id for Decision Trace emission. default: "mcp"
always_on_quotaintegeroptionalAlways-on worker quota. default: 0
budget_usdnumberoptionalBudget ceiling in USD. default: 100.0
foreground_reservationsintegeroptionalForeground worker reservations. default: 0
reasonstringoptionalDecision Trace reason. default: "Updated capacity from MCP"
source_packobjectoptionalCircle / Work-Function source pack (#10769): {sources:[{type,ref}], plane_default?}.
tenant_idstringoptionalOptional workspace id. Must match the authenticated MCP workspace context when provided.
zero_burn_target_usdstringoptionalZero-burn target in USD. default: "0"

inputSchema

{
  "properties": {
    "actor_id": {
      "default": "mcp",
      "description": "Acting principal id for Decision Trace emission.",
      "type": "string"
    },
    "always_on_quota": {
      "default": 0,
      "description": "Always-on worker quota.",
      "type": "integer"
    },
    "budget_usd": {
      "default": 100.0,
      "description": "Budget ceiling in USD.",
      "type": "number"
    },
    "foreground_reservations": {
      "default": 0,
      "description": "Foreground worker reservations.",
      "type": "integer"
    },
    "function_id": {
      "description": "Work Function id.",
      "type": "string"
    },
    "max_cloud_workers": {
      "default": 5,
      "description": "Maximum concurrent Work Function workers; maps to REST capacity max_concurrent.",
      "type": "integer"
    },
    "reason": {
      "default": "Updated capacity from MCP",
      "description": "Decision Trace reason.",
      "type": "string"
    },
    "source_pack": {
      "description": "Circle / Work-Function source pack (#10769): {sources:[{type,ref}], plane_default?}.",
      "type": "object"
    },
    "tenant_id": {
      "description": "Optional workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    },
    "zero_burn_target_usd": {
      "default": "0",
      "description": "Zero-burn target in USD.",
      "type": "string"
    }
  },
  "required": [
    "function_id",
    "max_cloud_workers"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.function.capacity.set", function_id="<function_id>", max_cloud_workers=0)
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.function.capacity.set", { function_id: "<function_id>", max_cloud_workers: 0 });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.function.capacity.set/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "function_id": "<function_id>",
    "max_cloud_workers": 0
  }
}'

ww.function.create

ADMIN

Create a Work Function through the REST lifecycle route. Emits Decision Trace action work_function.create.

Parameters

ParameterTypeRequiredDescription
namestringrequiredWork Function display name.
actor_idstringoptionalActing principal id for Decision Trace emission. default: "mcp"
always_on_quotaintegeroptionalAlways-on worker quota. default: 0
autonomy_levelintegeroptionalAutonomy level, 0-5. default: 2
budget_usdnumberoptionalBudget ceiling in USD. default: 100.0
connector_scopesarrayoptionalAllowed connector scopes.
coordination_protocolstringoptionalCoordination protocol. default: "auto"
foreground_reservationsintegeroptionalForeground worker reservations. default: 0
initial_statestringoptionalInitial lifecycle state. enum: dormant, active default: "active"
localitystringoptionalLocal/cloud locality preference. enum: prefer_local, prefer_cloud, local_only, cloud_only, cloud_required default: "prefer_local"
max_cloud_workersintegeroptionalMaximum concurrent Work Function workers; maps to REST capacity max_concurrent. default: 5
presetstringoptionalPreset id, e.g. marketing.
preset_idstringoptionalPreset id alias.
purposestringoptionalPurpose summary.
resource_policy_idstringoptionalResource Policy id.
source_packobjectoptionalCircle / Work-Function source pack (#10769): {sources:[{type,ref}], plane_default?}.
tenant_idstringoptionalOptional workspace id. Must match the authenticated MCP workspace context when provided.
zero_burn_target_usdstringoptionalZero-burn target in USD. default: "0"

inputSchema

{
  "properties": {
    "actor_id": {
      "default": "mcp",
      "description": "Acting principal id for Decision Trace emission.",
      "type": "string"
    },
    "always_on_quota": {
      "default": 0,
      "description": "Always-on worker quota.",
      "type": "integer"
    },
    "autonomy_level": {
      "default": 2,
      "description": "Autonomy level, 0-5.",
      "type": "integer"
    },
    "budget_usd": {
      "default": 100.0,
      "description": "Budget ceiling in USD.",
      "type": "number"
    },
    "connector_scopes": {
      "description": "Allowed connector scopes.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "coordination_protocol": {
      "default": "auto",
      "description": "Coordination protocol.",
      "type": "string"
    },
    "foreground_reservations": {
      "default": 0,
      "description": "Foreground worker reservations.",
      "type": "integer"
    },
    "initial_state": {
      "default": "active",
      "description": "Initial lifecycle state.",
      "enum": [
        "dormant",
        "active"
      ],
      "type": "string"
    },
    "locality": {
      "default": "prefer_local",
      "description": "Local/cloud locality preference.",
      "enum": [
        "prefer_local",
        "prefer_cloud",
        "local_only",
        "cloud_only",
        "cloud_required"
      ],
      "type": "string"
    },
    "max_cloud_workers": {
      "default": 5,
      "description": "Maximum concurrent Work Function workers; maps to REST capacity max_concurrent.",
      "type": "integer"
    },
    "name": {
      "description": "Work Function display name.",
      "type": "string"
    },
    "preset": {
      "description": "Preset id, e.g. marketing.",
      "type": "string"
    },
    "preset_id": {
      "description": "Preset id alias.",
      "type": "string"
    },
    "purpose": {
      "description": "Purpose summary.",
      "type": "string"
    },
    "resource_policy_id": {
      "description": "Resource Policy id.",
      "type": "string"
    },
    "source_pack": {
      "description": "Circle / Work-Function source pack (#10769): {sources:[{type,ref}], plane_default?}.",
      "properties": {
        "plane_default": {
          "type": "string"
        },
        "sources": {
          "items": {
            "properties": {
              "ref": {
                "type": "string"
              },
              "type": {
                "type": "string"
              }
            },
            "required": [
              "type",
              "ref"
            ],
            "type": "object"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "tenant_id": {
      "description": "Optional workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    },
    "zero_burn_target_usd": {
      "default": "0",
      "description": "Zero-burn target in USD.",
      "type": "string"
    }
  },
  "required": [
    "name"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.function.create", name="<name>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.function.create", { name: "<name>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.function.create/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "name": "<name>"
  }
}'

ww.function.delete

ADMIN

Tombstone a Work Function and return deletion proof. Emits Decision Trace action work_function.delete.

Parameters

ParameterTypeRequiredDescription
confirmbooleanrequiredMust be true to perform deletion. default: false
function_idstringrequiredWork Function id.
actor_idstringoptionalActing principal id for Decision Trace emission. default: "mcp"
evidence_retention_daysintegeroptionalEvidence retention window. default: 365
reasonstringoptionalDecision Trace reason. default: "Deleted from MCP"
tenant_idstringoptionalOptional workspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "actor_id": {
      "default": "mcp",
      "description": "Acting principal id for Decision Trace emission.",
      "type": "string"
    },
    "confirm": {
      "default": false,
      "description": "Must be true to perform deletion.",
      "type": "boolean"
    },
    "evidence_retention_days": {
      "default": 365,
      "description": "Evidence retention window.",
      "type": "integer"
    },
    "function_id": {
      "description": "Work Function id.",
      "type": "string"
    },
    "reason": {
      "default": "Deleted from MCP",
      "description": "Decision Trace reason.",
      "type": "string"
    },
    "tenant_id": {
      "description": "Optional workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "function_id",
    "confirm"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.function.delete", confirm=true, function_id="<function_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.function.delete", { confirm: true, function_id: "<function_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.function.delete/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "confirm": true,
    "function_id": "<function_id>"
  }
}'

ww.function.downgrade_preview

WRITE

Preview a tier downgrade through the REST route. Emits Decision Trace action work_function.downgrade_preview.

Parameters

ParameterTypeRequiredDescription
function_idstringrequiredWork Function id.
to_tierstringrequiredTarget tier id.
active_connectorsarrayoptionalActive connectors.
actor_idstringoptionalActing principal id for Decision Trace emission. default: "mcp"
from_tierstringoptionalCurrent tier id. default: "current"
tenant_idstringoptionalOptional workspace id. Must match the authenticated MCP workspace context when provided.
tier_connectorsarrayoptionalAllowed connectors.
tier_limitsobjectoptionalTarget tier numeric limits.

inputSchema

{
  "properties": {
    "active_connectors": {
      "description": "Active connectors.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "actor_id": {
      "default": "mcp",
      "description": "Acting principal id for Decision Trace emission.",
      "type": "string"
    },
    "from_tier": {
      "default": "current",
      "description": "Current tier id.",
      "type": "string"
    },
    "function_id": {
      "description": "Work Function id.",
      "type": "string"
    },
    "tenant_id": {
      "description": "Optional workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    },
    "tier_connectors": {
      "description": "Allowed connectors.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "tier_limits": {
      "description": "Target tier numeric limits.",
      "type": "object"
    },
    "to_tier": {
      "description": "Target tier id.",
      "type": "string"
    }
  },
  "required": [
    "function_id",
    "to_tier"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.function.downgrade_preview", function_id="<function_id>", to_tier="<to_tier>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.function.downgrade_preview", { function_id: "<function_id>", to_tier: "<to_tier>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.function.downgrade_preview/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "function_id": "<function_id>",
    "to_tier": "<to_tier>"
  }
}'

ww.function.list

READ

List workspace-scoped Work Functions. Emits Decision Trace action work_function.list.

Parameters

ParameterTypeRequiredDescription
tenant_idstringoptionalOptional workspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "tenant_id": {
      "description": "Optional workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.function.list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.function.list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.function.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.function.presets.list

READ

List canonical Work Function presets. Emits Decision Trace action work_function.presets.

Parameters

ParameterTypeRequiredDescription
tenant_idstringoptionalOptional workspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "tenant_id": {
      "description": "Optional workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.function.presets.list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.function.presets.list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.function.presets.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.function.quota.check

READ

Read Work Function WORM quota through the REST route. Emits Decision Trace action work_function.quota.check.

Parameters

ParameterTypeRequiredDescription
function_idstringrequiredWork Function id.
tenant_idstringoptionalOptional workspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "function_id": {
      "description": "Work Function id.",
      "type": "string"
    },
    "tenant_id": {
      "description": "Optional workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "function_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.function.quota.check", function_id="<function_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.function.quota.check", { function_id: "<function_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.function.quota.check/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "function_id": "<function_id>"
  }
}'

ww.function.quota.set

ADMIN

Set Work Function WORM quota policy through the REST route. Emits Decision Trace action work_function.quota.policy.changed, or work_function.quota.policy.denied on quota conflicts.

Parameters

ParameterTypeRequiredDescription
function_idstringrequiredWork Function id.
actor_idstringoptionalActing principal id for Decision Trace emission. default: "mcp"
artifact_retention_classstringoptionalArtifact retention class. enum: hot, warm, cold, archive default: "hot"
cold_tier_after_daysintegeroptionalDays before artifacts become cold-tier eligible.
reasonstringoptionalDecision Trace reason. default: "Updated Work Function WORM quota policy"
storage_quota_gbstring | numberoptionalWORM storage quota in GiB.
tenant_idstringoptionalOptional workspace id. Must match the authenticated MCP workspace context when provided.
workmemory_index_quota_mbstring | numberoptionalWorkMemory index quota in MiB.

inputSchema

{
  "properties": {
    "actor_id": {
      "default": "mcp",
      "description": "Acting principal id for Decision Trace emission.",
      "type": "string"
    },
    "artifact_retention_class": {
      "default": "hot",
      "description": "Artifact retention class.",
      "enum": [
        "hot",
        "warm",
        "cold",
        "archive"
      ],
      "type": "string"
    },
    "cold_tier_after_days": {
      "description": "Days before artifacts become cold-tier eligible.",
      "type": "integer"
    },
    "function_id": {
      "description": "Work Function id.",
      "type": "string"
    },
    "reason": {
      "default": "Updated Work Function WORM quota policy",
      "description": "Decision Trace reason.",
      "type": "string"
    },
    "storage_quota_gb": {
      "description": "WORM storage quota in GiB.",
      "type": [
        "string",
        "number"
      ]
    },
    "tenant_id": {
      "description": "Optional workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    },
    "workmemory_index_quota_mb": {
      "description": "WorkMemory index quota in MiB.",
      "type": [
        "string",
        "number"
      ]
    }
  },
  "required": [
    "function_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.function.quota.set", function_id="<function_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.function.quota.set", { function_id: "<function_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.function.quota.set/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "function_id": "<function_id>"
  }
}'

ww.function.reactivate

ADMIN

Reactivate an archived Work Function. Emits Decision Trace action work_function.reactivate.

Parameters

ParameterTypeRequiredDescription
function_idstringrequiredWork Function id.
actor_idstringoptionalActing principal id for Decision Trace emission. default: "mcp"
reasonstringoptionalDecision Trace reason. default: "Reactivated from MCP"
tenant_idstringoptionalOptional workspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "actor_id": {
      "default": "mcp",
      "description": "Acting principal id for Decision Trace emission.",
      "type": "string"
    },
    "function_id": {
      "description": "Work Function id.",
      "type": "string"
    },
    "reason": {
      "default": "Reactivated from MCP",
      "description": "Decision Trace reason.",
      "type": "string"
    },
    "tenant_id": {
      "description": "Optional workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "function_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.function.reactivate", function_id="<function_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.function.reactivate", { function_id: "<function_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.function.reactivate/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "function_id": "<function_id>"
  }
}'

ww.function.show

READ

Show one Work Function through the REST route. Emits Decision Trace action work_function.show.

Parameters

ParameterTypeRequiredDescription
function_idstringrequiredWork Function id.
tenant_idstringoptionalOptional workspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "function_id": {
      "description": "Work Function id.",
      "type": "string"
    },
    "tenant_id": {
      "description": "Optional workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "function_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.function.show", function_id="<function_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.function.show", { function_id: "<function_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.function.show/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "function_id": "<function_id>"
  }
}'

ww.mission.operating-method.activation

READ

Return the tenant-safe workspace operating-method activation truth: qualified | activation_held | active | rolled_back | unavailable plus the append-only receipt history (#12145). Read-only; pointer mutation stays on founder admin surfaces.

Parameters

ParameterTypeRequiredDescription
tenant_idstringoptional

inputSchema

{
  "properties": {
    "tenant_id": {
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.mission.operating-method.activation")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.mission.operating-method.activation");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.mission.operating-method.activation/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.mission.operating-method.binding

WRITE

Return the exact operating-method binding for a run: binding, release, policy, and aggregate IDs plus qualification state. Never returns prompt or customer content (#12141).

Parameters

ParameterTypeRequiredDescription
binding_idstringoptionalImmutable binding id.
run_idstringoptionalCanonical Skill run id.
tenant_idstringoptional

inputSchema

{
  "properties": {
    "binding_id": {
      "description": "Immutable binding id.",
      "type": "string"
    },
    "run_id": {
      "description": "Canonical Skill run id.",
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.mission.operating-method.binding")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.mission.operating-method.binding");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.mission.operating-method.binding/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.ontology.evolution

WRITE

Read the tenant governed business-grammar projection: proposal state, active version, coverage, and compatibility impact (#12159).

Parameters

ParameterTypeRequiredDescription
tenant_idstringoptional

inputSchema

{
  "properties": {
    "tenant_id": {
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.ontology.evolution")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.ontology.evolution");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.ontology.evolution/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.ontology.query

READ

Query the tenant ontology graph (entity schemas, instances, skills, capabilities) through the same shared query service as GET /api/v1/ontology/query and the public MCP ww.ontology.query.

Parameters

ParameterTypeRequiredDescription
kindstringoptionalOptional PrimitiveKind filter (e.g. entity_schema, entity_instance).
limitintegeroptionalMaximum nodes to return (1-100). Default 50. default: 50
qstringoptionalFree-text token query over node names/descriptions.

inputSchema

{
  "properties": {
    "kind": {
      "description": "Optional PrimitiveKind filter (e.g. entity_schema, entity_instance).",
      "type": "string"
    },
    "limit": {
      "default": 50,
      "description": "Maximum nodes to return (1-100). Default 50.",
      "type": "integer"
    },
    "q": {
      "description": "Free-text token query over node names/descriptions.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.ontology.query")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.ontology.query");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.ontology.query/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.ontology.vocabulary_packs.fork_provenance

WRITE

Fork pack provenance badge From→Modified-from after a tenant edit (#10948).

Parameters

ParameterTypeRequiredDescription
contentobjectrequiredPack-sourced entity content
tenant_idstringoptional

inputSchema

{
  "properties": {
    "content": {
      "description": "Pack-sourced entity content",
      "type": "object"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "content"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.ontology.vocabulary_packs.fork_provenance", content={})
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.ontology.vocabulary_packs.fork_provenance", { content: {} });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.ontology.vocabulary_packs.fork_provenance/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "content": {}
  }
}'

ww.ontology.vocabulary_packs.install

WRITE

Install an industry vocabulary pack via EmergenceGate proposals (#10948).

Parameters

ParameterTypeRequiredDescription
pack_idstringrequiredfibo | snomed | gs1 | schema_org
license_attestedbooleanoptionalRequired for SNOMED CT
tenant_idstringoptional

inputSchema

{
  "properties": {
    "license_attested": {
      "description": "Required for SNOMED CT",
      "type": "boolean"
    },
    "pack_id": {
      "description": "fibo | snomed | gs1 | schema_org",
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "pack_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.ontology.vocabulary_packs.install", pack_id="<pack_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.ontology.vocabulary_packs.install", { pack_id: "<pack_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.ontology.vocabulary_packs.install/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "pack_id": "<pack_id>"
  }
}'

ww.ontology.vocabulary_packs.list

READ

List industry vocabulary packs (FIBO/SNOMED/GS1/Schema.org) and install state (#10948).

Parameters

ParameterTypeRequiredDescription
tenant_idstringoptional

inputSchema

{
  "properties": {
    "tenant_id": {
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.ontology.vocabulary_packs.list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.ontology.vocabulary_packs.list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.ontology.vocabulary_packs.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.orchestrate.fanout

WRITE

Fan a goal out to multiple external ACP harnesses (Codex, Claude Code, Cursor) in parallel, capture every run into WorkMemory with provenance, and return a merged/best result.

Parameters

ParameterTypeRequiredDescription
goalstringrequiredFree-text goal handed to every harness.
harnessesarrayrequiredHarnesses to fan out to, e.g. ['codex','claude_code','cursor']. Deduplicated; unknown harness names are rejected.
budgetobjectoptionalOptional budget envelope forwarded to each leg.
strategystringoptionalAggregation strategy: best_of (first successful leg), merge (concatenate surviving legs), or all (return every leg with no single selection). enum: best_of, merge, all default: "best_of"

inputSchema

{
  "properties": {
    "budget": {
      "description": "Optional budget envelope forwarded to each leg.",
      "type": "object"
    },
    "goal": {
      "description": "Free-text goal handed to every harness.",
      "type": "string"
    },
    "harnesses": {
      "description": "Harnesses to fan out to, e.g. ['codex','claude_code','cursor']. Deduplicated; unknown harness names are rejected.",
      "items": {
        "type": "string"
      },
      "minItems": 1,
      "type": "array"
    },
    "strategy": {
      "default": "best_of",
      "description": "Aggregation strategy: best_of (first successful leg), merge (concatenate surviving legs), or all (return every leg with no single selection).",
      "enum": [
        "best_of",
        "merge",
        "all"
      ],
      "type": "string"
    }
  },
  "required": [
    "goal",
    "harnesses"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.orchestrate.fanout", goal="<goal>", harnesses=[])
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.orchestrate.fanout", { goal: "<goal>", harnesses: [] });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.orchestrate.fanout/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "goal": "<goal>",
    "harnesses": []
  }
}'

ww.orchestrate.status

READ

Show one orchestrator fan-out: per-harness legs + the selected result.

Parameters

ParameterTypeRequiredDescription
orchestration_idstringrequiredOrchestration ID returned by ww.orchestrate.fanout.

inputSchema

{
  "properties": {
    "orchestration_id": {
      "description": "Orchestration ID returned by ww.orchestrate.fanout.",
      "type": "string"
    }
  },
  "required": [
    "orchestration_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.orchestrate.status", orchestration_id="<orchestration_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.orchestrate.status", { orchestration_id: "<orchestration_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.orchestrate.status/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "orchestration_id": "<orchestration_id>"
  }
}'

ww.proposed_skills.get

READ

Fetch a single ProposedSkill row by proposal_id (#5090).

Parameters

ParameterTypeRequiredDescription
proposal_idstringrequiredProposal id (``prop_<hex>``).
tenant_idstringoptionalTenant id. Defaults to the authenticated MCP context.

inputSchema

{
  "properties": {
    "proposal_id": {
      "description": "Proposal id (``prop_<hex>``).",
      "type": "string"
    },
    "tenant_id": {
      "description": "Tenant id. Defaults to the authenticated MCP context.",
      "type": "string"
    }
  },
  "required": [
    "proposal_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.proposed_skills.get", proposal_id="<proposal_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.proposed_skills.get", { proposal_id: "<proposal_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.proposed_skills.get/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "proposal_id": "<proposal_id>"
  }
}'

ww.proposed_skills.list

READ

List ProposedSkill rows for a tenant, optionally filtered by status (pending_review | accepted | rejected | merged) (#5090).

Parameters

ParameterTypeRequiredDescription
statusstringoptionalOptional status filter. enum: pending_review, accepted, rejected, merged
tenant_idstringoptionalTenant id. Defaults to the authenticated MCP context; cross-tenant param values are rejected.

inputSchema

{
  "properties": {
    "status": {
      "description": "Optional status filter.",
      "enum": [
        "pending_review",
        "accepted",
        "rejected",
        "merged"
      ],
      "type": "string"
    },
    "tenant_id": {
      "description": "Tenant id. Defaults to the authenticated MCP context; cross-tenant param values are rejected.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.proposed_skills.list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.proposed_skills.list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.proposed_skills.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.proposed_skills.update_status

ADMIN

Transition a proposal from pending_review to accepted, rejected, or merged. Terminal states are terminal; illegal transitions return an ``illegal_transition`` error envelope (#5090).

Parameters

ParameterTypeRequiredDescription
actor_idstringrequiredReviewer id; recorded on the row as ``reviewed_by``.
proposal_idstringrequiredProposal id (``prop_<hex>``).
statusstringrequiredTarget lifecycle status. enum: pending_review, accepted, rejected, merged
tenant_idstringoptionalTenant id. Defaults to the authenticated MCP context.

inputSchema

{
  "properties": {
    "actor_id": {
      "description": "Reviewer id; recorded on the row as ``reviewed_by``.",
      "type": "string"
    },
    "proposal_id": {
      "description": "Proposal id (``prop_<hex>``).",
      "type": "string"
    },
    "status": {
      "description": "Target lifecycle status.",
      "enum": [
        "pending_review",
        "accepted",
        "rejected",
        "merged"
      ],
      "type": "string"
    },
    "tenant_id": {
      "description": "Tenant id. Defaults to the authenticated MCP context.",
      "type": "string"
    }
  },
  "required": [
    "proposal_id",
    "status",
    "actor_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.proposed_skills.update_status", actor_id="<actor_id>", proposal_id="<proposal_id>", status="pending_review")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.proposed_skills.update_status", { actor_id: "<actor_id>", proposal_id: "<proposal_id>", status: "pending_review" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.proposed_skills.update_status/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "actor_id": "<actor_id>",
    "proposal_id": "<proposal_id>",
    "status": "pending_review"
  }
}'

ww.relations.read

READ

Read the entity relation graph (RelationStore) through the same store GET /v1/relations serves. Exactly one of subject, object, or entity must be provided.

Parameters

ParameterTypeRequiredDescription
entitystringoptionalEntity ID (bidirectional edges).
limitintegeroptionalMax relations to return (1-500). Default 50. default: 50
objectstringoptionalObject entity ID (inbound edges).
relation_typestringoptionalOptional relation-type filter.
subjectstringoptionalSubject entity ID (outbound edges).

inputSchema

{
  "properties": {
    "entity": {
      "description": "Entity ID (bidirectional edges).",
      "type": "string"
    },
    "limit": {
      "default": 50,
      "description": "Max relations to return (1-500). Default 50.",
      "type": "integer"
    },
    "object": {
      "description": "Object entity ID (inbound edges).",
      "type": "string"
    },
    "relation_type": {
      "description": "Optional relation-type filter.",
      "type": "string"
    },
    "subject": {
      "description": "Subject entity ID (outbound edges).",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.relations.read")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.relations.read");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.relations.read/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.routine.list

READ

List the workspace's typed routines through the canonical routine facade.

Parameters

ParameterTypeRequiredDescription
health_statusstringoptionalOptional routine health filter.
statusstringoptionalOptional backing-schedule status filter.
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "health_status": {
      "description": "Optional routine health filter.",
      "type": "string"
    },
    "status": {
      "description": "Optional backing-schedule status filter.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.routine.list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.routine.list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.routine.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.routine.show

READ

Show one routine by id through the canonical routine facade.

Parameters

ParameterTypeRequiredDescription
routine_idstringrequiredRoutine id / backing schedule id.
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "routine_id": {
      "description": "Routine id / backing schedule id.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "routine_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.routine.show", routine_id="<routine_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.routine.show", { routine_id: "<routine_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.routine.show/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "routine_id": "<routine_id>"
  }
}'

ww.routine.update

WRITE

Update a routine control knob through the canonical routine action route. Currently supports concurrency_mode serial|swarm.

Parameters

ParameterTypeRequiredDescription
concurrency_modestringrequiredRoutine dispatch mode to persist. enum: serial, swarm
routine_idstringrequiredRoutine id / backing schedule id.
workspace_idstringrequiredWorkspace id whose routine should be updated.
actor_idstringoptionalOptional MCP actor id for audit attribution. default: "mcp"
notestringoptionalOptional operator note recorded in routine history. default: ""

inputSchema

{
  "properties": {
    "actor_id": {
      "default": "mcp",
      "description": "Optional MCP actor id for audit attribution.",
      "type": "string"
    },
    "concurrency_mode": {
      "description": "Routine dispatch mode to persist.",
      "enum": [
        "serial",
        "swarm"
      ],
      "type": "string"
    },
    "note": {
      "default": "",
      "description": "Optional operator note recorded in routine history.",
      "type": "string"
    },
    "routine_id": {
      "description": "Routine id / backing schedule id.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id whose routine should be updated.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "routine_id",
    "concurrency_mode"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.routine.update", concurrency_mode="serial", routine_id="<routine_id>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.routine.update", { concurrency_mode: "serial", routine_id: "<routine_id>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.routine.update/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "concurrency_mode": "serial",
    "routine_id": "<routine_id>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.schedule.create

WRITE

Create a schedule through the canonical Mission Schedules route. Emits a Decision Trace.

Parameters

ParameterTypeRequiredDescription
agent_idstringrequiredOwning agent/entity id.
schedule_typestringrequiredSchedule type (e.g. recurring, triggered, one_shot).
titlestringrequiredHuman-readable schedule title.
check_interval_minutesintegeroptionalPolling interval for interval-style schedules. default: 5
configobjectoptionalOptional schedule config payload.
cron_expressionstringoptionalOptional cron cadence for recurring schedules.
descriptionstringoptionalOptional schedule description. default: ""
next_run_atstringoptionalOptional ISO-8601 next-run timestamp.
routineobjectoptionalOptional routine config block.
timezonestringoptionalOptional IANA timezone for cadence evaluation.
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "agent_id": {
      "description": "Owning agent/entity id.",
      "type": "string"
    },
    "check_interval_minutes": {
      "default": 5,
      "description": "Polling interval for interval-style schedules.",
      "type": "integer"
    },
    "config": {
      "description": "Optional schedule config payload.",
      "type": "object"
    },
    "cron_expression": {
      "description": "Optional cron cadence for recurring schedules.",
      "type": "string"
    },
    "description": {
      "default": "",
      "description": "Optional schedule description.",
      "type": "string"
    },
    "next_run_at": {
      "description": "Optional ISO-8601 next-run timestamp.",
      "type": "string"
    },
    "routine": {
      "description": "Optional routine config block.",
      "type": "object"
    },
    "schedule_type": {
      "description": "Schedule type (e.g. recurring, triggered, one_shot).",
      "type": "string"
    },
    "timezone": {
      "description": "Optional IANA timezone for cadence evaluation.",
      "type": "string"
    },
    "title": {
      "description": "Human-readable schedule title.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "agent_id",
    "title",
    "schedule_type"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.schedule.create", agent_id="<agent_id>", schedule_type="<schedule_type>", title="<title>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.schedule.create", { agent_id: "<agent_id>", schedule_type: "<schedule_type>", title: "<title>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.schedule.create/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "agent_id": "<agent_id>",
    "schedule_type": "<schedule_type>",
    "title": "<title>"
  }
}'

ww.schedule.delete

WRITE

Delete a schedule through the canonical Mission Schedules route.

Parameters

ParameterTypeRequiredDescription
schedule_idstringrequiredSchedule id to delete.
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "schedule_id": {
      "description": "Schedule id to delete.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "schedule_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.schedule.delete", schedule_id="<schedule_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.schedule.delete", { schedule_id: "<schedule_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.schedule.delete/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "schedule_id": "<schedule_id>"
  }
}'

ww.schedule.list

READ

List the workspace's schedules through the canonical Mission Schedules route.

Parameters

ParameterTypeRequiredDescription
agent_idstringoptionalOptional agent/entity id filter.
limitintegeroptionalMaximum schedules to return. default: 100
schedule_typestringoptionalOptional schedule type filter.
statusstringoptionalOptional schedule status filter.
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "agent_id": {
      "description": "Optional agent/entity id filter.",
      "type": "string"
    },
    "limit": {
      "default": 100,
      "description": "Maximum schedules to return.",
      "maximum": 500,
      "minimum": 1,
      "type": "integer"
    },
    "schedule_type": {
      "description": "Optional schedule type filter.",
      "type": "string"
    },
    "status": {
      "description": "Optional schedule status filter.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.schedule.list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.schedule.list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.schedule.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.schedule.pause

WRITE

Pause a schedule through the canonical Mission Schedules route. Emits a Decision Trace.

Parameters

ParameterTypeRequiredDescription
schedule_idstringrequiredSchedule id to pause.
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "schedule_id": {
      "description": "Schedule id to pause.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "schedule_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.schedule.pause", schedule_id="<schedule_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.schedule.pause", { schedule_id: "<schedule_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.schedule.pause/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "schedule_id": "<schedule_id>"
  }
}'

ww.schedule.resume

WRITE

Resume a paused schedule through the canonical Mission Schedules route. Emits a Decision Trace.

Parameters

ParameterTypeRequiredDescription
schedule_idstringrequiredSchedule id to resume.
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "schedule_id": {
      "description": "Schedule id to resume.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "schedule_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.schedule.resume", schedule_id="<schedule_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.schedule.resume", { schedule_id: "<schedule_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.schedule.resume/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "schedule_id": "<schedule_id>"
  }
}'

ww.schedule.run_now

WRITE

Trigger an immediate run of a triggered schedule. Emits a Decision Trace.

Parameters

ParameterTypeRequiredDescription
schedule_idstringrequiredTriggered schedule id to fire.
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "schedule_id": {
      "description": "Triggered schedule id to fire.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "schedule_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.schedule.run_now", schedule_id="<schedule_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.schedule.run_now", { schedule_id: "<schedule_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.schedule.run_now/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "schedule_id": "<schedule_id>"
  }
}'

ww.schedule.show

READ

Show one schedule by id through the canonical Mission Schedules route.

Parameters

ParameterTypeRequiredDescription
schedule_idstringrequiredSchedule id to fetch.
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "schedule_id": {
      "description": "Schedule id to fetch.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "schedule_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.schedule.show", schedule_id="<schedule_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.schedule.show", { schedule_id: "<schedule_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.schedule.show/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "schedule_id": "<schedule_id>"
  }
}'

ww.schedule.update

WRITE

Update a schedule (partial) through the canonical Mission Schedules route. Emits a Decision Trace.

Parameters

ParameterTypeRequiredDescription
revisionintegerrequiredCurrent revision for optimistic locking.
schedule_idstringrequiredSchedule id to update.
check_interval_minutesintegeroptionalNew polling interval.
configobjectoptionalReplacement config payload.
cron_expressionstringoptionalNew cron cadence.
descriptionstringoptionalNew description.
next_run_atstringoptionalNew ISO-8601 next-run timestamp.
routineobjectoptionalRoutine config block to merge.
titlestringoptionalNew title.
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "check_interval_minutes": {
      "description": "New polling interval.",
      "type": "integer"
    },
    "config": {
      "description": "Replacement config payload.",
      "type": "object"
    },
    "cron_expression": {
      "description": "New cron cadence.",
      "type": "string"
    },
    "description": {
      "description": "New description.",
      "type": "string"
    },
    "next_run_at": {
      "description": "New ISO-8601 next-run timestamp.",
      "type": "string"
    },
    "revision": {
      "description": "Current revision for optimistic locking.",
      "type": "integer"
    },
    "routine": {
      "description": "Routine config block to merge.",
      "type": "object"
    },
    "schedule_id": {
      "description": "Schedule id to update.",
      "type": "string"
    },
    "title": {
      "description": "New title.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "schedule_id",
    "revision"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.schedule.update", revision=0, schedule_id="<schedule_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.schedule.update", { revision: 0, schedule_id: "<schedule_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.schedule.update/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "revision": 0,
    "schedule_id": "<schedule_id>"
  }
}'

ww.scheduler.pause

WRITE

Disable the continuous auto-replan sweep for the workspace (#8626). The dirty-flag hash is preserved so resume resumes from the right state.

Parameters

ParameterTypeRequiredDescription
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.scheduler.pause")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.scheduler.pause");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.scheduler.pause/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.scheduler.replan

WRITE

Force one adaptive replan for the workspace now (#8626). Bypasses the auto-replan pause and cadence.

Parameters

ParameterTypeRequiredDescription
itemsarrayrequiredSchedulable items to replan with (same shape as POST /api/v1/scheduler/replan).
target_datestringoptionalYYYY-MM-DD target date for the replan.
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "items": {
      "description": "Schedulable items to replan with (same shape as POST /api/v1/scheduler/replan).",
      "items": {
        "type": "object"
      },
      "type": "array"
    },
    "target_date": {
      "description": "YYYY-MM-DD target date for the replan.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "items"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.scheduler.replan", items=[])
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.scheduler.replan", { items: [] });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.scheduler.replan/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "items": []
  }
}'

ww.scheduler.resume

WRITE

Re-enable the continuous auto-replan sweep for the workspace (#8626).

Parameters

ParameterTypeRequiredDescription
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.scheduler.resume")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.scheduler.resume");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.scheduler.resume/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.scheduler.status

READ

Read the workspace auto-replan state (running/paused) and last-replan summary (#8626).

Parameters

ParameterTypeRequiredDescription
workspace_idstringoptionalWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.scheduler.status")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.scheduler.status");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.scheduler.status/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.skill.autoresearch_log

WRITE

Durable Skill research campaign job receipt (#10898).

Parameters

ParameterTypeRequiredDescription
job_refstringrequired
tenant_idstringoptional

inputSchema

{
  "properties": {
    "job_ref": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "job_ref"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.autoresearch_log", job_ref="<job_ref>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.autoresearch_log", { job_ref: "<job_ref>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.autoresearch_log/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "job_ref": "<job_ref>"
  }
}'

ww.skill.autoresearch_start

WRITE

Start one durable evaluator-owned Skill research campaign cycle (#10898).

Parameters

ParameterTypeRequiredDescription
campaign_refstringrequired
idempotency_keystringrequired
revisionintegerrequired
tenant_idstringoptional

inputSchema

{
  "properties": {
    "campaign_ref": {
      "type": "string"
    },
    "idempotency_key": {
      "type": "string"
    },
    "revision": {
      "minimum": 1,
      "type": "integer"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "campaign_ref",
    "revision",
    "idempotency_key"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.autoresearch_start", campaign_ref="<campaign_ref>", idempotency_key="<idempotency_key>", revision=0)
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.autoresearch_start", { campaign_ref: "<campaign_ref>", idempotency_key: "<idempotency_key>", revision: 0 });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.autoresearch_start/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "campaign_ref": "<campaign_ref>",
    "idempotency_key": "<idempotency_key>",
    "revision": 0
  }
}'

ww.skill.autoresearch_status

WRITE

Durable Skill research campaign job status (#10898).

Parameters

ParameterTypeRequiredDescription
job_refstringrequired
tenant_idstringoptional

inputSchema

{
  "properties": {
    "job_ref": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "job_ref"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.autoresearch_status", job_ref="<job_ref>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.autoresearch_status", { job_ref: "<job_ref>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.autoresearch_status/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "job_ref": "<job_ref>"
  }
}'

ww.skill.eval_correlation

READ

Read the per-skill weekly eval-vs-outcome MCC (Matthews Correlation Coefficient) report (tenant-scoped) (#7819). REST/CLI parity for GET /api/v1/skills/{skill_id}/eval-correlation.

Parameters

ParameterTypeRequiredDescription
skill_idstringrequiredSkill id to read the report for.
tenant_idstringoptional
week_idstringoptionalISO YYYY-Www week id; omit for the latest report.

inputSchema

{
  "properties": {
    "skill_id": {
      "description": "Skill id to read the report for.",
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    },
    "week_id": {
      "description": "ISO YYYY-Www week id; omit for the latest report.",
      "type": "string"
    }
  },
  "required": [
    "skill_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.eval_correlation", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.eval_correlation", { skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.eval_correlation/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "skill_id": "<skill_id>"
  }
}'

ww.skill.living_evidence

WRITE

Return the composed Skill living-evidence cockpit: Skill, Quality check, Live run, Record, Score, Improve, optional Practice, and allowed next actions. Missing time and cost stay unknown (#10596).

Parameters

ParameterTypeRequiredDescription
skill_idstringrequiredSkill id.
run_idstringoptionalOptional selected run id.
tenant_idstringoptional

inputSchema

{
  "properties": {
    "run_id": {
      "description": "Optional selected run id.",
      "type": "string"
    },
    "skill_id": {
      "description": "Skill id.",
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.living_evidence", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.living_evidence", { skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.living_evidence/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "skill_id": "<skill_id>"
  }
}'

ww.skill.optimize.apply

ADMIN

Apply an accepted optimisation candidate by recording a governed SkillVersion. Fails if the candidate is missing, terminal, locked by a user, or carries no candidate body (#6669).

Parameters

ParameterTypeRequiredDescription
candidate_idstringrequiredProposal id of the candidate.
actor_idstringoptionalReviewer applying the candidate.
tenant_idstringoptional

inputSchema

{
  "properties": {
    "actor_id": {
      "description": "Reviewer applying the candidate.",
      "type": "string"
    },
    "candidate_id": {
      "description": "Proposal id of the candidate.",
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "candidate_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.optimize.apply", candidate_id="<candidate_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.optimize.apply", { candidate_id: "<candidate_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.optimize.apply/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "candidate_id": "<candidate_id>"
  }
}'

ww.skill.optimize.bootstrap

WRITE

Generate a draft, review-pending optimisation benchmark for a skill from its body + capability routes + execution deltas + trace precedents. The benchmark carries BOOTSTRAP_PENDING_REVIEW and refuses to run until reviewed (#6669).

Parameters

ParameterTypeRequiredDescription
skill_bodystringrequiredThe skill markdown body.
skill_idstringrequiredTarget skill slug.
capability_routesarrayoptionalCapabilityRegistry route metadata for the skill.
execution_deltasarrayoptionalExecutionDelta clusters (repeated-work signals).
tenant_idstringoptionalTenant id. Defaults to the authenticated MCP context.
trace_precedentsarrayoptionalTrace-backed precedents; each yields a holdout-eligible case.

inputSchema

{
  "properties": {
    "capability_routes": {
      "description": "CapabilityRegistry route metadata for the skill.",
      "items": {
        "type": "object"
      },
      "type": "array"
    },
    "execution_deltas": {
      "description": "ExecutionDelta clusters (repeated-work signals).",
      "items": {
        "type": "object"
      },
      "type": "array"
    },
    "skill_body": {
      "description": "The skill markdown body.",
      "type": "string"
    },
    "skill_id": {
      "description": "Target skill slug.",
      "type": "string"
    },
    "tenant_id": {
      "description": "Tenant id. Defaults to the authenticated MCP context.",
      "type": "string"
    },
    "trace_precedents": {
      "description": "Trace-backed precedents; each yields a holdout-eligible case.",
      "items": {
        "type": "object"
      },
      "type": "array"
    }
  },
  "required": [
    "skill_id",
    "skill_body"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.optimize.bootstrap", skill_body="<skill_body>", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.optimize.bootstrap", { skill_body: "<skill_body>", skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.optimize.bootstrap/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "skill_body": "<skill_body>",
    "skill_id": "<skill_id>"
  }
}'

ww.skill.optimize.model_canary.list

READ

List bounded Skill-model canary history for one Skill (#12184).

Parameters

ParameterTypeRequiredDescription
skill_idstringrequired
cursorstringoptional
limitintegeroptional
statestringoptional
tenant_idstringoptional

inputSchema

{
  "properties": {
    "cursor": {
      "type": "string"
    },
    "limit": {
      "type": "integer"
    },
    "skill_id": {
      "type": "string"
    },
    "state": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.optimize.model_canary.list", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.optimize.model_canary.list", { skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.optimize.model_canary.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "skill_id": "<skill_id>"
  }
}'

ww.skill.optimize.model_canary.read

WRITE

Read one durable Skill-model canary generation (#12184).

Parameters

ParameterTypeRequiredDescription
canary_idstringrequired
skill_idstringrequired
tenant_idstringoptional

inputSchema

{
  "properties": {
    "canary_id": {
      "type": "string"
    },
    "skill_id": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "canary_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.optimize.model_canary.read", canary_id="<canary_id>", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.optimize.model_canary.read", { canary_id: "<canary_id>", skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.optimize.model_canary.read/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "canary_id": "<canary_id>",
    "skill_id": "<skill_id>"
  }
}'

ww.skill.optimize.model_canary.start

WRITE

Start one bounded Skill-model canary generation from an unexpired qualification receipt (#12184). The server derives arms, family identity, and assignment; callers cannot supply routing authority.

Parameters

ParameterTypeRequiredDescription
bounds_policy_refstringrequiredFrozen monitoring plan/bounds ref.
idempotency_keystringrequired
qualification_refstringrequiredUnexpired #11408 qualification receipt ref.
skill_idstringrequired
expected_active_snapshot_or_baseline_generation_refstringoptional
route_slotstringoptionalExact inference route slot under canary.
tenant_idstringoptional

inputSchema

{
  "properties": {
    "bounds_policy_ref": {
      "description": "Frozen monitoring plan/bounds ref.",
      "type": "string"
    },
    "expected_active_snapshot_or_baseline_generation_ref": {
      "type": "string"
    },
    "idempotency_key": {
      "type": "string"
    },
    "qualification_ref": {
      "description": "Unexpired #11408 qualification receipt ref.",
      "type": "string"
    },
    "route_slot": {
      "description": "Exact inference route slot under canary.",
      "type": "string"
    },
    "skill_id": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "qualification_ref",
    "bounds_policy_ref",
    "idempotency_key"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.optimize.model_canary.start", bounds_policy_ref="<bounds_policy_ref>", idempotency_key="<idempotency_key>", qualification_ref="<qualification_ref>", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.optimize.model_canary.start", { bounds_policy_ref: "<bounds_policy_ref>", idempotency_key: "<idempotency_key>", qualification_ref: "<qualification_ref>", skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.optimize.model_canary.start/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "bounds_policy_ref": "<bounds_policy_ref>",
    "idempotency_key": "<idempotency_key>",
    "qualification_ref": "<qualification_ref>",
    "skill_id": "<skill_id>"
  }
}'

ww.skill.optimize.model_canary.stop

WRITE

Stop a Skill-model canary; new candidate allocation is fenced (#12184).

Parameters

ParameterTypeRequiredDescription
canary_idstringrequired
skill_idstringrequired
reasonstringoptional
tenant_idstringoptional

inputSchema

{
  "properties": {
    "canary_id": {
      "type": "string"
    },
    "reason": {
      "type": "string"
    },
    "skill_id": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "canary_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.optimize.model_canary.stop", canary_id="<canary_id>", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.optimize.model_canary.stop", { canary_id: "<canary_id>", skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.optimize.model_canary.stop/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "canary_id": "<canary_id>",
    "skill_id": "<skill_id>"
  }
}'

ww.skill.optimize.model_certificate

WRITE

Read the latest signed Skill-model certificate for one Skill version (#11408).

Parameters

ParameterTypeRequiredDescription
skill_idstringrequired
skill_versionstringrequired
tenant_idstringoptional

inputSchema

{
  "properties": {
    "skill_id": {
      "type": "string"
    },
    "skill_version": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "skill_version"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.optimize.model_certificate", skill_id="<skill_id>", skill_version="<skill_version>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.optimize.model_certificate", { skill_id: "<skill_id>", skill_version: "<skill_version>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.optimize.model_certificate/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "skill_id": "<skill_id>",
    "skill_version": "<skill_version>"
  }
}'

ww.skill.optimize.model_proof

WRITE

Request offline proof for a cheaper Skill-revision model candidate and emit a signed certificate (#11408). Does not change live routing.

Parameters

ParameterTypeRequiredDescription
baselineobjectrequired
candidateobjectrequired
instruction_manifest_shastringrequired
skill_content_shastringrequired
skill_idstringrequired
skill_versionstringrequired
casesarrayoptional
deterministicbooleanoptional
eval_manifestobjectoptional
evidence_countsobjectoptional
outcome_variancestringoptional
risk_tierstringoptional
tenant_idstringoptional

inputSchema

{
  "properties": {
    "baseline": {
      "type": "object"
    },
    "candidate": {
      "type": "object"
    },
    "cases": {
      "items": {
        "type": "object"
      },
      "type": "array"
    },
    "deterministic": {
      "type": "boolean"
    },
    "eval_manifest": {
      "type": "object"
    },
    "evidence_counts": {
      "type": "object"
    },
    "instruction_manifest_sha": {
      "type": "string"
    },
    "outcome_variance": {
      "type": "string"
    },
    "risk_tier": {
      "type": "string"
    },
    "skill_content_sha": {
      "type": "string"
    },
    "skill_id": {
      "type": "string"
    },
    "skill_version": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "skill_version",
    "skill_content_sha",
    "instruction_manifest_sha",
    "baseline",
    "candidate"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.optimize.model_proof", baseline={}, candidate={}, instruction_manifest_sha="<instruction_manifest_sha>", skill_content_sha="<skill_content_sha>", skill_id="<skill_id>", skill_version="<skill_version>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.optimize.model_proof", { baseline: {}, candidate: {}, instruction_manifest_sha: "<instruction_manifest_sha>", skill_content_sha: "<skill_content_sha>", skill_id: "<skill_id>", skill_version: "<skill_version>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.optimize.model_proof/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "baseline": {},
    "candidate": {},
    "instruction_manifest_sha": "<instruction_manifest_sha>",
    "skill_content_sha": "<skill_content_sha>",
    "skill_id": "<skill_id>",
    "skill_version": "<skill_version>"
  }
}'

ww.skill.optimize.reject

ADMIN

Reject an optimisation candidate, closing its proposal (#6669).

Parameters

ParameterTypeRequiredDescription
candidate_idstringrequired
actor_idstringoptional
reasonstringoptionalRejection rationale.
tenant_idstringoptional

inputSchema

{
  "properties": {
    "actor_id": {
      "type": "string"
    },
    "candidate_id": {
      "type": "string"
    },
    "reason": {
      "description": "Rejection rationale.",
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "candidate_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.optimize.reject", candidate_id="<candidate_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.optimize.reject", { candidate_id: "<candidate_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.optimize.reject/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "candidate_id": "<candidate_id>"
  }
}'

ww.skill.optimize.run

WRITE

Run a bounded skill optimisation pass against a reviewed benchmark. dry_run returns a cost estimate with no LLM call; a pending-review benchmark is refused (#6669).

Parameters

ParameterTypeRequiredDescription
benchmarkobjectrequiredA SkillOptimizationBenchmark object.
skill_idstringrequired
allow_small_selectionbooleanoptionalApprove a selection set below the size floor.
dry_runbooleanoptionalEstimate cost only.
epsilonnumberoptionalSelection-gate epsilon.
max_cost_usdnumberoptionalCost ceiling for the run.
tenant_idstringoptional

inputSchema

{
  "properties": {
    "allow_small_selection": {
      "description": "Approve a selection set below the size floor.",
      "type": "boolean"
    },
    "benchmark": {
      "description": "A SkillOptimizationBenchmark object.",
      "type": "object"
    },
    "dry_run": {
      "description": "Estimate cost only.",
      "type": "boolean"
    },
    "epsilon": {
      "description": "Selection-gate epsilon.",
      "type": "number"
    },
    "max_cost_usd": {
      "description": "Cost ceiling for the run.",
      "type": "number"
    },
    "skill_id": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "benchmark"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.optimize.run", benchmark={}, skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.optimize.run", { benchmark: {}, skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.optimize.run/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "benchmark": {},
    "skill_id": "<skill_id>"
  }
}'

ww.skill.optimize.status

READ

Read a persisted skill optimisation run receipt (tenant-scoped) (#6669).

Parameters

ParameterTypeRequiredDescription
run_idstringrequiredRun id (``skopt_<hex>``).
tenant_idstringoptional

inputSchema

{
  "properties": {
    "run_id": {
      "description": "Run id (``skopt_<hex>``).",
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "run_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.optimize.status", run_id="<run_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.optimize.status", { run_id: "<run_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.optimize.status/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "run_id": "<run_id>"
  }
}'

ww.skill.practice_corpus.curate

WRITE

Review a Practice candidate (promote, reject, redact, merge, or non_generalizable). Authors cannot promote into the gate channel (#10597).

Parameters

ParameterTypeRequiredDescription
candidate_idstringrequired
decisionstringrequired enum: promote, reject, redact, merge, non_generalizable
reasonstringrequired
skill_idstringrequired
target_channelstringoptional enum: practice, selection
tenant_idstringoptional

inputSchema

{
  "properties": {
    "candidate_id": {
      "type": "string"
    },
    "decision": {
      "enum": [
        "promote",
        "reject",
        "redact",
        "merge",
        "non_generalizable"
      ],
      "type": "string"
    },
    "reason": {
      "type": "string"
    },
    "skill_id": {
      "type": "string"
    },
    "target_channel": {
      "enum": [
        "practice",
        "selection"
      ],
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "candidate_id",
    "decision",
    "reason"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.practice_corpus.curate", candidate_id="<candidate_id>", decision="promote", reason="<reason>", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.practice_corpus.curate", { candidate_id: "<candidate_id>", decision: "promote", reason: "<reason>", skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.practice_corpus.curate/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "candidate_id": "<candidate_id>",
    "decision": "promote",
    "reason": "<reason>",
    "skill_id": "<skill_id>"
  }
}'

ww.skill.practice_corpus.list

READ

List visible Practice cases and pending review candidates for a Skill. Optimizer-blind gate items are never returned (#10597).

Parameters

ParameterTypeRequiredDescription
skill_idstringrequiredSkill id.
tenant_idstringoptional

inputSchema

{
  "properties": {
    "skill_id": {
      "description": "Skill id.",
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.practice_corpus.list", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.practice_corpus.list", { skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.practice_corpus.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "skill_id": "<skill_id>"
  }
}'

ww.skill.practice_transcript.edit

WRITE

Append a CAS-safe Practice transcript edit (#10779).

Parameters

ParameterTypeRequiredDescription
case_idstringrequired
contentobjectrequired
expected_active_versionintegerrequired
skill_idstringrequired
idempotency_keystringoptional
reasonstringoptional
tenant_idstringoptional

inputSchema

{
  "properties": {
    "case_id": {
      "type": "string"
    },
    "content": {
      "type": "object"
    },
    "expected_active_version": {
      "type": "integer"
    },
    "idempotency_key": {
      "type": "string"
    },
    "reason": {
      "type": "string"
    },
    "skill_id": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "case_id",
    "content",
    "expected_active_version"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.practice_transcript.edit", case_id="<case_id>", content={}, expected_active_version=0, skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.practice_transcript.edit", { case_id: "<case_id>", content: {}, expected_active_version: 0, skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.practice_transcript.edit/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "case_id": "<case_id>",
    "content": {},
    "expected_active_version": 0,
    "skill_id": "<skill_id>"
  }
}'

ww.skill.practice_transcript.get

READ

Read the active Practice transcript tip for a Skill case (#10779).

Parameters

ParameterTypeRequiredDescription
case_idstringrequired
skill_idstringrequired
tenant_idstringoptional
transcript_idstringoptional

inputSchema

{
  "properties": {
    "case_id": {
      "type": "string"
    },
    "skill_id": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    },
    "transcript_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "case_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.practice_transcript.get", case_id="<case_id>", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.practice_transcript.get", { case_id: "<case_id>", skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.practice_transcript.get/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "case_id": "<case_id>",
    "skill_id": "<skill_id>"
  }
}'

ww.skill.practice_transcript.list

READ

Keyset-paginated Practice transcript version history (#10779).

Parameters

ParameterTypeRequiredDescription
case_idstringrequired
skill_idstringrequired
cursorstringoptional
limitintegeroptional
tenant_idstringoptional

inputSchema

{
  "properties": {
    "case_id": {
      "type": "string"
    },
    "cursor": {
      "type": "string"
    },
    "limit": {
      "type": "integer"
    },
    "skill_id": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "case_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.practice_transcript.list", case_id="<case_id>", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.practice_transcript.list", { case_id: "<case_id>", skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.practice_transcript.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "case_id": "<case_id>",
    "skill_id": "<skill_id>"
  }
}'

ww.skill.practice_transcript.revoke

WRITE

Revoke a Practice transcript version without deleting bytes (#10779).

Parameters

ParameterTypeRequiredDescription
case_idstringrequired
reasonstringrequired
skill_idstringrequired
versionintegerrequired
idempotency_keystringoptional
tenant_idstringoptional

inputSchema

{
  "properties": {
    "case_id": {
      "type": "string"
    },
    "idempotency_key": {
      "type": "string"
    },
    "reason": {
      "type": "string"
    },
    "skill_id": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    },
    "version": {
      "type": "integer"
    }
  },
  "required": [
    "skill_id",
    "case_id",
    "version",
    "reason"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.practice_transcript.revoke", case_id="<case_id>", reason="<reason>", skill_id="<skill_id>", version=0)
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.practice_transcript.revoke", { case_id: "<case_id>", reason: "<reason>", skill_id: "<skill_id>", version: 0 });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.practice_transcript.revoke/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "case_id": "<case_id>",
    "reason": "<reason>",
    "skill_id": "<skill_id>",
    "version": 0
  }
}'

ww.skill.practice_transcript.rollback

WRITE

Rollback a Practice transcript by appending a restored tip (#10779).

Parameters

ParameterTypeRequiredDescription
case_idstringrequired
expected_active_versionintegerrequired
skill_idstringrequired
to_versionintegerrequired
idempotency_keystringoptional
tenant_idstringoptional

inputSchema

{
  "properties": {
    "case_id": {
      "type": "string"
    },
    "expected_active_version": {
      "type": "integer"
    },
    "idempotency_key": {
      "type": "string"
    },
    "skill_id": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    },
    "to_version": {
      "type": "integer"
    }
  },
  "required": [
    "skill_id",
    "case_id",
    "to_version",
    "expected_active_version"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.practice_transcript.rollback", case_id="<case_id>", expected_active_version=0, skill_id="<skill_id>", to_version=0)
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.practice_transcript.rollback", { case_id: "<case_id>", expected_active_version: 0, skill_id: "<skill_id>", to_version: 0 });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.practice_transcript.rollback/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "case_id": "<case_id>",
    "expected_active_version": 0,
    "skill_id": "<skill_id>",
    "to_version": 0
  }
}'

ww.skill.practice_transcript.seed

WRITE

Seed the immutable original Practice transcript (#10779).

Parameters

ParameterTypeRequiredDescription
case_idstringrequired
contentobjectrequired
skill_idstringrequired
idempotency_keystringoptional
reasonstringoptional
tenant_idstringoptional

inputSchema

{
  "properties": {
    "case_id": {
      "type": "string"
    },
    "content": {
      "type": "object"
    },
    "idempotency_key": {
      "type": "string"
    },
    "reason": {
      "type": "string"
    },
    "skill_id": {
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "case_id",
    "content"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.practice_transcript.seed", case_id="<case_id>", content={}, skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.practice_transcript.seed", { case_id: "<case_id>", content: {}, skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.practice_transcript.seed/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "case_id": "<case_id>",
    "content": {},
    "skill_id": "<skill_id>"
  }
}'

ww.skill.quality_timeline

WRITE

Return one immutable Skill quality and learning timeline: bounded newest-first pages with a tamper-evident cursor, honest missingness states (never zero-filled), and an optional compact comparable efficiency series. Customer-facing only; never exposes internal costs or private reasoning (#11386).

Parameters

ParameterTypeRequiredDescription
skill_idstringrequiredSkill package id.
cursorstringoptionalOpaque keyset cursor from a previous page.
include_pointsbooleanoptionalAttach the compact comparable series summary.
limitintegeroptionalPage size (1-200). Defaults to 50.
tenant_idstringoptional

inputSchema

{
  "properties": {
    "cursor": {
      "description": "Opaque keyset cursor from a previous page.",
      "type": "string"
    },
    "include_points": {
      "description": "Attach the compact comparable series summary.",
      "type": "boolean"
    },
    "limit": {
      "description": "Page size (1-200). Defaults to 50.",
      "type": "integer"
    },
    "skill_id": {
      "description": "Skill package id.",
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.quality_timeline", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.quality_timeline", { skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.quality_timeline/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "skill_id": "<skill_id>"
  }
}'

ww.skill.run.contract

WRITE

Resolve the exact active Skill package, authority, and bounded input/output schemas.

Parameters

ParameterTypeRequiredDescription
skill_idstringrequired

inputSchema

{
  "properties": {
    "skill_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.run.contract", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.run.contract", { skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.run.contract/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "skill_id": "<skill_id>"
  }
}'

ww.skill.run.economics

WRITE

Return truthful per-Skill-run usage units, customer amount, amount status, and coverage from the canonical usage ledger. Returns customer-facing amounts only (#11406).

Parameters

ParameterTypeRequiredDescription
run_idstringrequiredCanonical Skill run id.
skill_idstringrequiredSkill package id.
leg_cursorstringoptionalOptional keyset cursor for legs.
leg_limitintegeroptionalPage size for execution legs.
tenant_idstringoptional

inputSchema

{
  "properties": {
    "leg_cursor": {
      "description": "Optional keyset cursor for legs.",
      "type": "string"
    },
    "leg_limit": {
      "description": "Page size for execution legs.",
      "type": "integer"
    },
    "run_id": {
      "description": "Canonical Skill run id.",
      "type": "string"
    },
    "skill_id": {
      "description": "Skill package id.",
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "run_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.run.economics", run_id="<run_id>", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.run.economics", { run_id: "<run_id>", skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.run.economics/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "run_id": "<run_id>",
    "skill_id": "<skill_id>"
  }
}'

ww.skill.run.submit

WRITE

Submit editable input values against a resolved Skill run contract generation.

Parameters

ParameterTypeRequiredDescription
contract_etagstringrequired
expected_generationstringrequired
idempotency_keystringrequired
input_dataobjectrequired
skill_idstringrequired

inputSchema

{
  "properties": {
    "contract_etag": {
      "type": "string"
    },
    "expected_generation": {
      "type": "string"
    },
    "idempotency_key": {
      "type": "string"
    },
    "input_data": {
      "type": "object"
    },
    "skill_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "input_data",
    "idempotency_key",
    "expected_generation",
    "contract_etag"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.run.submit", contract_etag="<contract_etag>", expected_generation="<expected_generation>", idempotency_key="<idempotency_key>", input_data={}, skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.run.submit", { contract_etag: "<contract_etag>", expected_generation: "<expected_generation>", idempotency_key: "<idempotency_key>", input_data: {}, skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.run.submit/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "contract_etag": "<contract_etag>",
    "expected_generation": "<expected_generation>",
    "idempotency_key": "<idempotency_key>",
    "input_data": {},
    "skill_id": "<skill_id>"
  }
}'

ww.skill.run.view

WRITE

Read durable Skill run lifecycle, typed output, observation state, and references.

Parameters

ParameterTypeRequiredDescription
run_idstringrequired
skill_idstringrequired

inputSchema

{
  "properties": {
    "run_id": {
      "type": "string"
    },
    "skill_id": {
      "type": "string"
    }
  },
  "required": [
    "skill_id",
    "run_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.skill.run.view", run_id="<run_id>", skill_id="<skill_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.skill.run.view", { run_id: "<run_id>", skill_id: "<skill_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.skill.run.view/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "run_id": "<run_id>",
    "skill_id": "<skill_id>"
  }
}'

ww.swarm.cancel

WRITE

Cancel a pending or running swarm execution.

Parameters

ParameterTypeRequiredDescription
execution_idstringrequiredSwarm execution ID to cancel.
reasonstringoptionalOptional cancellation reason for audit evidence.

inputSchema

{
  "properties": {
    "execution_id": {
      "description": "Swarm execution ID to cancel.",
      "type": "string"
    },
    "reason": {
      "description": "Optional cancellation reason for audit evidence.",
      "type": "string"
    }
  },
  "required": [
    "execution_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.swarm.cancel", execution_id="<execution_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.swarm.cancel", { execution_id: "<execution_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.swarm.cancel/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "execution_id": "<execution_id>"
  }
}'

ww.swarm.spawn

WRITE

Plan and start a swarm execution from a free-text goal plus budget envelope.

Parameters

ParameterTypeRequiredDescription
goalstringrequiredFree-text goal for the swarm to execute.
auto_approve_tierstringoptionalComma-separated tiers allowed to auto-execute. Only low and medium are accepted. default: "low,medium"
budgetstringoptionalBudget axes as tokens=N,dollars=N,wall=Ns,steps=N.
plan_modestringoptionalPlanner mode override. enum: emergent, self_organizing_emergent, rigid
until_donebooleanoptionalPoll until completed, failed, or cancelled. default: false

inputSchema

{
  "properties": {
    "auto_approve_tier": {
      "default": "low,medium",
      "description": "Comma-separated tiers allowed to auto-execute. Only low and medium are accepted.",
      "type": "string"
    },
    "budget": {
      "description": "Budget axes as tokens=N,dollars=N,wall=Ns,steps=N.",
      "type": "string"
    },
    "goal": {
      "description": "Free-text goal for the swarm to execute.",
      "type": "string"
    },
    "plan_mode": {
      "description": "Planner mode override.",
      "enum": [
        "emergent",
        "self_organizing_emergent",
        "rigid"
      ],
      "type": "string"
    },
    "until_done": {
      "default": false,
      "description": "Poll until completed, failed, or cancelled.",
      "type": "boolean"
    }
  },
  "required": [
    "goal"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.swarm.spawn", goal="<goal>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.swarm.spawn", { goal: "<goal>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.swarm.spawn/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "goal": "<goal>"
  }
}'

ww.swarm.status

READ

List active swarm executions or show one swarm execution.

Parameters

ParameterTypeRequiredDescription
execution_idstringoptionalOptional swarm execution ID to inspect.
limitintegeroptionalMaximum executions to return when listing. default: 50
statusstringoptionalOptional list filter: active, admitted, running, completed, failed, or cancelled. default: "active"

inputSchema

{
  "properties": {
    "execution_id": {
      "description": "Optional swarm execution ID to inspect.",
      "type": "string"
    },
    "limit": {
      "default": 50,
      "description": "Maximum executions to return when listing.",
      "type": "integer"
    },
    "status": {
      "default": "active",
      "description": "Optional list filter: active, admitted, running, completed, failed, or cancelled.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.swarm.status")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.swarm.status");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.swarm.status/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.telephony.list

READ

List the workspace's provisioned telephony numbers.

Parameters

ParameterTypeRequiredDescription
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.telephony.list", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.telephony.list", { workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.telephony.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "workspace_id": "<workspace_id>"
  }
}'

ww.telephony.provision

WRITE

Provision a telephony number for the workspace.

Parameters

ParameterTypeRequiredDescription
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.
area_codestringoptionalOptional desired area code.
capabilitiesarrayoptionalOptional capabilities.
country_codestringoptionalOptional country code.
forward_tostringoptionalOptional forwarding target.
labelstringoptionalOptional friendly label.
routing_targetstringoptionalOptional routing target.

inputSchema

{
  "properties": {
    "area_code": {
      "description": "Optional desired area code.",
      "type": "string"
    },
    "capabilities": {
      "description": "Optional capabilities.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "country_code": {
      "description": "Optional country code.",
      "type": "string"
    },
    "forward_to": {
      "description": "Optional forwarding target.",
      "type": "string"
    },
    "label": {
      "description": "Optional friendly label.",
      "type": "string"
    },
    "routing_target": {
      "description": "Optional routing target.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.telephony.provision", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.telephony.provision", { workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.telephony.provision/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "workspace_id": "<workspace_id>"
  }
}'

ww.telephony.release

WRITE

Release a provisioned telephony number.

Parameters

ParameterTypeRequiredDescription
sidstringrequiredProvider SID of the number to release.
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "sid": {
      "description": "Provider SID of the number to release.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "sid"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.telephony.release", sid="<sid>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.telephony.release", { sid: "<sid>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.telephony.release/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "sid": "<sid>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.telephony.route

WRITE

Update routing for a provisioned telephony number.

Parameters

ParameterTypeRequiredDescription
routing_targetstringrequiredRouting target.
sidstringrequiredProvider SID of the number to route.
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.
business_hours_onlybooleanoptionalRestrict routing to business hours.
forward_tostringoptionalOptional forwarding target.
greeting_messagestringoptionalOptional greeting message.

inputSchema

{
  "properties": {
    "business_hours_only": {
      "description": "Restrict routing to business hours.",
      "type": "boolean"
    },
    "forward_to": {
      "description": "Optional forwarding target.",
      "type": "string"
    },
    "greeting_message": {
      "description": "Optional greeting message.",
      "type": "string"
    },
    "routing_target": {
      "description": "Routing target.",
      "type": "string"
    },
    "sid": {
      "description": "Provider SID of the number to route.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "sid",
    "routing_target"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.telephony.route", routing_target="<routing_target>", sid="<sid>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.telephony.route", { routing_target: "<routing_target>", sid: "<sid>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.telephony.route/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "routing_target": "<routing_target>",
    "sid": "<sid>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.tenant.condition_capacity.show

READ

Return the tenant Condition & Capacity projection. Unknown and missing required sources stay unknown; no composite score (#11515).

Parameters

ParameterTypeRequiredDescription
tenant_idstringoptional

inputSchema

{
  "properties": {
    "tenant_id": {
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.tenant.condition_capacity.show")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.tenant.condition_capacity.show");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.tenant.condition_capacity.show/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.tenant.slo.show

READ

Return tenant-scoped Mission operating measures as canonical observed measures. Never invents zeros or leaks Workweaver cost-tier or MemoryBench (#5025).

Parameters

ParameterTypeRequiredDescription
tenant_idstringoptional

inputSchema

{
  "properties": {
    "tenant_id": {
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.tenant.slo.show")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.tenant.slo.show");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.tenant.slo.show/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.timeblock.create

WRITE

Create a TimeBlock on the Mission calendar. Requires workspace_id, owner_id, start_utc, end_utc, title.

Parameters

ParameterTypeRequiredDescription
end_utcstringrequiredISO 8601 block end (strictly after start).
owner_idstringrequiredOwning agent id.
start_utcstringrequiredISO 8601 block start.
titlestringrequiredHuman/objective-readable title.
workspace_idstringrequiredWorkspace the block belongs to.
forcebooleanoptionalSkip overlap-conflict detection (recorded in metadata). Default false. default: false
intentstringoptionalOptional plan/intent text.

inputSchema

{
  "properties": {
    "end_utc": {
      "description": "ISO 8601 block end (strictly after start).",
      "type": "string"
    },
    "force": {
      "default": false,
      "description": "Skip overlap-conflict detection (recorded in metadata). Default false.",
      "type": "boolean"
    },
    "intent": {
      "description": "Optional plan/intent text.",
      "type": "string"
    },
    "owner_id": {
      "description": "Owning agent id.",
      "type": "string"
    },
    "start_utc": {
      "description": "ISO 8601 block start.",
      "type": "string"
    },
    "title": {
      "description": "Human/objective-readable title.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace the block belongs to.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "owner_id",
    "start_utc",
    "end_utc",
    "title"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.timeblock.create", end_utc="<end_utc>", owner_id="<owner_id>", start_utc="<start_utc>", title="<title>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.timeblock.create", { end_utc: "<end_utc>", owner_id: "<owner_id>", start_utc: "<start_utc>", title: "<title>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.timeblock.create/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "end_utc": "<end_utc>",
    "owner_id": "<owner_id>",
    "start_utc": "<start_utc>",
    "title": "<title>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.timeblock.delete

WRITE

Soft-delete a TimeBlock (state → CANCELLED; audit row preserved).

Parameters

ParameterTypeRequiredDescription
idstringrequiredTimeBlock id.

inputSchema

{
  "properties": {
    "id": {
      "description": "TimeBlock id.",
      "type": "string"
    }
  },
  "required": [
    "id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.timeblock.delete", id="<id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.timeblock.delete", { id: "<id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.timeblock.delete/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "id": "<id>"
  }
}'

ww.timeblock.list

READ

List Mission-calendar TimeBlocks. Same ledger and envelope as the public ww.timeblock.list.

Parameters

ParameterTypeRequiredDescription
cursorstringoptionalOpaque pagination cursor.
limitintegeroptionalPage size (1-500). Default 50. default: 50
ownerstringoptionalFilter by owner (agent) id.
sincestringoptionalISO 8601 window start filter.
untilstringoptionalISO 8601 window end filter.
workspace_idstringoptionalOptional workspace filter.

inputSchema

{
  "properties": {
    "cursor": {
      "description": "Opaque pagination cursor.",
      "type": "string"
    },
    "limit": {
      "default": 50,
      "description": "Page size (1-500). Default 50.",
      "type": "integer"
    },
    "owner": {
      "description": "Filter by owner (agent) id.",
      "type": "string"
    },
    "since": {
      "description": "ISO 8601 window start filter.",
      "type": "string"
    },
    "until": {
      "description": "ISO 8601 window end filter.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Optional workspace filter.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.timeblock.list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.timeblock.list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.timeblock.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.timeblock.move

WRITE

Atomically move a TimeBlock to a new window.

Parameters

ParameterTypeRequiredDescription
idstringrequiredTimeBlock id.
new_end_utcstringrequiredNew ISO 8601 end.
new_start_utcstringrequiredNew ISO 8601 start.
forcebooleanoptionalSkip overlap-conflict detection. default: false

inputSchema

{
  "properties": {
    "force": {
      "default": false,
      "description": "Skip overlap-conflict detection.",
      "type": "boolean"
    },
    "id": {
      "description": "TimeBlock id.",
      "type": "string"
    },
    "new_end_utc": {
      "description": "New ISO 8601 end.",
      "type": "string"
    },
    "new_start_utc": {
      "description": "New ISO 8601 start.",
      "type": "string"
    }
  },
  "required": [
    "id",
    "new_start_utc",
    "new_end_utc"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.timeblock.move", id="<id>", new_end_utc="<new_end_utc>", new_start_utc="<new_start_utc>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.timeblock.move", { id: "<id>", new_end_utc: "<new_end_utc>", new_start_utc: "<new_start_utc>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.timeblock.move/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "id": "<id>",
    "new_end_utc": "<new_end_utc>",
    "new_start_utc": "<new_start_utc>"
  }
}'

ww.timeblock.show

READ

Show one TimeBlock by id.

Parameters

ParameterTypeRequiredDescription
idstringrequiredTimeBlock id.

inputSchema

{
  "properties": {
    "id": {
      "description": "TimeBlock id.",
      "type": "string"
    }
  },
  "required": [
    "id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.timeblock.show", id="<id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.timeblock.show", { id: "<id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.timeblock.show/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "id": "<id>"
  }
}'

ww.timeblock.update

WRITE

Patch a non-terminal TimeBlock's title, intent, or window.

Parameters

ParameterTypeRequiredDescription
idstringrequiredTimeBlock id.
end_utcstringoptionalNew ISO 8601 end.
forcebooleanoptionalSkip overlap-conflict detection. default: false
intentstringoptionalNew plan/intent text.
start_utcstringoptionalNew ISO 8601 start.
titlestringoptionalNew title.

inputSchema

{
  "properties": {
    "end_utc": {
      "description": "New ISO 8601 end.",
      "type": "string"
    },
    "force": {
      "default": false,
      "description": "Skip overlap-conflict detection.",
      "type": "boolean"
    },
    "id": {
      "description": "TimeBlock id.",
      "type": "string"
    },
    "intent": {
      "description": "New plan/intent text.",
      "type": "string"
    },
    "start_utc": {
      "description": "New ISO 8601 start.",
      "type": "string"
    },
    "title": {
      "description": "New title.",
      "type": "string"
    }
  },
  "required": [
    "id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.timeblock.update", id="<id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.timeblock.update", { id: "<id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.timeblock.update/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "id": "<id>"
  }
}'

ww.tools.search

READ

Search the canonical MCP tool catalog by natural-language intent or domain. Returns compact catalog rows so thin harnesses can discover tools outside their initial capability profile (#5015).

Parameters

ParameterTypeRequiredDescription
domainstringoptionalOptional canonical domain prefix to filter by, e.g. 'ww.workflow', 'ww.channel', 'memory'.
intentstringoptionalNatural-language action or goal to resolve.
limitintegeroptionalMaximum matches to return. default: 10

inputSchema

{
  "properties": {
    "domain": {
      "description": "Optional canonical domain prefix to filter by, e.g. 'ww.workflow', 'ww.channel', 'memory'.",
      "type": "string"
    },
    "intent": {
      "description": "Natural-language action or goal to resolve.",
      "type": "string"
    },
    "limit": {
      "default": 10,
      "description": "Maximum matches to return.",
      "type": "integer"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.tools.search")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.tools.search");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.tools.search/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.upgrades.approve

WRITE

Approve an upgrade proposal.

Parameters

ParameterTypeRequiredDescription
proposal_idstringrequiredUpgrade proposal ID.
actor_idstringoptionalApproving actor ID. default: "mcp"

inputSchema

{
  "properties": {
    "actor_id": {
      "default": "mcp",
      "description": "Approving actor ID.",
      "type": "string"
    },
    "proposal_id": {
      "description": "Upgrade proposal ID.",
      "type": "string"
    }
  },
  "required": [
    "proposal_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.upgrades.approve", proposal_id="<proposal_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.upgrades.approve", { proposal_id: "<proposal_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.upgrades.approve/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "proposal_id": "<proposal_id>"
  }
}'

ww.upgrades.dismiss

WRITE

Dismiss an upgrade proposal for 90 days.

Parameters

ParameterTypeRequiredDescription
proposal_idstringrequiredUpgrade proposal ID.
actor_idstringoptionalDismissing actor ID. default: "mcp"

inputSchema

{
  "properties": {
    "actor_id": {
      "default": "mcp",
      "description": "Dismissing actor ID.",
      "type": "string"
    },
    "proposal_id": {
      "description": "Upgrade proposal ID.",
      "type": "string"
    }
  },
  "required": [
    "proposal_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.upgrades.dismiss", proposal_id="<proposal_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.upgrades.dismiss", { proposal_id: "<proposal_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.upgrades.dismiss/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "proposal_id": "<proposal_id>"
  }
}'

ww.upgrades.list

READ

List current Weekly Upgrade Digest proposals.

Parameters

No parameters.

inputSchema

{
  "properties": {},
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.upgrades.list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.upgrades.list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.upgrades.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.upgrades.pilot

WRITE

Schedule a 1-week, 10% pilot for an upgrade proposal.

Parameters

ParameterTypeRequiredDescription
proposal_idstringrequiredUpgrade proposal ID.
actor_idstringoptionalApproving actor ID. default: "mcp"

inputSchema

{
  "properties": {
    "actor_id": {
      "default": "mcp",
      "description": "Approving actor ID.",
      "type": "string"
    },
    "proposal_id": {
      "description": "Upgrade proposal ID.",
      "type": "string"
    }
  },
  "required": [
    "proposal_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.upgrades.pilot", proposal_id="<proposal_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.upgrades.pilot", { proposal_id: "<proposal_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.upgrades.pilot/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "proposal_id": "<proposal_id>"
  }
}'

ww.whatsapp.inbox

WRITE

List recent inbound WhatsApp messages.

Parameters

ParameterTypeRequiredDescription
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.
limitintegeroptionalMaximum messages to return.

inputSchema

{
  "properties": {
    "limit": {
      "description": "Maximum messages to return.",
      "type": "integer"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.whatsapp.inbox", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.whatsapp.inbox", { workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.whatsapp.inbox/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "workspace_id": "<workspace_id>"
  }
}'

ww.whatsapp.send

WRITE

Send a WhatsApp message (text or template).

Parameters

ParameterTypeRequiredDescription
contentstringrequiredMessage content.
from_numberstringrequiredSending WhatsApp number.
to_numberstringrequiredRecipient WhatsApp number.
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.
media_urlstringoptionalOptional media URL.
message_typestringoptionalOptional message type (text|template).
template_namestringoptionalOptional template name.
template_paramsobjectoptionalOptional template parameters.

inputSchema

{
  "properties": {
    "content": {
      "description": "Message content.",
      "type": "string"
    },
    "from_number": {
      "description": "Sending WhatsApp number.",
      "type": "string"
    },
    "media_url": {
      "description": "Optional media URL.",
      "type": "string"
    },
    "message_type": {
      "description": "Optional message type (text|template).",
      "type": "string"
    },
    "template_name": {
      "description": "Optional template name.",
      "type": "string"
    },
    "template_params": {
      "description": "Optional template parameters.",
      "type": "object"
    },
    "to_number": {
      "description": "Recipient WhatsApp number.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "from_number",
    "to_number",
    "content"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.whatsapp.send", content="<content>", from_number="<from_number>", to_number="<to_number>", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.whatsapp.send", { content: "<content>", from_number: "<from_number>", to_number: "<to_number>", workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.whatsapp.send/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "content": "<content>",
    "from_number": "<from_number>",
    "to_number": "<to_number>",
    "workspace_id": "<workspace_id>"
  }
}'

ww.whatsapp.template.list

READ

List the workspace's approved WhatsApp templates.

Parameters

ParameterTypeRequiredDescription
workspace_idstringrequiredWorkspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.whatsapp.template.list", workspace_id="<workspace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.whatsapp.template.list", { workspace_id: "<workspace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.whatsapp.template.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "workspace_id": "<workspace_id>"
  }
}'

ww.work.outcome.list

READ

List tenant-scoped work outcome receipts for one definition. Bounded page; never a tenant scan (#12144).

Parameters

ParameterTypeRequiredDescription
definition_idstringoptional
limitintegeroptional
tenant_idstringoptional

inputSchema

{
  "properties": {
    "definition_id": {
      "type": "string"
    },
    "limit": {
      "type": "integer"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.work.outcome.list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.work.outcome.list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.work.outcome.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.work.outcome.show

READ

Return one tenant-scoped work outcome receipt. Status is verified, failed, partial, unknown, or ineligible — never a run count (#12144).

Parameters

ParameterTypeRequiredDescription
instance_idstringrequiredWorkload instance id.
tenant_idstringoptional

inputSchema

{
  "properties": {
    "instance_id": {
      "description": "Workload instance id.",
      "type": "string"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "instance_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.work.outcome.show", instance_id="<instance_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.work.outcome.show", { instance_id: "<instance_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.work.outcome.show/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "instance_id": "<instance_id>"
  }
}'

ww.workflow.promote

WRITE

Promote a completed WorkflowTemplate saga run into a reusable workflow after eval receipt.

Parameters

ParameterTypeRequiredDescription
eval_receipt_idstringrequiredEvaluation receipt proving promotion gates passed.
run_idstringrequiredSaga run ID.
namestringoptionalPromoted workflow name.

inputSchema

{
  "properties": {
    "eval_receipt_id": {
      "description": "Evaluation receipt proving promotion gates passed.",
      "type": "string"
    },
    "name": {
      "description": "Promoted workflow name.",
      "type": "string"
    },
    "run_id": {
      "description": "Saga run ID.",
      "type": "string"
    }
  },
  "required": [
    "run_id",
    "eval_receipt_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workflow.promote", eval_receipt_id="<eval_receipt_id>", run_id="<run_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workflow.promote", { eval_receipt_id: "<eval_receipt_id>", run_id: "<run_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workflow.promote/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "eval_receipt_id": "<eval_receipt_id>",
    "run_id": "<run_id>"
  }
}'

ww.workflow.replay

WRITE

Replay a WorkflowTemplate saga run against the same content SHA.

Parameters

ParameterTypeRequiredDescription
run_idstringrequiredSaga run ID.
idempotency_keystringoptionalStable retry key.

inputSchema

{
  "properties": {
    "idempotency_key": {
      "description": "Stable retry key.",
      "type": "string"
    },
    "run_id": {
      "description": "Saga run ID.",
      "type": "string"
    }
  },
  "required": [
    "run_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workflow.replay", run_id="<run_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workflow.replay", { run_id: "<run_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workflow.replay/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "run_id": "<run_id>"
  }
}'

ww.workflow.saga.compensate

WRITE

Manually compensate a WorkflowTemplate saga run.

Parameters

ParameterTypeRequiredDescription
run_idstringrequiredSaga run ID.
idempotency_keystringoptionalStable retry key.
reasonstringoptionalRollback reason.

inputSchema

{
  "properties": {
    "idempotency_key": {
      "description": "Stable retry key.",
      "type": "string"
    },
    "reason": {
      "description": "Rollback reason.",
      "type": "string"
    },
    "run_id": {
      "description": "Saga run ID.",
      "type": "string"
    }
  },
  "required": [
    "run_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workflow.saga.compensate", run_id="<run_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workflow.saga.compensate", { run_id: "<run_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workflow.saga.compensate/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "run_id": "<run_id>"
  }
}'

ww.workflow.saga.run

WRITE

Run a reference WorkflowTemplate saga with retry-safe idempotency.

Parameters

ParameterTypeRequiredDescription
template_idstringrequiredWorkflowTemplate ID.
fail_step_idstringoptionalDeterministic failure injection for tests.
idempotency_keystringoptionalStable retry key.
initial_dataobjectoptionalOptional initial data.

inputSchema

{
  "properties": {
    "fail_step_id": {
      "description": "Deterministic failure injection for tests.",
      "type": "string"
    },
    "idempotency_key": {
      "description": "Stable retry key.",
      "type": "string"
    },
    "initial_data": {
      "description": "Optional initial data.",
      "type": "object"
    },
    "template_id": {
      "description": "WorkflowTemplate ID.",
      "type": "string"
    }
  },
  "required": [
    "template_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workflow.saga.run", template_id="<template_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workflow.saga.run", { template_id: "<template_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workflow.saga.run/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "template_id": "<template_id>"
  }
}'

ww.workflow.saga.status

READ

Show one WorkflowTemplate saga run.

Parameters

ParameterTypeRequiredDescription
run_idstringrequiredSaga run ID.

inputSchema

{
  "properties": {
    "run_id": {
      "description": "Saga run ID.",
      "type": "string"
    }
  },
  "required": [
    "run_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workflow.saga.status", run_id="<run_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workflow.saga.status", { run_id: "<run_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workflow.saga.status/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "run_id": "<run_id>"
  }
}'

ww.workflow.template.list

READ

List reference WorkflowTemplate saga templates.

Parameters

No parameters.

inputSchema

{
  "properties": {},
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workflow.template.list")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workflow.template.list");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workflow.template.list/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.workflow.template.show

READ

Show one reference WorkflowTemplate saga template.

Parameters

ParameterTypeRequiredDescription
template_idstringrequiredWorkflowTemplate ID.

inputSchema

{
  "properties": {
    "template_id": {
      "description": "WorkflowTemplate ID.",
      "type": "string"
    }
  },
  "required": [
    "template_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workflow.template.show", template_id="<template_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workflow.template.show", { template_id: "<template_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workflow.template.show/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "template_id": "<template_id>"
  }
}'

ww.workmemory.awareness_snapshot

READ

Return the awareness snapshot bound to a decision trace. Mirrors the SDK ``WorkMemory.awareness_snapshot(trace_id)`` method (#4335). Reuses ``AwarenessSnapshotStore``.

Parameters

ParameterTypeRequiredDescription
trace_idstringrequiredDecision trace id whose awareness snapshot to return.

inputSchema

{
  "properties": {
    "trace_id": {
      "description": "Decision trace id whose awareness snapshot to return.",
      "type": "string"
    }
  },
  "required": [
    "trace_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workmemory.awareness_snapshot", trace_id="<trace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workmemory.awareness_snapshot", { trace_id: "<trace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workmemory.awareness_snapshot/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "trace_id": "<trace_id>"
  }
}'

ww.workmemory.contest

WRITE

File a counter-alternative against a decision. Mirrors the SDK ``WorkMemory.contest(decision_id, alternative, evidence_refs)`` method (#4335). Reuses ``ContestationService``.

Parameters

ParameterTypeRequiredDescription
alternativestringrequiredProposed counter-alternative summary.
decision_idstringrequiredDecision id being contested.
evidence_refsarrayoptionalEvidence record IDs supporting the contest.
member_idstringoptionalOptional acting principal id (defaults to 'mcp').
rationalestringoptionalWhy the alternative is better.

inputSchema

{
  "properties": {
    "alternative": {
      "description": "Proposed counter-alternative summary.",
      "type": "string"
    },
    "decision_id": {
      "description": "Decision id being contested.",
      "type": "string"
    },
    "evidence_refs": {
      "description": "Evidence record IDs supporting the contest.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "member_id": {
      "description": "Optional acting principal id (defaults to 'mcp').",
      "type": "string"
    },
    "rationale": {
      "description": "Why the alternative is better.",
      "type": "string"
    }
  },
  "required": [
    "decision_id",
    "alternative"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workmemory.contest", alternative="<alternative>", decision_id="<decision_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workmemory.contest", { alternative: "<alternative>", decision_id: "<decision_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workmemory.contest/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "alternative": "<alternative>",
    "decision_id": "<decision_id>"
  }
}'

ww.workmemory.decision_trace

READ

Return a single decision trace by id. Mirrors the SDK ``WorkMemory.decision_trace(trace_id)`` substrate method (#4335). Reuses ``DecisionEventCaptureService`` — no new backend logic.

Parameters

ParameterTypeRequiredDescription
trace_idstringrequiredDecision trace id to fetch.

inputSchema

{
  "properties": {
    "trace_id": {
      "description": "Decision trace id to fetch.",
      "type": "string"
    }
  },
  "required": [
    "trace_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workmemory.decision_trace", trace_id="<trace_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workmemory.decision_trace", { trace_id: "<trace_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workmemory.decision_trace/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "trace_id": "<trace_id>"
  }
}'

ww.workmemory.nudges

READ

Return the bounded recursive-self-improvement nudge projection: a union of applied/proposed learnings, pending proposed skills, and decision-trace precedents ('you solved this before'). Gated on the per-tenant capture opt-in — empty (never an error) when the tenant has opted out. Read-side only; creates no new data (#6267).

Parameters

ParameterTypeRequiredDescription
limitintegeroptionalMaximum nudges to return (default 10, max 200). default: 10
session_idstringoptionalOptional session scope for precedent nudges.
tenant_idstringoptionalTenant id. Defaults to the authenticated MCP context; cross-tenant param values are rejected.

inputSchema

{
  "properties": {
    "limit": {
      "default": 10,
      "description": "Maximum nudges to return (default 10, max 200).",
      "type": "integer"
    },
    "session_id": {
      "description": "Optional session scope for precedent nudges.",
      "type": "string"
    },
    "tenant_id": {
      "description": "Tenant id. Defaults to the authenticated MCP context; cross-tenant param values are rejected.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workmemory.nudges")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workmemory.nudges");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workmemory.nudges/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.workmemory.precedents

READ

Return precedent matches similar to the given description. Mirrors the SDK ``WorkMemory.precedents(similar_to, top_k)`` substrate method (#4335). Reuses ``PrecedentQuery``.

Parameters

ParameterTypeRequiredDescription
descriptionstringrequiredFree-text description to search precedents for.
top_kintegeroptionalMaximum number of precedents to return (default 10). default: 10

inputSchema

{
  "properties": {
    "description": {
      "description": "Free-text description to search precedents for.",
      "type": "string"
    },
    "top_k": {
      "default": 10,
      "description": "Maximum number of precedents to return (default 10).",
      "type": "integer"
    }
  },
  "required": [
    "description"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workmemory.precedents", description="<description>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workmemory.precedents", { description: "<description>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workmemory.precedents/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "description": "<description>"
  }
}'

ww.workmemory.replay

WRITE

Replay a previously captured decision trace. Mirrors the SDK ``WorkMemory.replay(decision_id)`` method (#4335). Reuses ``DecisionTraceReplayService``.

Parameters

ParameterTypeRequiredDescription
decision_idstringrequiredOriginal decision id to replay.

inputSchema

{
  "properties": {
    "decision_id": {
      "description": "Original decision id to replay.",
      "type": "string"
    }
  },
  "required": [
    "decision_id"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workmemory.replay", decision_id="<decision_id>")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workmemory.replay", { decision_id: "<decision_id>" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workmemory.replay/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "decision_id": "<decision_id>"
  }
}'

ww.workmemory.subscribe_events_replay

READ

Replay durable events from the tenant event bus. Used by MCP clients that cannot keep SSE open. SDK callers should use ``WorkMemory.subscribe_events`` for live streaming. (#4335)

Parameters

ParameterTypeRequiredDescription
channelstringoptionalChannel filter mirroring the SSE endpoints. enum: runtime, mission, calendar, global default: "runtime"
limitintegeroptionalMax events to replay (default 200, max 1000). default: 200
sincestringoptionalOptional ISO timestamp lower bound.

inputSchema

{
  "properties": {
    "channel": {
      "default": "runtime",
      "description": "Channel filter mirroring the SSE endpoints.",
      "enum": [
        "runtime",
        "mission",
        "calendar",
        "global"
      ],
      "type": "string"
    },
    "limit": {
      "default": 200,
      "description": "Max events to replay (default 200, max 1000).",
      "type": "integer"
    },
    "since": {
      "description": "Optional ISO timestamp lower bound.",
      "type": "string"
    }
  },
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.workmemory.subscribe_events_replay")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.workmemory.subscribe_events_replay");
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.workmemory.subscribe_events_replay/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {}
}'

ww.zara.goal_intake.session

WRITE

Drive the resumable, versioned Zara goal-intake interview (#12084). One typed action parameter: start | read | answer | cancel | complete. Same session contract as REST, Zara chat, ww CLI, and public MCP.

Parameters

ParameterTypeRequiredDescription
actionstringrequiredSession lifecycle action. enum: start, read, answer, cancel, complete
answerstringoptionalAnswer text (disposition=answer).
dispositionstringoptionalAnswer posture (action=answer). enum: answer, delegate, keep_unknown
evidence_refsarrayoptionalEvidence refs attached to an answer.
expected_session_revisionintegeroptionalCAS revision for answer/cancel/complete.
goal_textstringoptionalGoal prose for action=start.
idempotency_keystringoptionalCaller idempotency key for start/answer.
information_need_idstringoptionalNeed id being answered (action=answer).
requested_by_member_idstringoptionalOptional member id attributing the goal.
session_idstringoptionalSession id for read/answer/cancel/complete.
source_refsarrayoptionalProvenance refs for action=start.
tenant_idstringoptional

inputSchema

{
  "properties": {
    "action": {
      "description": "Session lifecycle action.",
      "enum": [
        "start",
        "read",
        "answer",
        "cancel",
        "complete"
      ],
      "type": "string"
    },
    "answer": {
      "description": "Answer text (disposition=answer).",
      "maxLength": 2000,
      "type": "string"
    },
    "disposition": {
      "description": "Answer posture (action=answer).",
      "enum": [
        "answer",
        "delegate",
        "keep_unknown"
      ],
      "type": "string"
    },
    "evidence_refs": {
      "description": "Evidence refs attached to an answer.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "expected_session_revision": {
      "description": "CAS revision for answer/cancel/complete.",
      "minimum": 1,
      "type": "integer"
    },
    "goal_text": {
      "description": "Goal prose for action=start.",
      "maxLength": 2000,
      "minLength": 1,
      "type": "string"
    },
    "idempotency_key": {
      "description": "Caller idempotency key for start/answer.",
      "maxLength": 200,
      "minLength": 1,
      "type": "string"
    },
    "information_need_id": {
      "description": "Need id being answered (action=answer).",
      "type": "string"
    },
    "requested_by_member_id": {
      "description": "Optional member id attributing the goal.",
      "type": "string"
    },
    "session_id": {
      "description": "Session id for read/answer/cancel/complete.",
      "type": "string"
    },
    "source_refs": {
      "description": "Provenance refs for action=start.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "tenant_id": {
      "type": "string"
    }
  },
  "required": [
    "action"
  ],
  "type": "object"
}

Example usage

Python SDK
from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.zara.goal_intake.session", action="start")
TypeScript SDK
import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.zara.goal_intake.session", { action: "start" });
Raw HTTP
curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.zara.goal_intake.session/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "action": "start"
  }
}'

No tools match your search.