[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6MMENWQ04KQYGC8369DA5EK":3,"skill-same:01M6MMENWQ04KQYGC8369DA5EK":96},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":31,"publishedAt":52,"linkOnly":53,"markdownContent":54,"markdownBody":55,"frontMatter":56,"refName":59,"commitSha":60,"skillDirectory":61,"forksCount":62,"repositoryHtmlUrl":63,"repositoryHomepageUrl":64,"ownerHtmlUrl":65,"ownerBlogUrl":66,"ownerDescription":67,"updatedAt":68,"install":69,"resources":81},"01M6MMENWQ04KQYGC8369DA5EK","tool-design",null,"Design or audit the tools an AI agent calls (MCP server tools, function calling, Runtype runtime and saved tools), or find out why an agent picks the wrong tool or misuses one. Routes naming, schema, output, error, execution, and security work to focused guides.","hashgraph-online\u002Fawesome-codex-plugins","hashgraph-online","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F160371962?v=4","01M6CNB6NRJVNNGN14TR01Q6D3","HOL (Hashgraph Online)","01M6JT1HSKKG9V68KQAQGBA7XP",1575,"Apache-2.0","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fruntypelabs\u002Fskills\u002Fskills\u002Ftool-design\u002FSKILL.md",[18,23,26],{"categoryNo":19,"categoryName":20,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000015","视觉设计","SCENARIO","使用场景",{"categoryNo":24,"categoryName":25,"taxonomyType":21,"taxonomyTypeDesc":22},"01JBSEEDCAT000000000000023","Skill与智能体开发",{"categoryNo":27,"categoryName":28,"taxonomyType":29,"taxonomyTypeDesc":30},"01JBSEEDCAT000000000000032","设计师","PROFESSION","适用职业",[32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51],"tool design","tool","design","execution","true","calls","error","guides","runtime","work","why","Tools","SET","server","audit","ai agent","mcp server","security","review","MCP","2026-11-10 10:12:30",false,"---\nname: tool-design\ndescription: 'Design or audit the tools an AI agent calls (MCP server tools, function calling, Runtype runtime and saved tools), or find out why an agent picks the wrong tool or misuses one. Routes naming, schema, output, error, execution, and security work to focused guides.'\nuser-invocable: true\nargument-hint: '[tool or tool set to design or review]'\n---\n\n# Tool Design\n\nA tool that returns correct data can still fail in production because the agent could\nnot tell when to call it, what to pass, or what to do with the result. \"Working\" is not\nthe same as \"agent-usable\". This skill family treats the agent as the consumer and\ndesigns for it.\n\nThe guidance is framework-neutral: it applies to MCP servers, native function calling,\nRuntype runtime tools, and any custom loop. It is organized as 54 named patterns across\nten questions; `references\u002Fpattern-index.md` maps every pattern to the skill that owns\nit.\n\n## The consumer changed, so the design rules changed\n\n| Aspect        | Integration middleware | Agent tools                             |\n| ------------- | ---------------------- | --------------------------------------- |\n| Consumer      | Applications           | An LLM                                  |\n| Routing       | Predetermined flows    | Chosen by the agent at runtime          |\n| Errors        | Dead-letter queue      | Recovery guidance the agent can act on  |\n| Documentation | Written for humans     | Written for machine comprehension       |\n| Composition   | Orchestrated by a bus  | Chained by the agent, non-deterministic |\n\nNothing enforces sequence for the agent. The tool descriptions, parameter shapes, result\nshapes, and error messages are the only orchestration layer there is.\n\n## Four rules that apply to every tool\n\n1. **Design for the model, not the human.** Names, descriptions, parameter names, and\n   error text are read by an LLM. Be literal, structured, and complete.\n2. **Prompts express intent; code enforces rules.** Authorization, secrets, boundaries,\n   and audit live in the tool layer. Never rely on the agent to police itself.\n3. **Errors teach, not just fail.** Every failure says what went wrong, why, and the\n   exact next call to make.\n4. **Hint at what comes next.** Descriptions and results name prerequisites and\n   follow-ups so the agent builds the workflow without trial and error.\n\n## Procedure: design a new tool\n\n1. **Classify it** on the three axes and write the answers down before writing a schema:\n   - Type: `query` (read-only, retryable, cacheable), `command` (side effects, document\n     irreversibility), or `discovery` (reveals what exists, schema, capabilities).\n   - Integration: API, database, file system, or system operation. Databases and\n     command tools need idempotency because agents retry on timeout.\n   - Access pattern: synchronous (most tools; bounded seconds), async job (minutes;\n     return a job id), streaming, or event-driven.\n   - Maturity: start **atomic**. Move to enhanced, composite, or orchestrated only\n     when traces show the signal (see \"Level up on evidence\").\n2. **Write the interface** with `tool-design-interface`: a verb-object name, a description\n   that says when to use it and when not to, constrained parameters, smart defaults,\n   natural identifiers, and dependency hints.\n3. **Shape the result** with `tool-design-output`: flat, token-efficient, paginated by\n   cursor, summary by default, with GUI links and a next-action hint.\n4. **Design the failure paths** with `tool-design-errors`: classify every error as\n   retryable, permanent, needs-user-input, or needs-auth, and attach recovery steps.\n5. **Decide execution semantics** with `tool-design-execution`: timeout, idempotency\n   key, transaction or compensation, async job when work exceeds the sync budget.\n6. **Lock the boundary** with `tool-design-security`: secrets injected server-side,\n   permission checks in code, declared scopes, audit log, identity anchor.\n7. **Place it in the set** with `tool-design-composition`: does it bundle a common\n   sequence, accept a batch, offer preview mode, sit on an abstraction ladder?\n8. **Test it as the agent would.** Call it with the inputs an LLM will plausibly send\n   (natural-language dates, display names instead of ids, a single item where an array\n   is expected) and read the errors back as if you knew nothing but the description.\n\n## Procedure: review an existing tool set\n\nRun this when asked to audit, review, or \"figure out why the agent misuses\" a toolkit.\n\n1. **Inventory.** List every tool with type (query\u002Fcommand\u002Fdiscovery), parameter count,\n   required-parameter count, and whether it has side effects. Flag any tool whose type\n   is not obvious from its name.\n2. **Read every description as the model.** For each tool, answer only from the\n   description: when do I call this? what do I need first? what do I get back? If any\n   answer is unclear, that is a finding.\n3. **Check the parameters** against `tool-design-interface`: free-form strings that\n   should be enums, required parameters that could default, ids where a natural\n   identifier would do, secrets accepted as parameters (a security finding, not a\n   style one), ambiguous \"one of X or Y\" pairs without enforcement.\n4. **Check the results** against `tool-design-output`: raw upstream payloads, nested\n   blobs, unbounded lists, missing `hasMore` and cursor, no GUI link, batch results\n   that collapse to all-or-nothing.\n5. **Check the errors** against `tool-design-errors`: raw status codes, messages with\n   no next step, no retryable\u002Fpermanent distinction, ambiguity resolved by guessing.\n6. **Check execution and security** against `tool-design-execution` and\n   `tool-design-security`: command tools with no idempotency story, work that cannot\n   finish inside the timeout, permission logic in the system prompt, no audit trail.\n7. **Check the set as a whole** against `tool-design-composition`: near-duplicate tools,\n   sequences the agent always performs together (bundle candidates), N-item loops\n   (batch candidates), destructive tools without a preview mode, more tools than the\n   model can hold in context at once.\n8. **Report** findings as a table: tool, pattern violated, severity (blocks the agent \u002F\n   degrades reliability \u002F polish), concrete fix. Lead with the findings that make the\n   agent choose the wrong tool or fail to recover; those dominate observed failures.\n\n## Level up on evidence, not ambition\n\nStart atomic and watch traces. Each signal maps to a specific move:\n\n| Signal in traces                               | Move                                            |\n| ---------------------------------------------- | ----------------------------------------------- |\n| High retry rate on one tool                    | Fix description and error guidance first        |\n| The same tool sequence repeated across runs    | Bundle it into a task tool                      |\n| Per-item loops over the same tool              | Add a batch variant                             |\n| Partial completion of multi-step operations    | Add a transaction boundary or compensation      |\n| Agent calls a tool it lacks prerequisites for  | Add dependency hints and a discovery tool       |\n| Agent picks the wrong one of two similar tools | Merge them or sharpen the \"use when \u002F not when\" |\n| Long-running calls time out                    | Convert to an async job                         |\n\nDo not build the orchestrated version first. Composite tools built before atomic usage\nis understood encode guesses about workflows the agent never runs.\n\n## Pre-ship checklist\n\nEvery tool must pass all of these before it reaches an agent:\n\n- Name is verb-object and unambiguous next to every sibling tool.\n- Description says what it does, when to use it, when not to, and what to call first.\n- Every string input that has a finite set of valid values is an enum.\n- Every optional parameter has a documented default; required parameters are minimal.\n- Human-friendly identifiers are accepted and resolved internally.\n- Result is flat, token-efficient, and consistent in shape across calls.\n- Large results are cursor-paginated with an explicit `hasMore`.\n- Errors carry a class (retryable \u002F permanent \u002F user input \u002F auth) and a next step.\n- Command tools state whether they are idempotent and how.\n- Secrets are injected from context, never accepted as parameters.\n- Permission checks run in code before the operation.\n- Invocations are logged with redacted parameters.\n- Destructive or costly commands are gated (approval, preview mode, or both).\n\n`references\u002Fchecklist.md` carries the same list with the pattern each row comes from.\n\n## On Runtype\n\nThe preceding sections are framework-neutral. When you build natively on Runtype, the\nplatform enforces most of these patterns, so your job is to know which mechanism\ncarries each one.\n\n### Which tool kind carries which pattern\n\n| Tool kind (`toolType`) | What it is                                                                            | Patterns it carries                                                                                                                      |\n| ---------------------- | ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |\n| `external`             | HTTP call defined by `url`, `method`, `headers`, `body` template                      | Tool Adapter, Secret Injection (`{{secret:KEY}}`), request mapping (the `body` template)                                                 |\n| `custom`               | Sandboxed code (JavaScript by default; TypeScript or Python in a sandbox environment) | Parameter Coercion, Response Shaper, Error Classification, Natural Identifier resolution; Tool Adapter when it opts into `networkAccess` |\n| `flow`                 | A saved flow exposed as one tool, run synchronously                                   | Task Bundle, Tool Chain, Compensation (per-step `errorHandling`), Response Shaper (`outputVariable`)                                     |\n| `subagent`             | Delegation to a saved or inline agent (`agentId` or `agent`)                          | Abstraction Ladder (the orchestrated rung), Scatter-Gather, Async Job (detached mode)                                                    |\n| `local`                | Executed by the client (browser widget or SDK caller)                                 | Confirmation Request, anything needing the user's environment                                                                            |\n| `mcp`                  | A tool discovered from an MCP server                                                  | Tool Gateway, Tool Registry (`discover_mcp_server_tools`)                                                                                |\n| `builtin` \u002F Orthogonal | Platform catalog tools (attached by id, not created)                                  | Canonical Tool Model, house style for descriptions                                                                                       |\n\nAn `external` tool returns the upstream response as-is; shape it in a `flow` tool\n(`api-call` step into `transform-data`) or in a downstream `transform-data` step. A\n`custom` tool can make the call itself only when it opts in: set `networkAccess` to an\n`allowedHostnames` list, and declare any managed secret in `secrets` so the code sends a\nphantom token that the egress proxy swaps for the real credential. Without\n`networkAccess`, a `custom` tool has no network egress. A `flow` tool returns the flow's terminal step output; set\n`config.outputVariable` to return one shaped variable instead. Long-running work is not\na `flow` tool either: a `subagent` tool with `config.execution.mode: \"detached\"` returns\na run handle, and `run_flow` with `async: true` returns an execution id (see\n`tool-design-execution`).\n\n`create_tool` also accepts `graphql`, but no executor runs that type: a call to a\n`graphql` tool fails with an unsupported-type error. Send a GraphQL query from an\n`external` tool with `method: \"POST\"` and the query in the `body` template.\n\nThe MCP `create_tool` accepts `tool_type` in `flow`, `custom`, `external`, `graphql`,\n`mcp`, `local`, with `name`, `description`, `parameters_schema` (JSON Schema), and\n`config`. `name` is at most 100 characters and `description` at most 500 on create, so\nkeep the description tight and put detail in parameter descriptions and error text. The\nREST API and SDKs (`POST \u002Fv1\u002Ftools`, spelled `toolType` and `parametersSchema`) accept\nthe same set plus `subagent`. To delegate to agents over MCP, pick the route by need:\n\n- A fixed saved agent as a tool: wrap it in a flow with an `execute-agent` step and\n  register that flow with `tool_type: \"flow\"`. Agent ids are not valid tool ids.\n- Delegation the agent decides at run time: set the agent's\n  `config.tools.subagentConfig`, which gives it a `spawn_subagent` tool.\n\n`builtin` tools are never created; attach them by id through `config.tools.toolIds`.\nIterate with `update_tool` and `get_tool`; read\n`get_platform_documentation(topic=\"external-tools\")` and\n`get_platform_documentation(topic=\"limits\")` before designing.\n\n### What the platform enforces for you\n\n- Credentials: `{{secret:KEY}}` references resolve server-side and are the only\n  credential contract. Never collect secret values in chat; hand the user the intake\n  URL from `get_secret_intake_manifest`.\n- Context injection: on runtime tools (an agent's `tools.runtimeTools` or\n  `\u002Fv1\u002Fdispatch`), `hiddenParameterNames` strips parameters from the model-facing schema\n  and fills them from execution variables. List `_endUser` or `_tenant` there to anchor\n  the verified caller identity so the model never supplies it. Saved tools created with\n  `create_tool` do not take this field. Names under `_internal` are rejected; use\n  `{{secret:KEY}}` for credentials.\n- Human-owned inputs: `config.elicit` on an `external` or `custom` tool pauses the run\n  for a form before approval and dispatch. Use it instead of letting the model invent\n  an argument that belongs to the person.\n- Permission gate: `config.tools.approval.require` pauses the run for a human on the\n  listed tools; the agent's `_approvalReason` is display-only, never a control signal.\n  `approval.timeout` (default 5 min), `approval.requestReason`, and `approval.choices`\n  (`alwaysAllow`, `alwaysDeny`) shape the prompt. Approval covers only calls a model\n  chooses in an agent or prompt step. A flow `tool-call` step always runs, unattended.\n- Idempotency: set `idempotent: true` only on runtime tools that are safe to run twice,\n  such as reads or writes keyed by an idempotency key. When a turn is interrupted\n  mid-call, Runtype re-runs only those; any other call returns an \"effects unknown,\n  verify before retrying\" error instead of running twice. For MCP tools, declare\n  `readOnlyHint` or `idempotentHint` on the server; with neither, the tool is treated\n  as unsafe to re-run.\n- Files and media: a binary media part of 4 KB or more in a tool result is stored and\n  handed to the model as a `runtype-asset:\u002F\u002F` handle. Declare a parameter as\n  `{ \"type\": \"string\", \"contentEncoding\": \"base64\" }` to receive those bytes; Runtype\n  substitutes them before dispatch, so the model never re-emits the payload. This is\n  the Resource Reference pattern on Runtype.\n- Audit: every tool call is traced on the run and visible in Runs, Logs, and\n  `trace_execution`.\n- Timeouts: a runtime custom tool is limited to 30 s. A saved custom tool takes its own\n  `timeout` in milliseconds, up to 300 s in the tool editor. MCP tools default to 30 s\n  and can run up to 300 s only in background runs. A subagent tool defaults to 5 min.\n  Longer work belongs in an async flow run or a detached subagent.\n- Tool set controls: `maxToolCalls` bounds tool-call loops, and `toolCallStrategy` is\n  `auto`, `required`, or `none`. Do not set `perToolLimits`: it is retired, and an agent\n  that carries it is rejected. Bound the loop with `loopConfig.maxTurns` or\n  `loopConfig.maxCost`, or enforce a per-tool budget inside the tool. `codeModeConfig`\n  gives the agent a `code_mode` tool that chains a subset of its tools in sandboxed\n  code, an alternative to hand-built bundle and batch tools.\n- Tool count: no cap; a request's serialized `runtimeTools` may total 1 MB. A provider\n  can still refuse a long list (`TOOL_COUNT_REFUSED_BY_PROVIDER`). Tool search is on by\n  default for multi-turn agents at 20+ tools (inline tools defer behind `tool_search`,\n  and `tools.toolSearch.enabled: false` opts out); use it for large tool sets. Single-turn agents send every tool on every\n  request, so keep sets small or split them across agents.\n- Save-time checks: `validate_flow` reports several checklist rows as stable codes\n  (see `references\u002Fchecklist.md`, \"Checked for you on Runtype\").\n\n### The test loop\n\n1. Read `validation.warnings` and `validation.recommendations` in the `create_tool` or\n   `update_tool` response. The save succeeds even when they are present, so no error\n   tells you to look.\n2. `execute_tool` with the inputs an agent will plausibly send, including wrong ones,\n   and read the result and error as the model would.\n3. Wire it into an agent and run a realistic prompt with `execute_agent` or `dispatch`.\n4. When a real run misuses the tool, pin it: `add_eval_case_from_execution`, then\n   `run_eval_suite` after every description or schema change. Read\n   `get_platform_documentation(topic=\"evals\")` for tool-use eval layers.\n\n## Measure it in a simulation\n\nA review produces findings; a simulation measures what fixing them is worth before\nanyone changes the server. Runtype simulations record what an MCP server answers, then\nserve a redesigned surface from those recordings to the same simulated users, so the\ncomparison is paired and the server receives no designed call. Simulations run on\nRuntype staging and preview deployments only; the production API answers 404\n`SIMULATIONS_DISABLED` and its MCP server does not list these tools.\n\n1. **Record.** Run a simulation against the server as published (`run_simulation`),\n   with recording on for the target (`update_simulation_target` with\n   `recording: { enabled: true, retention_days: 90 }`). For a tool no run has called,\n   upload real answers with `upload_simulation_tool_exchanges` or\n   `runtype simulations exchanges upload \u003Ctarget> \u003Cfile>`.\n2. **Read the evidence.** `get_simulation_tool_profile` returns the observed output\n   schema, the error catalog with the share the agent recovered from, and\n   `shapeFindings` that cite checklist rows 11, 13, 19, 20, 21 and 26, each with a\n   `suggestedOp` when one maps. `get_simulation_report` carries the trace signals:\n   confused pairs, argument errors by field, never-discovered tools.\n3. **Write the design as operations.** `propose_simulation_variants` with\n   `proposer: \"model\"` stages at most two designs that cite a checklist row per\n   operation, or write them yourself on the variant's `tool_surface` change and save\n   with `update_simulation_variant` and `validate: true`, which runs every operation on\n   recorded answers as a run would.\n4. **Preview.** `preview_simulation_variant` shows one recorded answer as published and\n   as designed. Fix an operation here, not after a paid run.\n5. **Run it paired.** Give the baseline `tool_policy: { \"*\": \"recorded\" }` and the\n   design `{ \"*\": \"simulated\" }`, then `run_simulation`. Pass\n   `replay: { synthesize: false }` on the design when the verdict must rest on\n   recordings and deterministic operations only.\n6. **Decide on the investment card.** The report's `investment` section reads\n   Recommended only when no deciding conversation rested on a synthesized answer and\n   the synthesized share is under the threshold (25% by default); otherwise Indicative,\n   with the reason. Record the missing calls live or add a deterministic operation,\n   then rerun.\n7. **Hand it over.** `export_simulation_design_brief` returns the Markdown brief:\n   before and after definitions, response mappings, error envelopes, each operation's\n   checklist row and measured effect. Later live runs mark each operation adopted or\n   not; `list_simulation_design_briefs` shows it beside the baseline trend.\n\nThe checklist rows map to operations as follows:\n\n| Checklist rows     | Operation                                | What the design changes                                  |\n| ------------------ | ---------------------------------------- | -------------------------------------------------------- |\n| 11, 12, 14, 18, 19 | `shape`                                  | Flattens, renames, drops or truncates fields of a result |\n| 13                 | `paginate`                               | One cursor style with `items`, `cursor` and `hasMore`    |\n| 20, 21, 22         | `error_design`                           | Error class, reason, recovery steps naming the next tool |\n| 6, 23              | `accept_identifier`                      | Accepts a name and resolves it to an id through a lookup |\n| 10, 34, 38, 39     | `add_tool`                               | A bundle, batch, discovery or identity tool              |\n| 1, 3, 4, 5         | `rename`, `describe`, `schema`, `preset` | Names, descriptions and argument schemas                 |\n\nDeveloper guide: \"Design a better tool surface without deploying it\"\n(`\u002Fdeveloper-guides\u002Fguides\u002Fdesign-tool-surface-in-simulation` on the Runtype docs).\n","# Tool Design\n\nA tool that returns correct data can still fail in production because the agent could\nnot tell when to call it, what to pass, or what to do with the result. \"Working\" is not\nthe same as \"agent-usable\". This skill family treats the agent as the consumer and\ndesigns for it.\n\nThe guidance is framework-neutral: it applies to MCP servers, native function calling,\nRuntype runtime tools, and any custom loop. It is organized as 54 named patterns across\nten questions; `references\u002Fpattern-index.md` maps every pattern to the skill that owns\nit.\n\n## The consumer changed, so the design rules changed\n\n| Aspect        | Integration middleware | Agent tools                             |\n| ------------- | ---------------------- | --------------------------------------- |\n| Consumer      | Applications           | An LLM                                  |\n| Routing       | Predetermined flows    | Chosen by the agent at runtime          |\n| Errors        | Dead-letter queue      | Recovery guidance the agent can act on  |\n| Documentation | Written for humans     | Written for machine comprehension       |\n| Composition   | Orchestrated by a bus  | Chained by the agent, non-deterministic |\n\nNothing enforces sequence for the agent. The tool descriptions, parameter shapes, result\nshapes, and error messages are the only orchestration layer there is.\n\n## Four rules that apply to every tool\n\n1. **Design for the model, not the human.** Names, descriptions, parameter names, and\n   error text are read by an LLM. Be literal, structured, and complete.\n2. **Prompts express intent; code enforces rules.** Authorization, secrets, boundaries,\n   and audit live in the tool layer. Never rely on the agent to police itself.\n3. **Errors teach, not just fail.** Every failure says what went wrong, why, and the\n   exact next call to make.\n4. **Hint at what comes next.** Descriptions and results name prerequisites and\n   follow-ups so the agent builds the workflow without trial and error.\n\n## Procedure: design a new tool\n\n1. **Classify it** on the three axes and write the answers down before writing a schema:\n   - Type: `query` (read-only, retryable, cacheable), `command` (side effects, document\n     irreversibility), or `discovery` (reveals what exists, schema, capabilities).\n   - Integration: API, database, file system, or system operation. Databases and\n     command tools need idempotency because agents retry on timeout.\n   - Access pattern: synchronous (most tools; bounded seconds), async job (minutes;\n     return a job id), streaming, or event-driven.\n   - Maturity: start **atomic**. Move to enhanced, composite, or orchestrated only\n     when traces show the signal (see \"Level up on evidence\").\n2. **Write the interface** with `tool-design-interface`: a verb-object name, a description\n   that says when to use it and when not to, constrained parameters, smart defaults,\n   natural identifiers, and dependency hints.\n3. **Shape the result** with `tool-design-output`: flat, token-efficient, paginated by\n   cursor, summary by default, with GUI links and a next-action hint.\n4. **Design the failure paths** with `tool-design-errors`: classify every error as\n   retryable, permanent, needs-user-input, or needs-auth, and attach recovery steps.\n5. **Decide execution semantics** with `tool-design-execution`: timeout, idempotency\n   key, transaction or compensation, async job when work exceeds the sync budget.\n6. **Lock the boundary** with `tool-design-security`: secrets injected server-side,\n   permission checks in code, declared scopes, audit log, identity anchor.\n7. **Place it in the set** with `tool-design-composition`: does it bundle a common\n   sequence, accept a batch, offer preview mode, sit on an abstraction ladder?\n8. **Test it as the agent would.** Call it with the inputs an LLM will plausibly send\n   (natural-language dates, display names instead of ids, a single item where an array\n   is expected) and read the errors back as if you knew nothing but the description.\n\n## Procedure: review an existing tool set\n\nRun this when asked to audit, review, or \"figure out why the agent misuses\" a toolkit.\n\n1. **Inventory.** List every tool with type (query\u002Fcommand\u002Fdiscovery), parameter count,\n   required-parameter count, and whether it has side effects. Flag any tool whose type\n   is not obvious from its name.\n2. **Read every description as the model.** For each tool, answer only from the\n   description: when do I call this? what do I need first? what do I get back? If any\n   answer is unclear, that is a finding.\n3. **Check the parameters** against `tool-design-interface`: free-form strings that\n   should be enums, required parameters that could default, ids where a natural\n   identifier would do, secrets accepted as parameters (a security finding, not a\n   style one), ambiguous \"one of X or Y\" pairs without enforcement.\n4. **Check the results** against `tool-design-output`: raw upstream payloads, nested\n   blobs, unbounded lists, missing `hasMore` and cursor, no GUI link, batch results\n   that collapse to all-or-nothing.\n5. **Check the errors** against `tool-design-errors`: raw status codes, messages with\n   no next step, no retryable\u002Fpermanent distinction, ambiguity resolved by guessing.\n6. **Check execution and security** against `tool-design-execution` and\n   `tool-design-security`: command tools with no idempotency story, work that cannot\n   finish inside the timeout, permission logic in the system prompt, no audit trail.\n7. **Check the set as a whole** against `tool-design-composition`: near-duplicate tools,\n   sequences the agent always performs together (bundle candidates), N-item loops\n   (batch candidates), destructive tools without a preview mode, more tools than the\n   model can hold in context at once.\n8. **Report** findings as a table: tool, pattern violated, severity (blocks the agent \u002F\n   degrades reliability \u002F polish), concrete fix. Lead with the findings that make the\n   agent choose the wrong tool or fail to recover; those dominate observed failures.\n\n## Level up on evidence, not ambition\n\nStart atomic and watch traces. Each signal maps to a specific move:\n\n| Signal in traces                               | Move                                            |\n| ---------------------------------------------- | ----------------------------------------------- |\n| High retry rate on one tool                    | Fix description and error guidance first        |\n| The same tool sequence repeated across runs    | Bundle it into a task tool                      |\n| Per-item loops over the same tool              | Add a batch variant                             |\n| Partial completion of multi-step operations    | Add a transaction boundary or compensation      |\n| Agent calls a tool it lacks prerequisites for  | Add dependency hints and a discovery tool       |\n| Agent picks the wrong one of two similar tools | Merge them or sharpen the \"use when \u002F not when\" |\n| Long-running calls time out                    | Convert to an async job                         |\n\nDo not build the orchestrated version first. Composite tools built before atomic usage\nis understood encode guesses about workflows the agent never runs.\n\n## Pre-ship checklist\n\nEvery tool must pass all of these before it reaches an agent:\n\n- Name is verb-object and unambiguous next to every sibling tool.\n- Description says what it does, when to use it, when not to, and what to call first.\n- Every string input that has a finite set of valid values is an enum.\n- Every optional parameter has a documented default; required parameters are minimal.\n- Human-friendly identifiers are accepted and resolved internally.\n- Result is flat, token-efficient, and consistent in shape across calls.\n- Large results are cursor-paginated with an explicit `hasMore`.\n- Errors carry a class (retryable \u002F permanent \u002F user input \u002F auth) and a next step.\n- Command tools state whether they are idempotent and how.\n- Secrets are injected from context, never accepted as parameters.\n- Permission checks run in code before the operation.\n- Invocations are logged with redacted parameters.\n- Destructive or costly commands are gated (approval, preview mode, or both).\n\n`references\u002Fchecklist.md` carries the same list with the pattern each row comes from.\n\n## On Runtype\n\nThe preceding sections are framework-neutral. When you build natively on Runtype, the\nplatform enforces most of these patterns, so your job is to know which mechanism\ncarries each one.\n\n### Which tool kind carries which pattern\n\n| Tool kind (`toolType`) | What it is                                                                            | Patterns it carries                                                                                                                      |\n| ---------------------- | ------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |\n| `external`             | HTTP call defined by `url`, `method`, `headers`, `body` template                      | Tool Adapter, Secret Injection (`{{secret:KEY}}`), request mapping (the `body` template)                                                 |\n| `custom`               | Sandboxed code (JavaScript by default; TypeScript or Python in a sandbox environment) | Parameter Coercion, Response Shaper, Error Classification, Natural Identifier resolution; Tool Adapter when it opts into `networkAccess` |\n| `flow`                 | A saved flow exposed as one tool, run synchronously                                   | Task Bundle, Tool Chain, Compensation (per-step `errorHandling`), Response Shaper (`outputVariable`)                                     |\n| `subagent`             | Delegation to a saved or inline agent (`agentId` or `agent`)                          | Abstraction Ladder (the orchestrated rung), Scatter-Gather, Async Job (detached mode)                                                    |\n| `local`                | Executed by the client (browser widget or SDK caller)                                 | Confirmation Request, anything needing the user's environment                                                                            |\n| `mcp`                  | A tool discovered from an MCP server                                                  | Tool Gateway, Tool Registry (`discover_mcp_server_tools`)                                                                                |\n| `builtin` \u002F Orthogonal | Platform catalog tools (attached by id, not created)                                  | Canonical Tool Model, house style for descriptions                                                                                       |\n\nAn `external` tool returns the upstream response as-is; shape it in a `flow` tool\n(`api-call` step into `transform-data`) or in a downstream `transform-data` step. A\n`custom` tool can make the call itself only when it opts in: set `networkAccess` to an\n`allowedHostnames` list, and declare any managed secret in `secrets` so the code sends a\nphantom token that the egress proxy swaps for the real credential. Without\n`networkAccess`, a `custom` tool has no network egress. A `flow` tool returns the flow's terminal step output; set\n`config.outputVariable` to return one shaped variable instead. Long-running work is not\na `flow` tool either: a `subagent` tool with `config.execution.mode: \"detached\"` returns\na run handle, and `run_flow` with `async: true` returns an execution id (see\n`tool-design-execution`).\n\n`create_tool` also accepts `graphql`, but no executor runs that type: a call to a\n`graphql` tool fails with an unsupported-type error. Send a GraphQL query from an\n`external` tool with `method: \"POST\"` and the query in the `body` template.\n\nThe MCP `create_tool` accepts `tool_type` in `flow`, `custom`, `external`, `graphql`,\n`mcp`, `local`, with `name`, `description`, `parameters_schema` (JSON Schema), and\n`config`. `name` is at most 100 characters and `description` at most 500 on create, so\nkeep the description tight and put detail in parameter descriptions and error text. The\nREST API and SDKs (`POST \u002Fv1\u002Ftools`, spelled `toolType` and `parametersSchema`) accept\nthe same set plus `subagent`. To delegate to agents over MCP, pick the route by need:\n\n- A fixed saved agent as a tool: wrap it in a flow with an `execute-agent` step and\n  register that flow with `tool_type: \"flow\"`. Agent ids are not valid tool ids.\n- Delegation the agent decides at run time: set the agent's\n  `config.tools.subagentConfig`, which gives it a `spawn_subagent` tool.\n\n`builtin` tools are never created; attach them by id through `config.tools.toolIds`.\nIterate with `update_tool` and `get_tool`; read\n`get_platform_documentation(topic=\"external-tools\")` and\n`get_platform_documentation(topic=\"limits\")` before designing.\n\n### What the platform enforces for you\n\n- Credentials: `{{secret:KEY}}` references resolve server-side and are the only\n  credential contract. Never collect secret values in chat; hand the user the intake\n  URL from `get_secret_intake_manifest`.\n- Context injection: on runtime tools (an agent's `tools.runtimeTools` or\n  `\u002Fv1\u002Fdispatch`), `hiddenParameterNames` strips parameters from the model-facing schema\n  and fills them from execution variables. List `_endUser` or `_tenant` there to anchor\n  the verified caller identity so the model never supplies it. Saved tools created with\n  `create_tool` do not take this field. Names under `_internal` are rejected; use\n  `{{secret:KEY}}` for credentials.\n- Human-owned inputs: `config.elicit` on an `external` or `custom` tool pauses the run\n  for a form before approval and dispatch. Use it instead of letting the model invent\n  an argument that belongs to the person.\n- Permission gate: `config.tools.approval.require` pauses the run for a human on the\n  listed tools; the agent's `_approvalReason` is display-only, never a control signal.\n  `approval.timeout` (default 5 min), `approval.requestReason`, and `approval.choices`\n  (`alwaysAllow`, `alwaysDeny`) shape the prompt. Approval covers only calls a model\n  chooses in an agent or prompt step. A flow `tool-call` step always runs, unattended.\n- Idempotency: set `idempotent: true` only on runtime tools that are safe to run twice,\n  such as reads or writes keyed by an idempotency key. When a turn is interrupted\n  mid-call, Runtype re-runs only those; any other call returns an \"effects unknown,\n  verify before retrying\" error instead of running twice. For MCP tools, declare\n  `readOnlyHint` or `idempotentHint` on the server; with neither, the tool is treated\n  as unsafe to re-run.\n- Files and media: a binary media part of 4 KB or more in a tool result is stored and\n  handed to the model as a `runtype-asset:\u002F\u002F` handle. Declare a parameter as\n  `{ \"type\": \"string\", \"contentEncoding\": \"base64\" }` to receive those bytes; Runtype\n  substitutes them before dispatch, so the model never re-emits the payload. This is\n  the Resource Reference pattern on Runtype.\n- Audit: every tool call is traced on the run and visible in Runs, Logs, and\n  `trace_execution`.\n- Timeouts: a runtime custom tool is limited to 30 s. A saved custom tool takes its own\n  `timeout` in milliseconds, up to 300 s in the tool editor. MCP tools default to 30 s\n  and can run up to 300 s only in background runs. A subagent tool defaults to 5 min.\n  Longer work belongs in an async flow run or a detached subagent.\n- Tool set controls: `maxToolCalls` bounds tool-call loops, and `toolCallStrategy` is\n  `auto`, `required`, or `none`. Do not set `perToolLimits`: it is retired, and an agent\n  that carries it is rejected. Bound the loop with `loopConfig.maxTurns` or\n  `loopConfig.maxCost`, or enforce a per-tool budget inside the tool. `codeModeConfig`\n  gives the agent a `code_mode` tool that chains a subset of its tools in sandboxed\n  code, an alternative to hand-built bundle and batch tools.\n- Tool count: no cap; a request's serialized `runtimeTools` may total 1 MB. A provider\n  can still refuse a long list (`TOOL_COUNT_REFUSED_BY_PROVIDER`). Tool search is on by\n  default for multi-turn agents at 20+ tools (inline tools defer behind `tool_search`,\n  and `tools.toolSearch.enabled: false` opts out); use it for large tool sets. Single-turn agents send every tool on every\n  request, so keep sets small or split them across agents.\n- Save-time checks: `validate_flow` reports several checklist rows as stable codes\n  (see `references\u002Fchecklist.md`, \"Checked for you on Runtype\").\n\n### The test loop\n\n1. Read `validation.warnings` and `validation.recommendations` in the `create_tool` or\n   `update_tool` response. The save succeeds even when they are present, so no error\n   tells you to look.\n2. `execute_tool` with the inputs an agent will plausibly send, including wrong ones,\n   and read the result and error as the model would.\n3. Wire it into an agent and run a realistic prompt with `execute_agent` or `dispatch`.\n4. When a real run misuses the tool, pin it: `add_eval_case_from_execution`, then\n   `run_eval_suite` after every description or schema change. Read\n   `get_platform_documentation(topic=\"evals\")` for tool-use eval layers.\n\n## Measure it in a simulation\n\nA review produces findings; a simulation measures what fixing them is worth before\nanyone changes the server. Runtype simulations record what an MCP server answers, then\nserve a redesigned surface from those recordings to the same simulated users, so the\ncomparison is paired and the server receives no designed call. Simulations run on\nRuntype staging and preview deployments only; the production API answers 404\n`SIMULATIONS_DISABLED` and its MCP server does not list these tools.\n\n1. **Record.** Run a simulation against the server as published (`run_simulation`),\n   with recording on for the target (`update_simulation_target` with\n   `recording: { enabled: true, retention_days: 90 }`). For a tool no run has called,\n   upload real answers with `upload_simulation_tool_exchanges` or\n   `runtype simulations exchanges upload \u003Ctarget> \u003Cfile>`.\n2. **Read the evidence.** `get_simulation_tool_profile` returns the observed output\n   schema, the error catalog with the share the agent recovered from, and\n   `shapeFindings` that cite checklist rows 11, 13, 19, 20, 21 and 26, each with a\n   `suggestedOp` when one maps. `get_simulation_report` carries the trace signals:\n   confused pairs, argument errors by field, never-discovered tools.\n3. **Write the design as operations.** `propose_simulation_variants` with\n   `proposer: \"model\"` stages at most two designs that cite a checklist row per\n   operation, or write them yourself on the variant's `tool_surface` change and save\n   with `update_simulation_variant` and `validate: true`, which runs every operation on\n   recorded answers as a run would.\n4. **Preview.** `preview_simulation_variant` shows one recorded answer as published and\n   as designed. Fix an operation here, not after a paid run.\n5. **Run it paired.** Give the baseline `tool_policy: { \"*\": \"recorded\" }` and the\n   design `{ \"*\": \"simulated\" }`, then `run_simulation`. Pass\n   `replay: { synthesize: false }` on the design when the verdict must rest on\n   recordings and deterministic operations only.\n6. **Decide on the investment card.** The report's `investment` section reads\n   Recommended only when no deciding conversation rested on a synthesized answer and\n   the synthesized share is under the threshold (25% by default); otherwise Indicative,\n   with the reason. Record the missing calls live or add a deterministic operation,\n   then rerun.\n7. **Hand it over.** `export_simulation_design_brief` returns the Markdown brief:\n   before and after definitions, response mappings, error envelopes, each operation's\n   checklist row and measured effect. Later live runs mark each operation adopted or\n   not; `list_simulation_design_briefs` shows it beside the baseline trend.\n\nThe checklist rows map to operations as follows:\n\n| Checklist rows     | Operation                                | What the design changes                                  |\n| ------------------ | ---------------------------------------- | -------------------------------------------------------- |\n| 11, 12, 14, 18, 19 | `shape`                                  | Flattens, renames, drops or truncates fields of a result |\n| 13                 | `paginate`                               | One cursor style with `items`, `cursor` and `hasMore`    |\n| 20, 21, 22         | `error_design`                           | Error class, reason, recovery steps naming the next tool |\n| 6, 23              | `accept_identifier`                      | Accepts a name and resolves it to an id through a lookup |\n| 10, 34, 38, 39     | `add_tool`                               | A bundle, batch, discovery or identity tool              |\n| 1, 3, 4, 5         | `rename`, `describe`, `schema`, `preset` | Names, descriptions and argument schemas                 |\n\nDeveloper guide: \"Design a better tool surface without deploying it\"\n(`\u002Fdeveloper-guides\u002Fguides\u002Fdesign-tool-surface-in-simulation` on the Runtype docs).\n",{"name":5,"description":7,"argument-hint":57,"user-invocable":58},"[tool or tool set to design or review]",true,"main","2b63f856ce19c2a797929cacabd9e0fc936812fa","plugins\u002Fruntypelabs\u002Fskills\u002Fskills\u002Ftool-design",491,"https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins","https:\u002F\u002Fhol.org\u002Fplugins\u002Fbest-codex-plugins","https:\u002F\u002Fgithub.com\u002Fhashgraph-online","https:\u002F\u002Fhol.org","Open-source standards and developer tools for interoperable AI agents: discovery, identity, communication, payments, privacy and security.","2026-11-14 14:06:13",{"source":8,"skillName":5,"commands":70,"prompt":80,"zipAvailable":58},[71,74,77],{"tool":72,"command":73},"npx","npx skills add hashgraph-online\u002Fawesome-codex-plugins --skill tool-design",{"tool":75,"command":76},"bunx","bunx skills add hashgraph-online\u002Fawesome-codex-plugins --skill tool-design",{"tool":78,"command":79},"pnpm","pnpm dlx skills add hashgraph-online\u002Fawesome-codex-plugins --skill tool-design","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fruntypelabs\u002Fskills\u002Fskills\u002Ftool-design\u002FSKILL.md",[82,88,92],{"path":83,"resourceType":84,"resourceTypeDesc":85,"sizeBytes":86,"sourceHtmlUrl":87},"agents\u002Fopenai.yaml","REFERENCE","参考文档",263,"https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fruntypelabs\u002Fskills\u002Fskills\u002Ftool-design\u002Fagents\u002Fopenai.yaml",{"path":89,"resourceType":84,"resourceTypeDesc":85,"sizeBytes":90,"sourceHtmlUrl":91},"references\u002Fchecklist.md",9825,"https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fruntypelabs\u002Fskills\u002Fskills\u002Ftool-design\u002Freferences\u002Fchecklist.md",{"path":93,"resourceType":84,"resourceTypeDesc":85,"sizeBytes":94,"sourceHtmlUrl":95},"references\u002Fpattern-index.md",7525,"https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fruntypelabs\u002Fskills\u002Fskills\u002Ftool-design\u002Freferences\u002Fpattern-index.md",[97,107,115,123,131,139],{"skillNo":98,"name":99,"nameZh":6,"description":100,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":101,"licenseFileUrl":102,"sourceHtmlUrl":103,"categories":104,"keywords":105,"publishedAt":106},"01M7DV332YQMGD8WTRJ9DZQXTB","worktable-review-with-annotations","Create, inspect, reply to, update, or resolve situated Worktable annotations. Use when feedback belongs to a Doc section, block, text range, or HTML Doc, or when the user asks to address existing review feedback and coordinate a requested artifact edit.","MIT","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fworktable\u002Fworktable-plugin\u002Fskills\u002Fworktable-review-with-annotations\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fworktable\u002Fworktable-plugin\u002Fskills\u002Fworktable-review-with-annotations\u002FSKILL.md",[],[],"2026-11-15 14:19:17",{"skillNo":108,"name":109,"nameZh":6,"description":110,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":101,"licenseFileUrl":111,"sourceHtmlUrl":112,"categories":113,"keywords":114,"publishedAt":106},"01M7DV2YGHCZVBEB1AHYB6CGHE","worktable-find-and-synthesize-context","Find, assess, and synthesize context from Worktable Docs and Records. Use when the user asks what a workspace contains, wants workspace-backed research, needs current facts reconciled across artifacts, or requests a cited synthesis without changing workspace state.","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fworktable\u002Fworktable-plugin\u002Fskills\u002Fworktable-find-and-synthesize-context\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fworktable\u002Fworktable-plugin\u002Fskills\u002Fworktable-find-and-synthesize-context\u002FSKILL.md",[],[],{"skillNo":116,"name":117,"nameZh":6,"description":118,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":101,"licenseFileUrl":119,"sourceHtmlUrl":120,"categories":121,"keywords":122,"publishedAt":106},"01M7DV2TQN1H11ME2SAF9MXN7V","worktable-create-or-update-docs","Create, edit, rename, or maintain narrative Worktable Docs. Use for plans, decisions, briefs, notes, research syntheses, and other durable prose when the user requests a new artifact or a safe update to an existing one.","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fworktable\u002Fworktable-plugin\u002Fskills\u002Fworktable-create-or-update-docs\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fworktable\u002Fworktable-plugin\u002Fskills\u002Fworktable-create-or-update-docs\u002FSKILL.md",[],[],{"skillNo":124,"name":125,"nameZh":6,"description":126,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":101,"licenseFileUrl":127,"sourceHtmlUrl":128,"categories":129,"keywords":130,"publishedAt":106},"01M7DV2NE452NEA8TXATKSNAJH","worktable-create-or-manage-records","Organize repeated structured information as durable Worktable Records. Use for research datasets, inventories, directories, pipelines, trackers, and other collections whose items need identity, fields, filtering, links, validation, or individual updates.","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fworktable\u002Fworktable-plugin\u002Fskills\u002Fworktable-create-or-manage-records\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fworktable\u002Fworktable-plugin\u002Fskills\u002Fworktable-create-or-manage-records\u002FSKILL.md",[],[],{"skillNo":132,"name":133,"nameZh":6,"description":134,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":101,"licenseFileUrl":135,"sourceHtmlUrl":136,"categories":137,"keywords":138,"publishedAt":106},"01M7DV2HENRBR2KSCVM064WH0Y","worktable-create-or-manage-interactive-html","Create or improve durable visual and interactive artifacts in Worktable. Use for dashboards, trackers, calculators, mini apps, slide presentations, and other requests that benefit from a polished HTML Doc.","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fworktable\u002Fworktable-plugin\u002Fskills\u002Fworktable-create-or-manage-interactive-html\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fworktable\u002Fworktable-plugin\u002Fskills\u002Fworktable-create-or-manage-interactive-html\u002FSKILL.md",[],[],{"skillNo":140,"name":141,"nameZh":6,"description":142,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":101,"licenseFileUrl":143,"sourceHtmlUrl":144,"categories":145,"keywords":146,"publishedAt":106},"01M7DV2CADR5R7RQFFYPNAGR9Y","worktable-collaborate-threads","Read, answer, and hand off messages through durable Worktable threads with users or other authenticated participants. Use when the user asks to check addressed messages, reply to a participant, continue a thread, request another agent's help, wait briefly for a response, or watch for comments and messages sent to the agent.","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fworktable\u002Fworktable-plugin\u002Fskills\u002Fworktable-collaborate-threads\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fhashgraph-online\u002Fawesome-codex-plugins\u002Fblob\u002Fmain\u002Fplugins\u002Fworktable\u002Fworktable-plugin\u002Fskills\u002Fworktable-collaborate-threads\u002FSKILL.md",[],[]]