MCP Tool Catalog — WorkMemory

`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

Parameter	Type	Required	Description
`session_id`	`string`	required	Session 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

Parameter	Type	Required	Description
`max_hops`	`integer`	optional	Maximum graph hops to traverse (default 2). default: 2
`org_entity_id`	`string`	optional	Org/role entity node to seed the walk from. Defaults to the tenant root node (ORG#<tenant_id>).
`role`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`dry_run`	`boolean`	optional	If 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_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

Parameter	Type	Required	Description
`entity_id`	`string`	required	The entity ID to cross-reference (e.g. person name, project ID).
`limit`	`integer`	optional	Maximum 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_forget`

WRITE

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

Parameters

Parameter	Type	Required	Description
`hard_delete`	`boolean`	optional	When true, delete the record instead of tombstoning it.
`memory_id`	`string`	optional	Legacy item ID to forget (if known).
`query`	`string`	optional	Legacy query to find the best-matching item to forget.
`reason`	`string`	optional	Why this record should be forgotten.
`target_id`	`string`	optional	Canonical target identifier.
`target_type`	`string`	optional	Canonical 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_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

Parameter	Type	Required	Description
`user_id`	`string`	required	User ID to get profile for (e.g. 'USER#alice').
`include_search_results`	`boolean`	optional	Include semantic search results alongside profile facts. default: false
`query`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`query`	`string`	required	What you want to recall — ask naturally.
`department_ids`	`array`	optional	Verified caller department memberships for department-partitioned recall.
`include_coverage`	`boolean`	optional	When 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_tokens`	`integer`	optional	If provided, returns token-budgeted formatted context. If omitted, returns raw search results.
`memory_tier`	`string`	optional	Filter by memory tier. Returns items from this tier plus parent tiers. E.g. 'task' returns task + mission + institutional. enum: institutional, mission, task, session
`min_tier`	`string`	optional	Optional minimum epistemic trust tier for recall filtering. enum: working, shared, durable, verified
`mission_id`	`string`	optional	Filter memories to a specific mission (e.g. 'MISSION#abc').
`team_ids`	`array`	optional	Verified caller team memberships for team-partitioned recall.
`tool_id`	`string`	optional	Filter memories by tool identity. Returns memories created by this tool_id plus all universal-scope memories. Omit to return all memories.

inputSchema

{
  "properties": {
    "department_ids": {
      "description": "Verified caller department memberships for department-partitioned recall.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "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"
    },
    "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"
    }
  },
  "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

Parameter	Type	Required	Description
`continuation_id`	`string`	required	The 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. Be specific — one fact per call. Auto-categorizes, deduplicates, and redacts PII.

Parameters

Parameter	Type	Required	Description
`content`	`string`	required	The fact or observation to remember.
`department_id`	`string`	optional	Department partition for memory_scope='department'.
`memory_scope`	`string`	optional	Recall visibility scope: universal/tool/member/workspace/shared, or team/department for org-unit partitioned memory. enum: universal, tool, member, workspace, shared, cross_workspace_via_permission, team, department
`memory_tier`	`string`	optional	Memory hierarchy tier: 'institutional' (permanent org-wide), 'mission' (project-scoped), 'task' (single task, default), 'session' (ephemeral). enum: institutional, mission, task, session
`mission_id`	`string`	optional	Mission ID to scope this memory to (e.g. 'MISSION#abc').
`shared_with_department_ids`	`array`	optional	Department ids explicitly allowed to read this memory across department partitions.
`shared_with_team_ids`	`array`	optional	Team ids explicitly allowed to read this memory across team partitions.
`team_id`	`string`	optional	Team partition for memory_scope='team'.
`tool_id`	`string`	optional	Identifies the tool saving this memory (e.g. 'claude-code', 'cursor', 'langchain'). Used for per-tool memory scoping.

inputSchema

{
  "properties": {
    "content": {
      "description": "The fact or observation to remember.",
      "type": "string"
    },
    "department_id": {
      "description": "Department partition for memory_scope='department'.",
      "type": "string"
    },
    "memory_scope": {
      "description": "Recall visibility scope: universal/tool/member/workspace/shared, or team/department for org-unit partitioned memory.",
      "enum": [
        "universal",
        "tool",
        "member",
        "workspace",
        "shared",
        "cross_workspace_via_permission",
        "team",
        "department"
      ],
      "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"
    },
    "shared_with_department_ids": {
      "description": "Department ids explicitly allowed to read this memory across department partitions.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "shared_with_team_ids": {
      "description": "Team ids explicitly allowed to read this memory across team partitions.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "team_id": {
      "description": "Team partition for memory_scope='team'.",
      "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"
    }
  },
  "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

Parameter	Type	Required	Description
`action`	`string`	required	Session action to perform. enum: start, flush, recall, pin, end
`agent_id`	`string`	optional	Agent identifier (for start).
`fact`	`string`	optional	Fact to pin (for pin).
`facts`	`array`	optional	Extracted facts from segment (for flush).
`model`	`string`	optional	LLM model (for start).
`query`	`string`	optional	What to recall from this session (for recall).
`session_id`	`string`	optional	Session ID (required for flush/recall/pin/end).
`summary`	`string`	optional	Compressed summary of the segment (for flush).
`token_count`	`integer`	optional	Token count of original content (for flush).
`topic_tags`	`array`	optional	Topic 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

Parameter	Type	Required	Description
`handle_id`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`topic`	`string`	required	The topic to synthesize a wiki page for.
`artifact_type`	`string`	optional	Type 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>"
  }
}'

`update_context`

SESSION

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

Parameters

Parameter	Type	Required
`session_id`	`string`	required
`tenant_id`	`string`	required
`context_vars`	`object`	optional
`conversation_summary`	`string`	optional
`current_step`	`string`	optional

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

Parameter	Type	Required	Description
`new_content`	`string`	required	Corrected text for the new item.
`old_item_id`	`string`	required	Memory item id to supersede.
`rationale`	`string`	required	Why the correction is being made (required).
`actor_id`	`string`	optional	Acting 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

Parameter	Type	Required	Description
`actor_id`	`string`	optional	FILTER dimension: forget every fact WRITTEN BY this actor. This is NOT the requesting actor; see requesting_actor_id.
`dry_run`	`boolean`	optional	Preview the affected items without writing. Defaults to true for safety. default: true
`fact_id`	`string`	optional	Forget a single fact by id.
`rationale`	`string`	optional	Audit-only reason for the forget request.
`requesting_actor_id`	`string`	optional	Principal performing the forget (analog of REST x-actor-id header). Defaults to 'system:mcp'. default: "system:mcp"
`scope`	`string`	optional	Forget facts in this memory scope.
`subject_id`	`string`	optional	Forget 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

Parameter	Type	Required	Description
`item_id`	`string`	required	Memory 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

Parameter	Type	Required	Description
`agent_id`	`string`	required	Agent 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

Parameter	Type	Required	Description
`mode`	`string`	optional	Repro 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.show`

READ

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

Parameters

Parameter	Type	Required	Description
`period`	`string`	optional	YYYY-MM period (default: current month UTC).
`tenant_id`	`string`	optional	Tenant 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.channel.normalize_inbound`

WRITE

Normalize a raw inbound channel message into the canonical envelope.

Parameters

Parameter	Type	Required	Description
`channel`	`string`	required	Inbound channel kind.
`raw_message`	`object`	required	Raw 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

Parameter	Type	Required	Description
`source_channel`	`string`	required	Originating channel kind.
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`entity_scope`	`string`	optional	Optional entity scope.
`intent_type`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`source_channel`	`string`	required	Originating channel kind.
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`condition`	`object`	optional	Optional rule condition payload.
`decision_trace_reason`	`string`	optional	Optional rationale for the proposal.
`entity_scope`	`string`	optional	Optional entity scope.
`intent_type`	`string`	optional	Optional intent classification.
`priority`	`integer`	optional	Optional rule priority.
`redaction_level`	`string`	optional	Optional redaction level.
`target_channel`	`string`	optional	Destination 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

Parameter	Type	Required	Description
`body`	`string`	required	Message body.
`channel`	`string`	required	Channel kind (e.g. email, sms, whatsapp, slack).
`recipient`	`string`	required	Recipient address/handle.
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`message_id`	`string`	optional	Optional message id for idempotency.
`metadata`	`object`	optional	Optional message metadata.
`sender`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`messages`	`array`	required	Messages to send.
`workspace_id`	`string`	required	Workspace 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

Parameter	Type	Required	Description
`body`	`string`	required	Rendered template body.
`recipient`	`string`	required	Recipient address/handle.
`source_channel`	`string`	required	Originating channel kind.
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`entity_scope`	`string`	optional	Optional entity scope.
`intent_type`	`string`	optional	Optional intent classification.
`message_id`	`string`	optional	Optional message id for idempotency.
`metadata`	`object`	optional	Optional message metadata.
`sender`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`channel_id`	`string`	required	Channel id to list messages for.
`workspace_id`	`string`	required	Workspace 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

Parameter	Type	Required	Description
`blocks`	`array`	required	Rendered message blocks.
`channel_id`	`string`	required	Destination channel id.
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`confidence_level`	`string`	optional	Optional confidence annotation.
`fallback_text`	`string`	optional	Optional 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.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 10 canonical harnesses (claude-desktop, claude-code, cursor, opencode, codex, gemini, openclaw, hermes, goose, generic-mcp). Plaintext key is returned exactly ONCE — clients must persist it themselves. ADMIN-scoped.

Parameters

Parameter	Type	Required	Description
`harness`	`string`	required	Public kebab-case harness name. enum: claude-desktop, claude-code, cursor, opencode, codex, gemini, openclaw, hermes, goose, generic-mcp
`base_url`	`string`	optional	Optional canonical public base URL the snippet embeds. Defaults to WORKMEMORY_PUBLIC_BASE_URL or https://api.workweaver.ai.
`name`	`string`	optional	Display name for the issued scoped API key. default: "harness-install"
`scopes`	`array`	optional	Scopes to mint on the issued API key. Allowed: READ, WRITE. ADMIN/SESSION are rejected (defence in depth — see #5022 codex review).
`task_scope`	`string`	optional	Optional 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_id`	`string`	optional	Tenant 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",
        "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.email.list_threads`

WRITE

List recent agent email threads.

Parameters

Parameter	Type	Required	Description
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`limit`	`integer`	optional	Maximum 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

Parameter	Type	Required	Description
`body`	`string`	required	Reply body.
`thread_id`	`string`	required	Email thread id to reply to.
`workspace_id`	`string`	required	Workspace 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

Parameter	Type	Required	Description
`body`	`string`	required	Email body.
`subject`	`string`	required	Email subject.
`to`	`string`	required	Recipient address.
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`bcc`	`string`	optional	Optional BCC address(es).
`cc`	`string`	optional	Optional CC address(es).
`from_alias`	`string`	optional	Optional from-alias.
`reply_to`	`string`	optional	Optional 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.fs.cat`

READ

Read a WorkMemoryFS virtual file (#5012).

Parameters

Parameter	Type	Required	Description
`path`	`string`	required
`task_scope`	`string`	optional	Optional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).
`tool_id`	`string`	optional	Optional requester tool id for tool-scoped memory visibility.

inputSchema

{
  "properties": {
    "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"
    },
    "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

Parameter	Type	Required	Description
`content`	`string`	required
`path`	`string`	required
`task_scope`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`name`	`string`	optional	default: "*"
`path`	`string`	optional	default: "/"
`task_scope`	`string`	optional	Optional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).
`tool_id`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`pattern`	`string`	required
`lexical`	`boolean`	optional	default: false
`limit`	`integer`	optional	default: 20
`path`	`string`	optional	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). default: "/"
`task_scope`	`string`	optional	Optional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).
`tool_id`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`path`	`string`	optional	Virtual directory path. default: "/"
`task_scope`	`string`	optional	Optional per-task scope key. Confines recall to this task's captures plus unscoped tenant knowledge; omit for tenant-wide recall (#6878).
`tool_id`	`string`	optional	Optional requester tool id for tool-scoped memory visibility.

inputSchema

{
  "properties": {
    "path": {
      "default": "/",
      "description": "Virtual directory 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"
    },
    "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

Parameter	Type	Required	Description
`path`	`string`	required

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

Parameter	Type	Required	Description
`function_id`	`string`	required	Work Function id.
`actor_id`	`string`	optional	Acting principal id for Decision Trace emission. default: "mcp"
`drain`	`string`	optional	In-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"
`reason`	`string`	optional	Decision Trace reason. default: "Archived from MCP"
`tenant_id`	`string`	optional	Optional 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 through the REST update route. Emits Decision Trace action work_function.update.

Parameters

Parameter	Type	Required	Description
`function_id`	`string`	required	Work Function id.
`max_cloud_workers`	`integer`	required	Maximum concurrent Work Function workers; maps to REST capacity max_concurrent. default: 5
`actor_id`	`string`	optional	Acting principal id for Decision Trace emission. default: "mcp"
`always_on_quota`	`integer`	optional	Always-on worker quota. default: 0
`budget_usd`	`number`	optional	Budget ceiling in USD. default: 100.0
`foreground_reservations`	`integer`	optional	Foreground worker reservations. default: 0
`reason`	`string`	optional	Decision Trace reason. default: "Updated capacity from MCP"
`tenant_id`	`string`	optional	Optional workspace id. Must match the authenticated MCP workspace context when provided.
`zero_burn_target_usd`	`string`	optional	Zero-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"
    },
    "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

Parameter	Type	Required	Description
`name`	`string`	required	Work Function display name.
`actor_id`	`string`	optional	Acting principal id for Decision Trace emission. default: "mcp"
`always_on_quota`	`integer`	optional	Always-on worker quota. default: 0
`autonomy_level`	`integer`	optional	Autonomy level, 0-5. default: 2
`budget_usd`	`number`	optional	Budget ceiling in USD. default: 100.0
`connector_scopes`	`array`	optional	Allowed connector scopes.
`coordination_protocol`	`string`	optional	Coordination protocol. default: "auto"
`foreground_reservations`	`integer`	optional	Foreground worker reservations. default: 0
`initial_state`	`string`	optional	Initial lifecycle state. enum: dormant, active default: "active"
`locality`	`string`	optional	Local/cloud locality preference. enum: prefer_local, prefer_cloud, local_only, cloud_only, cloud_required default: "prefer_local"
`max_cloud_workers`	`integer`	optional	Maximum concurrent Work Function workers; maps to REST capacity max_concurrent. default: 5
`preset`	`string`	optional	Preset id, e.g. marketing.
`preset_id`	`string`	optional	Preset id alias.
`purpose`	`string`	optional	Purpose summary.
`resource_policy_id`	`string`	optional	Resource Policy id.
`tenant_id`	`string`	optional	Optional workspace id. Must match the authenticated MCP workspace context when provided.
`zero_burn_target_usd`	`string`	optional	Zero-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"
    },
    "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

Parameter	Type	Required	Description
`confirm`	`boolean`	required	Must be true to perform deletion. default: false
`function_id`	`string`	required	Work Function id.
`actor_id`	`string`	optional	Acting principal id for Decision Trace emission. default: "mcp"
`evidence_retention_days`	`integer`	optional	Evidence retention window. default: 365
`reason`	`string`	optional	Decision Trace reason. default: "Deleted from MCP"
`tenant_id`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`function_id`	`string`	required	Work Function id.
`to_tier`	`string`	required	Target tier id.
`active_connectors`	`array`	optional	Active connectors.
`actor_id`	`string`	optional	Acting principal id for Decision Trace emission. default: "mcp"
`from_tier`	`string`	optional	Current tier id. default: "current"
`tenant_id`	`string`	optional	Optional workspace id. Must match the authenticated MCP workspace context when provided.
`tier_connectors`	`array`	optional	Allowed connectors.
`tier_limits`	`object`	optional	Target 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

Parameter	Type	Required	Description
`tenant_id`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`tenant_id`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`function_id`	`string`	required	Work Function id.
`tenant_id`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`function_id`	`string`	required	Work Function id.
`actor_id`	`string`	optional	Acting principal id for Decision Trace emission. default: "mcp"
`artifact_retention_class`	`string`	optional	Artifact retention class. enum: hot, warm, cold, archive default: "hot"
`cold_tier_after_days`	`integer`	optional	Days before artifacts become cold-tier eligible.
`reason`	`string`	optional	Decision Trace reason. default: "Updated Work Function WORM quota policy"
`storage_quota_gb`	`string \| number`	optional	WORM storage quota in GiB.
`tenant_id`	`string`	optional	Optional workspace id. Must match the authenticated MCP workspace context when provided.
`workmemory_index_quota_mb`	`string \| number`	optional	WorkMemory 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

Parameter	Type	Required	Description
`function_id`	`string`	required	Work Function id.
`actor_id`	`string`	optional	Acting principal id for Decision Trace emission. default: "mcp"
`reason`	`string`	optional	Decision Trace reason. default: "Reactivated from MCP"
`tenant_id`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`function_id`	`string`	required	Work Function id.
`tenant_id`	`string`	optional	Optional 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.channel.add`

WRITE

Add a collaboration channel to a mission.

Parameters

Parameter	Type	Required	Description
`name`	`string`	required	Channel name.
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`member_agent_ids`	`array`	optional	Optional initial member agent ids.
`scope`	`string`	optional	Optional channel scope.
`topic`	`string`	optional	Optional channel topic.

inputSchema

{
  "properties": {
    "member_agent_ids": {
      "description": "Optional initial member agent ids.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "name": {
      "description": "Channel name.",
      "type": "string"
    },
    "scope": {
      "description": "Optional channel scope.",
      "type": "string"
    },
    "topic": {
      "description": "Optional channel topic.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "name"
  ],
  "type": "object"
}

Example usage

Python SDK

from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.mission.channel.add", name="<name>", workspace_id="<workspace_id>")

TypeScript SDK

import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.mission.channel.add", { name: "<name>", workspace_id: "<workspace_id>" });

Raw HTTP

curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.mission.channel.add/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "name": "<name>",
    "workspace_id": "<workspace_id>"
  }
}'

`ww.mission.escalate`

WRITE

Escalate a mission decision to a human or supervisor.

Parameters

Parameter	Type	Required	Description
`decided_by`	`string`	required	Principal making the decision.
`decision`	`string`	required	Escalation decision.
`message_id`	`string`	required	Message id being escalated.
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`reasoning`	`string`	optional	Optional reasoning.

inputSchema

{
  "properties": {
    "decided_by": {
      "description": "Principal making the decision.",
      "type": "string"
    },
    "decision": {
      "description": "Escalation decision.",
      "type": "string"
    },
    "message_id": {
      "description": "Message id being escalated.",
      "type": "string"
    },
    "reasoning": {
      "description": "Optional reasoning.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "message_id",
    "decision",
    "decided_by"
  ],
  "type": "object"
}

Example usage

Python SDK

from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.mission.escalate", decided_by="<decided_by>", decision="<decision>", message_id="<message_id>", workspace_id="<workspace_id>")

TypeScript SDK

import { WorkMemory } from "@workweaver/memory";

const client = new WorkMemory({ apiKey: "ww_..." });
const result = await client.call("ww.mission.escalate", { decided_by: "<decided_by>", decision: "<decision>", message_id: "<message_id>", workspace_id: "<workspace_id>" });

Raw HTTP

curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.mission.escalate/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "decided_by": "<decided_by>",
    "decision": "<decision>",
    "message_id": "<message_id>",
    "workspace_id": "<workspace_id>"
  }
}'

`ww.mission.handoff`

WRITE

Initiate a cross-team mission handoff.

Parameters

Parameter	Type	Required	Description
`content`	`string`	required	Handoff content.
`from_agent`	`string`	required	Handing-off agent id.
`origin_channel_id`	`string`	required	Origin channel id.
`target_channel_id`	`string`	required	Target channel id.
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.

inputSchema

{
  "properties": {
    "content": {
      "description": "Handoff content.",
      "type": "string"
    },
    "from_agent": {
      "description": "Handing-off agent id.",
      "type": "string"
    },
    "origin_channel_id": {
      "description": "Origin channel id.",
      "type": "string"
    },
    "target_channel_id": {
      "description": "Target channel id.",
      "type": "string"
    },
    "workspace_id": {
      "description": "Workspace id. Must match the authenticated MCP workspace context when provided.",
      "type": "string"
    }
  },
  "required": [
    "workspace_id",
    "from_agent",
    "origin_channel_id",
    "target_channel_id",
    "content"
  ],
  "type": "object"
}

Example usage

Python SDK

from workweaver_memory import WorkMemory

client = WorkMemory(api_key="ww_...")
result = client.call("ww.mission.handoff", content="<content>", from_agent="<from_agent>", origin_channel_id="<origin_channel_id>", target_channel_id="<target_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.mission.handoff", { content: "<content>", from_agent: "<from_agent>", origin_channel_id: "<origin_channel_id>", target_channel_id: "<target_channel_id>", workspace_id: "<workspace_id>" });

Raw HTTP

curl -X POST https://workweaver.ai/memory/mcp/v1/tools/ww.mission.handoff/call \
  -H "Authorization: Bearer ww_..." \
  -H "Content-Type: application/json" \
  -d '{
  "arguments": {
    "content": "<content>",
    "from_agent": "<from_agent>",
    "origin_channel_id": "<origin_channel_id>",
    "target_channel_id": "<target_channel_id>",
    "workspace_id": "<workspace_id>"
  }
}'

`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

Parameter	Type	Required	Description
`goal`	`string`	required	Free-text goal handed to every harness.
`harnesses`	`array`	required	Harnesses to fan out to, e.g. ['codex','claude_code','cursor']. Deduplicated; unknown harness names are rejected.
`budget`	`object`	optional	Optional budget envelope forwarded to each leg.
`strategy`	`string`	optional	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 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

Parameter	Type	Required	Description
`orchestration_id`	`string`	required	Orchestration 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

Parameter	Type	Required	Description
`proposal_id`	`string`	required	Proposal id (``prop_<hex>``).
`tenant_id`	`string`	optional	Tenant 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

Parameter	Type	Required	Description
`status`	`string`	optional	Optional status filter. enum: pending_review, accepted, rejected, merged
`tenant_id`	`string`	optional	Tenant 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

Parameter	Type	Required	Description
`actor_id`	`string`	required	Reviewer id; recorded on the row as ``reviewed_by``.
`proposal_id`	`string`	required	Proposal id (``prop_<hex>``).
`status`	`string`	required	Target lifecycle status. enum: pending_review, accepted, rejected, merged
`tenant_id`	`string`	optional	Tenant 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.routine.list`

READ

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

Parameters

Parameter	Type	Required	Description
`health_status`	`string`	optional	Optional routine health filter.
`status`	`string`	optional	Optional backing-schedule status filter.
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`routine_id`	`string`	required	Routine id / backing schedule id.
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`concurrency_mode`	`string`	required	Routine dispatch mode to persist. enum: serial, swarm
`routine_id`	`string`	required	Routine id / backing schedule id.
`workspace_id`	`string`	required	Workspace id whose routine should be updated.
`actor_id`	`string`	optional	Optional MCP actor id for audit attribution. default: "mcp"
`note`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`agent_id`	`string`	required	Owning agent/entity id.
`schedule_type`	`string`	required	Schedule type (e.g. recurring, triggered, one_shot).
`title`	`string`	required	Human-readable schedule title.
`check_interval_minutes`	`integer`	optional	Polling interval for interval-style schedules. default: 5
`config`	`object`	optional	Optional schedule config payload.
`cron_expression`	`string`	optional	Optional cron cadence for recurring schedules.
`description`	`string`	optional	Optional schedule description. default: ""
`next_run_at`	`string`	optional	Optional ISO-8601 next-run timestamp.
`routine`	`object`	optional	Optional routine config block.
`timezone`	`string`	optional	Optional IANA timezone for cadence evaluation.
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`schedule_id`	`string`	required	Schedule id to delete.
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`agent_id`	`string`	optional	Optional agent/entity id filter.
`limit`	`integer`	optional	Maximum schedules to return. default: 100
`schedule_type`	`string`	optional	Optional schedule type filter.
`status`	`string`	optional	Optional schedule status filter.
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`schedule_id`	`string`	required	Schedule id to pause.
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`schedule_id`	`string`	required	Schedule id to resume.
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`schedule_id`	`string`	required	Triggered schedule id to fire.
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`schedule_id`	`string`	required	Schedule id to fetch.
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`revision`	`integer`	required	Current revision for optimistic locking.
`schedule_id`	`string`	required	Schedule id to update.
`check_interval_minutes`	`integer`	optional	New polling interval.
`config`	`object`	optional	Replacement config payload.
`cron_expression`	`string`	optional	New cron cadence.
`description`	`string`	optional	New description.
`next_run_at`	`string`	optional	New ISO-8601 next-run timestamp.
`routine`	`object`	optional	Routine config block to merge.
`title`	`string`	optional	New title.
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`items`	`array`	required	Schedulable items to replan with (same shape as POST /api/v1/scheduler/replan).
`target_date`	`string`	optional	YYYY-MM-DD target date for the replan.
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`workspace_id`	`string`	optional	Workspace 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

Parameter	Type	Required	Description
`workspace_id`	`string`	optional	Workspace 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.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

Parameter	Type	Required	Description
`skill_id`	`string`	required	Skill id to read the report for.
`tenant_id`	`string`	optional
`week_id`	`string`	optional	ISO 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.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

Parameter	Type	Required	Description
`candidate_id`	`string`	required	Proposal id of the candidate.
`actor_id`	`string`	optional	Reviewer applying the candidate.
`tenant_id`	`string`	optional

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

Parameter	Type	Required	Description
`skill_body`	`string`	required	The skill markdown body.
`skill_id`	`string`	required	Target skill slug.
`capability_routes`	`array`	optional	CapabilityRegistry route metadata for the skill.
`execution_deltas`	`array`	optional	ExecutionDelta clusters (repeated-work signals).
`tenant_id`	`string`	optional	Tenant id. Defaults to the authenticated MCP context.
`trace_precedents`	`array`	optional	Trace-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.reject`

ADMIN

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

Parameters

Parameter	Type	Required	Description
`candidate_id`	`string`	required
`actor_id`	`string`	optional
`reason`	`string`	optional	Rejection rationale.
`tenant_id`	`string`	optional

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

Parameter	Type	Required	Description
`benchmark`	`object`	required	A SkillOptimizationBenchmark object.
`skill_id`	`string`	required
`allow_small_selection`	`boolean`	optional	Approve a selection set below the size floor.
`dry_run`	`boolean`	optional	Estimate cost only.
`epsilon`	`number`	optional	Selection-gate epsilon.
`max_cost_usd`	`number`	optional	Cost ceiling for the run.
`tenant_id`	`string`	optional

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

Parameter	Type	Required	Description
`run_id`	`string`	required	Run id (``skopt_<hex>``).
`tenant_id`	`string`	optional

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.swarm.cancel`

WRITE

Cancel a pending or running swarm execution.

Parameters

Parameter	Type	Required	Description
`execution_id`	`string`	required	Swarm execution ID to cancel.
`reason`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`goal`	`string`	required	Free-text goal for the swarm to execute.
`auto_approve_tier`	`string`	optional	Comma-separated tiers allowed to auto-execute. Only low and medium are accepted. default: "low,medium"
`budget`	`string`	optional	Budget axes as tokens=N,dollars=N,wall=Ns,steps=N.
`plan_mode`	`string`	optional	Planner mode override. enum: emergent, self_organizing_emergent, rigid
`until_done`	`boolean`	optional	Poll 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

Parameter	Type	Required	Description
`execution_id`	`string`	optional	Optional swarm execution ID to inspect.
`limit`	`integer`	optional	Maximum executions to return when listing. default: 50
`status`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`workspace_id`	`string`	required	Workspace 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

Parameter	Type	Required	Description
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`area_code`	`string`	optional	Optional desired area code.
`capabilities`	`array`	optional	Optional capabilities.
`country_code`	`string`	optional	Optional country code.
`forward_to`	`string`	optional	Optional forwarding target.
`label`	`string`	optional	Optional friendly label.
`routing_target`	`string`	optional	Optional 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

Parameter	Type	Required	Description
`sid`	`string`	required	Provider SID of the number to release.
`workspace_id`	`string`	required	Workspace 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

Parameter	Type	Required	Description
`routing_target`	`string`	required	Routing target.
`sid`	`string`	required	Provider SID of the number to route.
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`business_hours_only`	`boolean`	optional	Restrict routing to business hours.
`forward_to`	`string`	optional	Optional forwarding target.
`greeting_message`	`string`	optional	Optional 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.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

Parameter	Type	Required	Description
`domain`	`string`	optional	Optional canonical domain prefix to filter by, e.g. 'ww.workflow', 'ww.channel', 'memory'.
`intent`	`string`	optional	Natural-language action or goal to resolve.
`limit`	`integer`	optional	Maximum 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

Parameter	Type	Required	Description
`proposal_id`	`string`	required	Upgrade proposal ID.
`actor_id`	`string`	optional	Approving 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

Parameter	Type	Required	Description
`proposal_id`	`string`	required	Upgrade proposal ID.
`actor_id`	`string`	optional	Dismissing 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

Parameter	Type	Required	Description
`proposal_id`	`string`	required	Upgrade proposal ID.
`actor_id`	`string`	optional	Approving 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

Parameter	Type	Required	Description
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`limit`	`integer`	optional	Maximum 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

Parameter	Type	Required	Description
`content`	`string`	required	Message content.
`from_number`	`string`	required	Sending WhatsApp number.
`to_number`	`string`	required	Recipient WhatsApp number.
`workspace_id`	`string`	required	Workspace id. Must match the authenticated MCP workspace context when provided.
`media_url`	`string`	optional	Optional media URL.
`message_type`	`string`	optional	Optional message type (text\|template).
`template_name`	`string`	optional	Optional template name.
`template_params`	`object`	optional	Optional 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

Parameter	Type	Required	Description
`workspace_id`	`string`	required	Workspace 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.workflow.promote`

WRITE

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

Parameters

Parameter	Type	Required	Description
`eval_receipt_id`	`string`	required	Evaluation receipt proving promotion gates passed.
`run_id`	`string`	required	Saga run ID.
`name`	`string`	optional	Promoted 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

Parameter	Type	Required	Description
`run_id`	`string`	required	Saga run ID.
`idempotency_key`	`string`	optional	Stable 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

Parameter	Type	Required	Description
`run_id`	`string`	required	Saga run ID.
`idempotency_key`	`string`	optional	Stable retry key.
`reason`	`string`	optional	Rollback 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

Parameter	Type	Required	Description
`template_id`	`string`	required	WorkflowTemplate ID.
`fail_step_id`	`string`	optional	Deterministic failure injection for tests.
`idempotency_key`	`string`	optional	Stable retry key.
`initial_data`	`object`	optional	Optional 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

Parameter	Type	Required	Description
`run_id`	`string`	required	Saga 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

Parameter	Type	Required	Description
`template_id`	`string`	required	WorkflowTemplate 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

Parameter	Type	Required	Description
`trace_id`	`string`	required	Decision 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

Parameter	Type	Required	Description
`alternative`	`string`	required	Proposed counter-alternative summary.
`decision_id`	`string`	required	Decision id being contested.
`evidence_refs`	`array`	optional	Evidence record IDs supporting the contest.
`member_id`	`string`	optional	Optional acting principal id (defaults to 'mcp').
`rationale`	`string`	optional	Why 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

Parameter	Type	Required	Description
`trace_id`	`string`	required	Decision 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

Parameter	Type	Required	Description
`limit`	`integer`	optional	Maximum nudges to return (default 10, max 200). default: 10
`session_id`	`string`	optional	Optional session scope for precedent nudges.
`tenant_id`	`string`	optional	Tenant 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

Parameter	Type	Required	Description
`description`	`string`	required	Free-text description to search precedents for.
`top_k`	`integer`	optional	Maximum 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

Parameter	Type	Required	Description
`decision_id`	`string`	required	Original 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

Parameter	Type	Required	Description
`channel`	`string`	optional	Channel filter mirroring the SSE endpoints. enum: runtime, mission, calendar, global default: "runtime"
`limit`	`integer`	optional	Max events to replay (default 200, max 1000). default: 200
`since`	`string`	optional	Optional 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": {}
}'