{
  "ok": true,
  "resource": {
    "id": "RES_88DBE012A24B",
    "resource_type": "mcp_server",
    "canonical_url": "https://registry.modelcontextprotocol.io/v0.1/servers/ai.agentplaybooks%2Fagentplaybooks/versions/1.0.0",
    "name": "AgentPlaybooks",
    "summary_en": "Manage portable AI agent playbooks, Agent Skills, MCP configurations, personas, and memory.",
    "summary_zh": "管理可移植的AI代理剧本、代理技能、MCP配置、角色和记忆。",
    "description_en": "AgentPlaybooks is an MCP server that manages portable AI agent playbooks, including Agent Skills, MCP configurations, personas, and memory. It provides tools to create, read, update, and delete playbooks, personas, skills, and memory entries. The server also supports hierarchical task graphs and memory consolidation. Authentication is required via a Bearer API key. The server was verified to be healthy with 49 tools available, of which 20 were reviewed in detail.",
    "description_zh": "AgentPlaybooks是一个MCP服务器，用于管理可移植的AI代理剧本，包括代理技能、MCP配置、角色和记忆。它提供了创建、读取、更新和删除剧本、角色、技能和记忆条目的工具。该服务器还支持分层任务图和记忆整合。需要通过Bearer API密钥进行身份验证。该服务器已验证健康，共有49个工具，其中20个已详细审查。",
    "provider_name": "ai.agentplaybooks",
    "homepage_url": "https://agentplaybooks.ai/",
    "endpoint_url": "https://agentplaybooks.ai/api/mcp/manage",
    "source_url": "https://github.com/matebenyovszky/agentplaybooks",
    "icon_url": "https://agentplaybooks.ai/icon.svg",
    "cover_image_url": null,
    "capabilities": [
      "playbook.manage",
      "persona.manage",
      "skill.manage",
      "memory.manage",
      "task-graph.manage",
      "tool.discover"
    ],
    "categories": [
      "developer-tools",
      "productivity"
    ],
    "industries": [
      "software",
      "general"
    ],
    "protocols": [
      "mcp"
    ],
    "auth": {
      "type": "unknown"
    },
    "pricing": {
      "model": "unknown"
    },
    "input_schema": {},
    "output_schema": {},
    "metadata": {
      "content_language": "en",
      "translation_status": "original-only",
      "official_registry": {
        "version": "1.0.0",
        "packages": [],
        "remotes": []
      },
      "review_gate": {
        "passed": true,
        "reasons": [],
        "policy_version": "review-gate-v1",
        "evaluated_at": "2026-09-03T06:31:38.505Z"
      }
    },
    "latest_version": "1.0.0",
    "status": "listed",
    "health_status": "healthy",
    "source_kind": "imported",
    "source_agent": "registry.modelcontextprotocol.io",
    "trust": {
      "signal": "none",
      "reason": "No suspicious or malicious evidence found.",
      "signals": {
        "yellow": 0,
        "red": 0
      }
    },
    "review_summary": {
      "method_version": "capability-evidence-v2",
      "capability_definition": "strong",
      "contract_completeness": "strong",
      "access_friction": "high",
      "operational_transparency": "partial",
      "evidence_strength": "protocol_inspected",
      "use_readiness": "conditional",
      "reviewed_at": "2026-09-03T06:31:39.711Z"
    },
    "experience_count": 0,
    "verified_experience_count": 0,
    "usage_count": 0,
    "success_rate": null,
    "first_seen_at": "2026-09-03T02:49:30.382Z",
    "last_seen_at": "2026-09-03T06:31:38.796Z",
    "published_at": "2026-09-03T06:31:38.796Z",
    "created_at": "2026-09-03T02:49:30.382Z",
    "updated_at": "2026-09-03T06:31:39.711Z",
    "api_url": "https://aiworkshub.io/api/v1/resources/RES_88DBE012A24B",
    "reviews_url": "https://aiworkshub.io/api/v1/resources/RES_88DBE012A24B/reviews",
    "public_url": "https://aiworkshub.io/resources/RES_88DBE012A24B",
    "distribution": {
      "canonical_identity": "https://registry.modelcontextprotocol.io/v0.1/servers/ai.agentplaybooks%2Fagentplaybooks/versions/1.0.0",
      "syndicatable": true,
      "origins": [
        {
          "registry_url": "https://registry.modelcontextprotocol.io/",
          "upstream_resource_id": "ai.agentplaybooks/agentplaybooks@1.0.0",
          "upstream_record_url": "https://registry.modelcontextprotocol.io/v0.1/servers/ai.agentplaybooks%2Fagentplaybooks/versions/1.0.0",
          "relation": "syndicated",
          "metadata": {
            "source": "official-mcp-registry"
          },
          "first_seen_at": "2026-09-03T02:49:30.382Z",
          "last_seen_at": "2026-09-03T06:31:38.796Z"
        }
      ]
    },
    "tools": [
      {
        "name": "archive_memories",
        "title_en": "Archive memories",
        "title_zh": "归档记忆",
        "description_en": "Archive memories from the working or contextual tier into longterm. Entries are kept, not deleted; filters (keys, tags, from_tier, older_than_hours) combine as AND. Requires memory:write or full permission. Use delete_memory for irreversible removal, promote_memory to move a key the other way, and consolidate_memories when you also want a parent summary. Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "将工作或上下文层级中的记忆归档到长期。条目被保留，而不是删除；过滤器（键、标签、from_tier、older_than_hours）以AND组合。需要memory:write或完全权限。使用delete_memory进行不可逆删除，使用promote_memory将键向另一个方向移动，当您还需要父摘要时使用consolidate_memories。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            },
            "keys": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "Specific keys to archive"
            },
            "older_than_hours": {
              "type": "number",
              "description": "Archive memories older than X hours"
            },
            "from_tier": {
              "type": "string",
              "enum": [
                "working",
                "contextual"
              ],
              "description": "Only archive from this tier"
            },
            "tags": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "Only archive memories with these tags"
            },
            "generate_summaries": {
              "type": "boolean",
              "description": "Auto-generate summaries if missing",
              "default": false
            }
          },
          "required": [
            "playbook_id"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "write",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "consolidate_memories",
        "title_en": "Consolidate memories",
        "title_zh": "整合记忆",
        "description_en": "Consolidate related memories under a new parent memory with a summary. Child rows stay readable; by default they are archived to the longterm tier rather than deleted. Requires memory:write or full permission. Use delete_memory only when a key should be destroyed, and archive_memories to move entries to longterm without creating a parent. Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "将相关记忆整合到带有摘要的新父记忆下。子行保持可读；默认情况下，它们被归档到长期层级而不是删除。需要memory:write或完全权限。仅当键应被销毁时使用delete_memory，使用archive_memories将条目移至长期而不创建父级。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            },
            "memory_keys": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "Keys of memories to consolidate"
            },
            "parent_key": {
              "type": "string",
              "description": "New parent memory key"
            },
            "summary": {
              "type": "string",
              "description": "Summary of consolidated memories"
            },
            "parent_tags": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "Tags for parent memory"
            },
            "archive_children": {
              "type": "boolean",
              "description": "Move children to longterm tier",
              "default": true
            }
          },
          "required": [
            "playbook_id",
            "memory_keys",
            "parent_key",
            "summary"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "write",
        "open_world": false,
        "idempotency": "not_idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "create_persona",
        "title_en": "Create persona",
        "title_zh": "创建角色",
        "description_en": "Set the playbook's singleton persona name and system prompt. This does not add a second persona; it is a backward-compatible alias that overwrites those fields. Requires personas:write or full permission. Prefer update_persona to change a subset of fields. Use update_playbook only when you also need playbook name, visibility, config, or project instructions. Do not use delete_persona unless you intend to reset to the default Assistant.",
        "description_zh": "设置剧本的单例角色名称和系统提示。这不会添加第二个角色；它是一个向后兼容的别名，覆盖这些字段。需要personas:write或完全权限。更改部分字段时，优先使用update_persona。仅当您还需要更改剧本名称、可见性、配置或项目说明时，才使用update_playbook。除非您打算重置为默认助手，否则不要使用delete_persona。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID of the playbook"
            },
            "name": {
              "type": "string",
              "description": "Name of the persona"
            },
            "system_prompt": {
              "type": "string",
              "description": "The system prompt that defines this persona's behavior"
            },
            "metadata": {
              "type": "object",
              "description": "Optional metadata"
            }
          },
          "required": [
            "playbook_id",
            "name",
            "system_prompt"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "irreversible",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "create_playbook",
        "title_en": "Create playbook",
        "title_zh": "创建剧本",
        "description_en": "Create a new playbook container for a singleton persona, skills, and memory. Each call inserts a new playbook; it does not upsert by name. Requires playbooks:write or full permission. Use update_playbook to change an existing playbook, not this tool.",
        "description_zh": "为单例角色、技能和记忆创建新的剧本容器。每次调用都会插入一个新剧本；不会按名称进行upsert。需要playbooks:write或完全权限。使用update_playbook来更改现有剧本，而不是此工具。",
        "input_schema": {
          "type": "object",
          "properties": {
            "name": {
              "type": "string",
              "description": "Name of the playbook"
            },
            "description": {
              "type": "string",
              "description": "Description of what the playbook is for"
            },
            "visibility": {
              "type": "string",
              "enum": [
                "public",
                "private",
                "unlisted"
              ],
              "description": "Visibility of the playbook",
              "default": "private"
            },
            "tags": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "Discovery and organization tags"
            },
            "persona_name": {
              "type": "string",
              "description": "Initial persona name"
            },
            "persona_system_prompt": {
              "type": "string",
              "description": "Initial persona/system prompt"
            },
            "persona_metadata": {
              "type": "object",
              "description": "Initial persona metadata"
            },
            "instructions": {
              "type": "string",
              "description": "Always-on project instructions (the AGENTS.md / CLAUDE.md content). Separate from the persona: the persona is who the agent is, these are the rules of this project."
            }
          },
          "required": [
            "name"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "write",
        "open_world": false,
        "idempotency": "not_idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "create_task_graph",
        "title_en": "Create task graph",
        "title_zh": "创建任务图",
        "description_en": "Create a hierarchical task plan in one call: a parent plan memory plus a child node per subtask. Upserts by key, so repeating the same plan_key overwrites the previous graph. Requires memory:write or full permission. Use write_memory for a single node, update_task_status to move a node through pending/running/completed, and get_memory_tree to inspect the graph. Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "在一次调用中创建分层任务计划：父计划记忆加上每个子任务的子节点。按键upsert，因此重复相同的plan_key会覆盖先前的图。需要memory:write或完全权限。使用write_memory创建单个节点，使用update_task_status将节点移动通过pending/running/completed，使用get_memory_tree检查图。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            },
            "plan_key": {
              "type": "string",
              "description": "Key for the root plan memory"
            },
            "plan_summary": {
              "type": "string",
              "description": "High-level summary of the entire plan"
            },
            "tasks": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "key": {
                    "type": "string",
                    "description": "Task key (will be prefixed with plan_key/)"
                  },
                  "description": {
                    "type": "string",
                    "description": "What this task does"
                  },
                  "value": {
                    "type": "object",
                    "description": "Task data (instructions, params, etc.)"
                  },
                  "depends_on": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "description": "Keys of tasks this depends on"
                  },
                  "tags": {
                    "type": "array",
                    "items": {
                      "type": "string"
                    },
                    "description": "Task tags"
                  }
                },
                "required": [
                  "key",
                  "description"
                ]
              },
              "description": "List of subtasks to create"
            },
            "tags": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "Tags for the plan"
            }
          },
          "required": [
            "playbook_id",
            "plan_key",
            "plan_summary",
            "tasks"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "irreversible",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "delete_memory",
        "title_en": "Delete memory",
        "title_zh": "删除记忆",
        "description_en": "Permanently delete one memory entry by key from this playbook. The row is removed from storage, not moved to another tier, and cannot be recovered. Requires a credential with memory:write or full permission. Use archive_memories to keep the entry in the longterm tier, or consolidate_memories to retain child detail under a parent summary. Do not call this when you only want to hide completed work. Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "从此剧本中按键永久删除一个记忆条目。该行从存储中移除，不会移动到其他层级，且无法恢复。需要具有memory:write或完全权限的凭据。使用archive_memories将条目保留在长期层级，或使用consolidate_memories在父摘要下保留子细节。当您只想隐藏已完成的工作时，不要调用此工具。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            },
            "key": {
              "type": "string",
              "description": "Memory key to delete"
            }
          },
          "required": [
            "playbook_id",
            "key"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "irreversible",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "delete_persona",
        "title_en": "Delete persona",
        "title_zh": "删除角色",
        "description_en": "Reset the playbook's singleton persona to the default Assistant name and system prompt. Despite the delete_* name, this is not a hard delete: each playbook always keeps exactly one logical persona, so the fields are overwritten rather than removed. persona_id must equal playbook_id because the persona is stored on the playbook row. Custom name, system prompt, and metadata are permanently replaced and cannot be undone. Requires personas:write or full permission. Use update_persona to change fields without resetting, create_persona to set a new identity, and delete_playbook only when the entire playbook should be removed.",
        "description_zh": "将剧本的单例角色重置为默认助手名称和系统提示。尽管名称中有delete_*，但这并不是硬删除：每个剧本始终只保留一个逻辑角色，因此字段被覆盖而不是删除。persona_id必须等于playbook_id，因为角色存储在剧本行上。自定义名称、系统提示和元数据将被永久替换，无法撤销。需要personas:write或完全权限。使用update_persona更改字段而不重置，使用create_persona设置新身份，仅在应删除整个剧本时使用delete_playbook。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID of the playbook"
            },
            "persona_id": {
              "type": "string",
              "description": "Must equal playbook_id; the persona is a singleton stored on the playbook"
            }
          },
          "required": [
            "playbook_id",
            "persona_id"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "irreversible",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "delete_playbook",
        "title_en": "Delete playbook",
        "title_zh": "删除剧本",
        "description_en": "Permanently delete a playbook and all of its contents (persona, skills, memory, API keys, canvas, and secrets). This cannot be undone. Requires playbooks:write or full permission, and only the owner may delete. Do not use this to reset a persona (delete_persona) or remove a single skill or memory; those have dedicated tools.",
        "description_zh": "永久删除剧本及其所有内容（角色、技能、记忆、API密钥、画布和机密）。此操作无法撤销。需要playbooks:write或完全权限，且只有所有者才能删除。不要使用此工具重置角色（delete_persona）或删除单个技能或记忆；这些有专门的工具。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID of the playbook to delete"
            }
          },
          "required": [
            "playbook_id"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "irreversible",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "find_tools",
        "title_en": "Find tools",
        "title_zh": "查找工具",
        "description_en": "Search this playbook's complete tool catalog by keyword: the built-in playbook tools (memory, skills, canvas, workflow runs, secrets) and every connected server's federated tools (names like supabase__execute_sql or cloudflare__search). Matches against tool names and descriptions; a name match ranks above a description match. Returns up to `limit` (default 10, max 25) entries with name, description, and full input schema. Every returned tool can be called directly by name even when it is absent from tools/list — the advertised list is a view, not a boundary, unless this connection was pinned with ?toolset=. Read-only and free of side effects. Use this when the tool you need is not in your current list, before concluding a capability is missing. Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "通过关键字搜索此剧本的完整工具目录：内置剧本工具（记忆、技能、画布、工作流运行、机密）以及每个连接服务器的联合工具（名称如supabase__execute_sql或cloudflare__search）。匹配工具名称和描述；名称匹配排名高于描述匹配。返回最多`limit`（默认10，最大25）个条目，包含名称、描述和完整输入模式。即使返回的工具不在tools/list中，也可以直接按名称调用——广告列表是一个视图，而不是边界，除非此连接使用?toolset=固定。只读且无副作用。当您需要的工具不在当前列表中时，在断定缺少能力之前使用此工具。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            },
            "query": {
              "type": "string",
              "description": "Keywords to match against tool names and descriptions, e.g. 'sql tables' or 'archive memory'"
            },
            "limit": {
              "type": "number",
              "description": "Maximum matches to return (default 10, max 25)"
            }
          },
          "required": [
            "playbook_id",
            "query"
          ]
        },
        "output_schema": {
          "type": "object",
          "properties": {
            "matches": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "name": {
                    "type": "string",
                    "description": "Callable tool name"
                  },
                  "description": {
                    "type": "string"
                  },
                  "inputSchema": {
                    "type": "object"
                  }
                },
                "required": [
                  "name",
                  "description",
                  "inputSchema"
                ]
              }
            }
          },
          "required": [
            "matches"
          ]
        },
        "unit_kind": "mcp_tool",
        "effect": "read",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "get_memory_context",
        "title_en": "Get memory context",
        "title_zh": "获取记忆上下文",
        "description_en": "Get a context-optimized view of memories: full working memory, summaries for contextual, and keys only for longterm. Read-only. Use this to pack a prompt; use read_memory for one key, search_memory to filter, and get_memory_tree for parent-child task graphs. Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "获取记忆的上下文优化视图：完整的工作记忆，上下文的摘要，以及仅长期的关键字。只读。使用此工具打包提示；使用read_memory获取单个键，使用search_memory过滤，使用get_memory_tree获取父子任务图。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            },
            "include_tiers": {
              "type": "array",
              "items": {
                "type": "string",
                "enum": [
                  "working",
                  "contextual",
                  "longterm"
                ]
              },
              "description": "Tiers to include (default: working, contextual)"
            },
            "max_items": {
              "type": "number",
              "description": "Maximum items per tier",
              "default": 20
            },
            "expand_keys": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "Keys to show full content regardless of tier"
            },
            "tags_filter": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "Only include memories with these tags"
            }
          },
          "required": [
            "playbook_id"
          ]
        },
        "output_schema": {
          "type": "object",
          "properties": {
            "tiers": {
              "type": "object",
              "additionalProperties": {
                "type": "array",
                "items": {
                  "type": "object"
                }
              }
            },
            "total_items": {
              "type": "number"
            }
          },
          "required": [
            "tiers",
            "total_items"
          ]
        },
        "unit_kind": "mcp_tool",
        "effect": "read",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "get_memory_tree",
        "title_en": "Get memory tree",
        "title_zh": "获取记忆树",
        "description_en": "Get a hierarchical tree of memories showing parent-child relationships and per-node status. Read-only. Use this to visualize task graphs; use search_memory to filter flat lists, get_memory_context for a tiered prompt view, and read_memory for a single key's full value. Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "获取记忆的分层树，显示父子关系和每个节点的状态。只读。使用此工具可视化任务图；使用search_memory过滤平面列表，使用get_memory_context获取分层提示视图，使用read_memory获取单个键的完整值。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            },
            "root_key": {
              "type": "string",
              "description": "Start from this key (omit for all roots)"
            },
            "max_depth": {
              "type": "number",
              "description": "Maximum tree depth",
              "default": 3
            },
            "include_values": {
              "type": "boolean",
              "description": "Include full values (false = summaries only)",
              "default": false
            }
          },
          "required": [
            "playbook_id"
          ]
        },
        "output_schema": {
          "type": "object",
          "properties": {
            "root": {
              "type": [
                "string",
                "null"
              ]
            },
            "tree": {
              "type": "array",
              "items": {
                "type": "object"
              }
            },
            "total_nodes": {
              "type": "number"
            }
          },
          "required": [
            "root",
            "tree",
            "total_nodes"
          ]
        },
        "unit_kind": "mcp_tool",
        "effect": "read",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "get_playbook",
        "title_en": "Get playbook",
        "title_zh": "获取剧本",
        "description_en": "Get a playbook with its singleton persona, skills, connected MCP servers, and memory. This is the only persona retrieval tool; there is no get_persona. Read-only. Requires playbooks:read or full permission. Use list_playbooks to discover IDs first, and get_skill when you need one skill's full content rather than the playbook summary.",
        "description_zh": "获取剧本及其单例角色、技能、连接的MCP服务器和记忆。这是唯一的角色检索工具；没有get_persona。只读。需要playbooks:read或完全权限。先使用list_playbooks发现ID，当您需要单个技能的完整内容而不是剧本摘要时，使用get_skill。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID of the playbook"
            }
          },
          "required": [
            "playbook_id"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "read",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "get_skill",
        "title_en": "Get skill",
        "title_zh": "获取技能",
        "description_en": "Return the full definition of one skill in this playbook, including name, description, content, priority, and attachments. Identify the skill with skill_id, which may be a UUID or the skill's kebab-case name. This lookup does not modify the skill. Use list_skills first to discover IDs and names. Do not use list_skill_versions (historical revisions) or get_playbook (persona and summaries, not full skill content). Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "返回此剧本中一个技能的完整定义，包括名称、描述、内容、优先级和附件。使用skill_id标识技能，可以是UUID或技能的kebab-case名称。此查找不会修改技能。先使用list_skills发现ID和名称。不要使用list_skill_versions（历史修订）或get_playbook（角色和摘要，不是完整技能内容）。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            },
            "skill_id": {
              "type": "string",
              "description": "Skill ID or name"
            }
          },
          "required": [
            "playbook_id",
            "skill_id"
          ]
        },
        "output_schema": {
          "type": "object",
          "properties": {
            "id": {
              "type": "string"
            },
            "playbook_id": {
              "type": "string"
            },
            "name": {
              "type": "string"
            },
            "description": {
              "type": [
                "string",
                "null"
              ]
            },
            "content": {
              "type": [
                "string",
                "null"
              ]
            },
            "licence": {
              "type": [
                "string",
                "null"
              ]
            },
            "publisher_id": {
              "type": [
                "string",
                "null"
              ]
            },
            "priority": {
              "type": [
                "number",
                "null"
              ]
            },
            "created_at": {
              "type": "string"
            },
            "skill_attachments": {
              "type": "array",
              "items": {
                "type": "object"
              }
            }
          }
        },
        "unit_kind": "mcp_tool",
        "effect": "read",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "list_playbooks",
        "title_en": "List playbooks",
        "title_zh": "列出剧本",
        "description_en": "List playbooks owned by or shared with the authenticated user, including access role and content counts. Read-only; it does not create or modify playbooks. Use get_playbook when you need the singleton persona, skills, connected servers, and memory for one playbook. Requires playbooks:read or full permission.",
        "description_zh": "列出由认证用户拥有或与其共享的剧本，包括访问角色和内容计数。只读；不会创建或修改剧本。当您需要单个剧本的单例角色、技能、连接的服务器和记忆时，请使用get_playbook。需要playbooks:read或完全权限。",
        "input_schema": {
          "type": "object",
          "properties": {}
        },
        "output_schema": {
          "type": "object",
          "properties": {
            "playbooks": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "id": {
                    "type": "string"
                  },
                  "guid": {
                    "type": "string"
                  },
                  "name": {
                    "type": "string"
                  },
                  "current_user_role": {
                    "type": "string"
                  },
                  "persona_count": {
                    "type": "number"
                  }
                },
                "additionalProperties": true
              }
            }
          },
          "required": [
            "playbooks"
          ]
        },
        "unit_kind": "mcp_tool",
        "effect": "read",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "list_skills",
        "title_en": "List skills",
        "title_zh": "列出技能",
        "description_en": "List every skill currently attached to this playbook, returning id, name, description, content, licence, and priority ordered by priority descending. Read-only; it does not create or change skills. Use this to discover skill_id values before get_skill, update_skill, or delete_skill. Do not use list_skill_versions, which lists historical revisions of a single skill, or get_playbook, which only summarizes skills. Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "列出当前附加到此剧本的每个技能，返回id、名称、描述、内容、许可证和优先级，按优先级降序排列。只读；不会创建或更改技能。在get_skill、update_skill或delete_skill之前，使用此工具发现skill_id值。不要使用list_skill_versions（列出单个技能的历史修订）或get_playbook（仅总结技能）。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            }
          },
          "required": [
            "playbook_id"
          ]
        },
        "output_schema": {
          "type": "object",
          "properties": {
            "skills": {
              "type": "array",
              "items": {
                "type": "object",
                "properties": {
                  "id": {
                    "type": "string",
                    "description": "Skill UUID"
                  },
                  "name": {
                    "type": "string"
                  },
                  "description": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "content": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "licence": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "publisher_id": {
                    "type": [
                      "string",
                      "null"
                    ]
                  },
                  "priority": {
                    "type": [
                      "number",
                      "null"
                    ]
                  }
                }
              }
            }
          },
          "required": [
            "skills"
          ]
        },
        "unit_kind": "mcp_tool",
        "effect": "read",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "promote_memory",
        "title_en": "Promote memory",
        "title_zh": "提升记忆",
        "description_en": "Promote a memory to a higher tier or boost its priority for active use. This tool cannot demote; use archive_memories to move working or contextual entries to longterm. Repeating the call with priority_boost increases priority again. Requires memory:write or full permission. Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "将记忆提升到更高层级或提高其优先级以供活动使用。此工具不能降级；使用archive_memories将工作或上下文条目移至长期。使用priority_boost重复调用会再次增加优先级。需要memory:write或完全权限。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            },
            "key": {
              "type": "string",
              "description": "Memory key to promote"
            },
            "target_tier": {
              "type": "string",
              "enum": [
                "working",
                "contextual"
              ],
              "description": "Target tier (cannot demote with this tool)"
            },
            "priority_boost": {
              "type": "number",
              "description": "Amount to increase priority (0-50)",
              "default": 10
            }
          },
          "required": [
            "playbook_id",
            "key"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "write",
        "open_world": false,
        "idempotency": "not_idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "read_memory",
        "title_en": "Read memory",
        "title_zh": "读取记忆",
        "description_en": "Read one memory entry by key and return its value, tags, tier, summary, and metadata. This is not a pure read: it increments access_count and updates last_accessed_at as a side effect, without changing the stored value. There is no update_memory; use write_memory to overwrite a key. Use search_memory to find keys, get_memory_context for a tiered summary, or get_memory_tree for hierarchical task graphs. Do not pass memory_type; that filter belongs to search_memory. Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "按键读取一个记忆条目，并返回其值、标签、层级、摘要和元数据。这不是纯粹的读取：它会增加access_count并更新last_accessed_at作为副作用，而不更改存储的值。没有update_memory；使用write_memory覆盖键。使用search_memory查找键，使用get_memory_context获取分层摘要，或使用get_memory_tree获取分层任务图。不要传递memory_type；该过滤器属于search_memory。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            },
            "key": {
              "type": "string",
              "description": "Memory key to read"
            }
          },
          "required": [
            "playbook_id",
            "key"
          ]
        },
        "output_schema": {
          "type": "object",
          "properties": {
            "key": {
              "type": "string"
            },
            "value": {},
            "tags": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "description": {
              "type": [
                "string",
                "null"
              ]
            },
            "tier": {
              "type": "string",
              "enum": [
                "working",
                "contextual",
                "longterm"
              ]
            },
            "priority": {
              "type": "number"
            },
            "parent_key": {
              "type": [
                "string",
                "null"
              ]
            },
            "summary": {
              "type": [
                "string",
                "null"
              ]
            },
            "access_count": {
              "type": "number"
            },
            "updated_at": {
              "type": "string"
            }
          }
        },
        "unit_kind": "mcp_tool",
        "effect": "read",
        "open_world": false,
        "idempotency": "not_idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "search_memory",
        "title_en": "Search memory",
        "title_zh": "搜索记忆",
        "description_en": "Search memories by text, tags, tier, or type. Returns summaries for large memories. Use tags for categorical search; use tier to focus on active vs archived data; use memory_type to find task graphs. Read-only aside from returning matches; it does not write entries. Use read_memory for one key, get_memory_context for a compact tiered view, and get_memory_tree for parent-child task graphs. Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "按文本、标签、层级或类型搜索记忆。返回大型记忆的摘要。使用标签进行分类搜索；使用层级关注活动与存档数据；使用memory_type查找任务图。除了返回匹配项外，只读；不会写入条目。使用read_memory获取单个键，使用get_memory_context获取紧凑的分层视图，使用get_memory_tree获取父子任务图。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            },
            "search": {
              "type": "string",
              "description": "Search in keys, descriptions, and summaries"
            },
            "tags": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "Filter by tags (any match)"
            },
            "tier": {
              "type": "string",
              "enum": [
                "working",
                "contextual",
                "longterm"
              ],
              "description": "Filter by memory tier"
            },
            "memory_type": {
              "type": "string",
              "enum": [
                "flat",
                "hierarchical"
              ],
              "description": "Filter by memory type"
            },
            "status": {
              "type": "string",
              "enum": [
                "pending",
                "running",
                "completed",
                "failed",
                "blocked"
              ],
              "description": "Filter by task status (hierarchical only)"
            },
            "include_children": {
              "type": "boolean",
              "description": "Include child memories in results",
              "default": false
            }
          },
          "required": [
            "playbook_id"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "read",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "update_persona",
        "title_en": "Update persona",
        "title_zh": "更新角色",
        "description_en": "Update the singleton persona's name, system prompt, or metadata without resetting to defaults. persona_id must equal playbook_id because the persona is stored on the playbook row. Requires personas:write or full permission. Use create_persona to replace name and system prompt together, delete_persona to reset to the default Assistant, and update_playbook when changing playbook-level fields as well.",
        "description_zh": "更新单例角色的名称、系统提示或元数据，而不重置为默认值。persona_id必须等于playbook_id，因为角色存储在剧本行上。需要personas:write或完全权限。使用create_persona同时替换名称和系统提示，使用delete_persona重置为默认助手，并在同时更改剧本级字段时使用update_playbook。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID of the playbook"
            },
            "persona_id": {
              "type": "string",
              "description": "Must equal playbook_id; the persona is a singleton stored on the playbook"
            },
            "name": {
              "type": "string",
              "description": "New name"
            },
            "system_prompt": {
              "type": "string",
              "description": "New system prompt"
            },
            "metadata": {
              "type": "object",
              "description": "New metadata"
            }
          },
          "required": [
            "playbook_id",
            "persona_id"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "write",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      },
      {
        "name": "write_memory",
        "title_en": "Write memory",
        "title_zh": "写入记忆",
        "description_en": "Create or overwrite a memory entry by key. There is no separate update_memory; a second write to the same key replaces the previous value and cannot be undone. Use tier='working' for active tasks, 'contextual' for background context, 'longterm' for completed work. Set memory_type='hierarchical' and parent_key to build task graphs. Requires memory:write or full permission. Use delete_memory to remove a key, archive_memories to move it to longterm without deleting, and read_memory to fetch without replacing. Pass playbook_id as the UUID or GUID of the playbook this call should target.",
        "description_zh": "按键创建或覆盖记忆条目。没有单独的update_memory；对同一键的第二次写入将替换先前的值且无法撤销。对活动任务使用tier='working'，对背景上下文使用'contextual'，对已完成工作使用'longterm'。设置memory_type='hierarchical'和parent_key以构建任务图。需要memory:write或完全权限。使用delete_memory删除键，使用archive_memories将其移至长期而不删除，使用read_memory获取而不替换。将playbook_id作为此调用应针对的剧本的UUID或GUID传递。",
        "input_schema": {
          "type": "object",
          "properties": {
            "playbook_id": {
              "type": "string",
              "description": "UUID or GUID of the target playbook"
            },
            "key": {
              "type": "string",
              "description": "Memory key"
            },
            "value": {
              "type": "object",
              "description": "Value to store"
            },
            "tags": {
              "type": "array",
              "items": {
                "type": "string"
              },
              "description": "Tags for categorization"
            },
            "description": {
              "type": "string",
              "description": "Human-readable description"
            },
            "tier": {
              "type": "string",
              "enum": [
                "working",
                "contextual",
                "longterm"
              ],
              "description": "Memory tier (default: contextual)"
            },
            "priority": {
              "type": "number",
              "description": "Priority 1-100 (default: 50)"
            },
            "parent_key": {
              "type": "string",
              "description": "Parent memory key for hierarchical organization"
            },
            "summary": {
              "type": "string",
              "description": "Compact summary for context views"
            },
            "memory_type": {
              "type": "string",
              "enum": [
                "flat",
                "hierarchical"
              ],
              "description": "flat (default) or hierarchical for task graphs"
            },
            "status": {
              "type": "string",
              "enum": [
                "pending",
                "running",
                "completed",
                "failed",
                "blocked"
              ],
              "description": "Task status (for hierarchical task tracking)"
            },
            "metadata": {
              "type": "object",
              "description": "Graph metadata: dependencies, thread assignment, progress, etc."
            }
          },
          "required": [
            "playbook_id",
            "key",
            "value"
          ]
        },
        "output_schema": {},
        "unit_kind": "mcp_tool",
        "effect": "irreversible",
        "open_world": false,
        "idempotency": "idempotent",
        "confirmation": "explicit policy",
        "evidence_ids": [
          "protocol-tools"
        ],
        "runtime_auth": {},
        "pricing": {},
        "metadata": {}
      }
    ],
    "review_profile": {
      "schema_version": "aiworkshub.resource-review/0.2",
      "method_version": "capability-evidence-v2",
      "review_state": {
        "identity": "verified",
        "source": "verified",
        "connectivity": "verified",
        "contract": "strong",
        "safe_use": "untested",
        "real_use": "unobserved"
      },
      "assessment": {
        "capability_definition": "strong",
        "contract_completeness": "strong",
        "access_friction": "high",
        "operational_transparency": "partial",
        "evidence_strength": "protocol_inspected",
        "use_readiness": "conditional"
      },
      "profile": {
        "capabilities": [
          {
            "id": "playbook.manage",
            "weight": 90,
            "confidence": 90,
            "evidence_ids": [
              "source-record",
              "protocol-tools"
            ]
          },
          {
            "id": "persona.manage",
            "weight": 80,
            "confidence": 90,
            "evidence_ids": [
              "protocol-tools"
            ]
          },
          {
            "id": "skill.manage",
            "weight": 80,
            "confidence": 90,
            "evidence_ids": [
              "protocol-tools"
            ]
          },
          {
            "id": "memory.manage",
            "weight": 90,
            "confidence": 90,
            "evidence_ids": [
              "protocol-tools"
            ]
          },
          {
            "id": "task-graph.manage",
            "weight": 70,
            "confidence": 80,
            "evidence_ids": [
              "protocol-tools"
            ]
          },
          {
            "id": "tool.discover",
            "weight": 60,
            "confidence": 80,
            "evidence_ids": [
              "protocol-tools"
            ]
          }
        ],
        "domains": [
          {
            "id": "agent-orchestration",
            "weight": 90,
            "confidence": 90,
            "evidence_ids": [
              "source-record",
              "protocol-tools"
            ]
          },
          {
            "id": "knowledge-management",
            "weight": 80,
            "confidence": 80,
            "evidence_ids": [
              "protocol-tools"
            ]
          }
        ],
        "workflow_roles": [
          "discover",
          "retrieve",
          "analyze",
          "design",
          "generate",
          "transform",
          "execute",
          "monitor",
          "deliver",
          "instruct"
        ]
      },
      "capability_units": [
        {
          "id": "tool:list_playbooks",
          "kind": "mcp_tool",
          "capability_id": "playbook.manage",
          "effect": "read",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "typed",
          "accepts": [],
          "produces": [
            "playbook list"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:create_playbook",
          "kind": "mcp_tool",
          "capability_id": "playbook.manage",
          "effect": "write",
          "open_world": false,
          "idempotency": "not_idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "playbook configuration"
          ],
          "produces": [
            "playbook"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:get_playbook",
          "kind": "mcp_tool",
          "capability_id": "playbook.manage",
          "effect": "read",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "playbook id"
          ],
          "produces": [
            "playbook details"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:delete_playbook",
          "kind": "mcp_tool",
          "capability_id": "playbook.manage",
          "effect": "irreversible",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "playbook id"
          ],
          "produces": [],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:create_persona",
          "kind": "mcp_tool",
          "capability_id": "persona.manage",
          "effect": "irreversible",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "persona configuration"
          ],
          "produces": [
            "persona"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:update_persona",
          "kind": "mcp_tool",
          "capability_id": "persona.manage",
          "effect": "write",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "persona configuration"
          ],
          "produces": [
            "updated persona"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:delete_persona",
          "kind": "mcp_tool",
          "capability_id": "persona.manage",
          "effect": "irreversible",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "playbook id",
            "persona id"
          ],
          "produces": [],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:find_tools",
          "kind": "mcp_tool",
          "capability_id": "tool.discover",
          "effect": "read",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "typed",
          "accepts": [
            "search query"
          ],
          "produces": [
            "tool matches"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:list_skills",
          "kind": "mcp_tool",
          "capability_id": "skill.manage",
          "effect": "read",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "typed",
          "accepts": [
            "playbook id"
          ],
          "produces": [
            "skill list"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:get_skill",
          "kind": "mcp_tool",
          "capability_id": "skill.manage",
          "effect": "read",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "typed",
          "accepts": [
            "playbook id",
            "skill id"
          ],
          "produces": [
            "skill details"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:read_memory",
          "kind": "mcp_tool",
          "capability_id": "memory.manage",
          "effect": "read",
          "open_world": false,
          "idempotency": "not_idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "typed",
          "accepts": [
            "memory key"
          ],
          "produces": [
            "memory entry"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:search_memory",
          "kind": "mcp_tool",
          "capability_id": "memory.manage",
          "effect": "read",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "search criteria"
          ],
          "produces": [
            "memory matches"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:write_memory",
          "kind": "mcp_tool",
          "capability_id": "memory.manage",
          "effect": "irreversible",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "memory key",
            "value"
          ],
          "produces": [
            "memory entry"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:delete_memory",
          "kind": "mcp_tool",
          "capability_id": "memory.manage",
          "effect": "irreversible",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "memory key"
          ],
          "produces": [],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:consolidate_memories",
          "kind": "mcp_tool",
          "capability_id": "memory.manage",
          "effect": "write",
          "open_world": false,
          "idempotency": "not_idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "memory keys",
            "parent key",
            "summary"
          ],
          "produces": [
            "consolidated memory"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:promote_memory",
          "kind": "mcp_tool",
          "capability_id": "memory.manage",
          "effect": "write",
          "open_world": false,
          "idempotency": "not_idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "memory key"
          ],
          "produces": [
            "promoted memory"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:get_memory_context",
          "kind": "mcp_tool",
          "capability_id": "memory.manage",
          "effect": "read",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "typed",
          "accepts": [
            "playbook id"
          ],
          "produces": [
            "memory context"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:archive_memories",
          "kind": "mcp_tool",
          "capability_id": "memory.manage",
          "effect": "write",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "playbook id"
          ],
          "produces": [
            "archived memories"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:get_memory_tree",
          "kind": "mcp_tool",
          "capability_id": "memory.manage",
          "effect": "read",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "typed",
          "accepts": [
            "playbook id"
          ],
          "produces": [
            "memory tree"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        },
        {
          "id": "tool:create_task_graph",
          "kind": "mcp_tool",
          "capability_id": "task-graph.manage",
          "effect": "irreversible",
          "open_world": false,
          "idempotency": "idempotent",
          "confirmation": "explicit policy",
          "input_contract": "typed",
          "output_contract": "untyped",
          "accepts": [
            "plan key",
            "tasks"
          ],
          "produces": [
            "task graph"
          ],
          "runtime_auth": {},
          "pricing": {},
          "evidence_ids": [
            "protocol-tools"
          ],
          "metadata": {}
        }
      ],
      "access": {},
      "operational_flags": [
        "requires_api_key",
        "deprecated_registry_status"
      ],
      "trust": {
        "signal": "none",
        "evidence_ids": [
          "source-record",
          "protocol-tools"
        ],
        "reason": "No suspicious or malicious evidence found."
      },
      "fit": {
        "good_for": [
          "Managing portable agent playbooks and personas",
          "Organizing agent skills and memory",
          "Building hierarchical task plans",
          "Discovering tools across connected servers"
        ],
        "not_for": [
          "Scenarios requiring no authentication",
          "Use cases needing fine-grained persona management beyond singleton",
          "Production use without testing due to untested safe use"
        ]
      },
      "evidence": [
        {
          "id": "source-record",
          "type": "registry_record",
          "source": "https://github.com/matebenyovszky/agentplaybooks",
          "observation": "MCP source record for AgentPlaybooks; version 1.0.0.",
          "observed_at": null,
          "payload": {}
        },
        {
          "id": "protocol-tools",
          "type": "protocol_observation",
          "source": "https://agentplaybooks.ai/api/mcp/manage#tools/list",
          "observation": "49 tools were returned by MCP discovery; 20 were retained for review.",
          "observed_at": "2026-09-03T06:06:29.774Z",
          "payload": {}
        }
      ],
      "unknowns": [
        "Pricing model is unknown.",
        "Exact authentication mechanism beyond Bearer token is unknown.",
        "Full list of 49 tools not reviewed; only 20 retained.",
        "Real-world usage not observed.",
        "Safe use not tested."
      ],
      "id": "REV_FDEDB54BF4DD",
      "resource_id": "RES_88DBE012A24B",
      "evaluator_type": "platform_ai",
      "provider": "deepseek",
      "model": "deepseek-v4-flash",
      "review_scope": "protocol-inspected-mcp",
      "created_at": "2026-09-03T06:31:39.711Z"
    }
  }
}