[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M760MZ5CFSAX4FYMEXZJBGM2":3,"skill-same:01M760MZ5CFSAX4FYMEXZJBGM2":47},{"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":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":6,"ownerHtmlUrl":29,"ownerBlogUrl":30,"ownerDescription":31,"updatedAt":32,"install":33,"resources":46},"01M760MZ5CFSAX4FYMEXZJBGM2","workflow-patterns",null,"Load when one Workflow must run different nodes in its branches at the same time (a different prompt or model for each branch), or loops back to a state (a polling loop). Named branches, the router pattern, examples that compile.","microsoft\u002FPilotSwarm","microsoft","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F6154722?v=4","01M698VYDXZ6JW5WH3CRV650R8","Microsoft","01M69A6RNK492A5JSNBTXANKX5",16,"MIT","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FPilotSwarm\u002Fblob\u002Fmain\u002Fpackages\u002Fsdk\u002Fplugins\u002Fworkflow\u002Fskills\u002Fworkflow-patterns\u002FSKILL.md",[],[],"2026-11-12 13:55:43",false,"---\nname: workflow-patterns\ndescription: Load when one Workflow must run different nodes in its branches at the same time (a different prompt or model for each branch), or loops back to a state (a polling loop). Named branches, the router pattern, examples that compile.\n---\n\n# Workflow patterns\n\nCall `load_skill` with name `workflow-authoring` first. This skill adds three patterns to it.\n\n## Different work in each branch at once: named branches\n\nWhen different branches must run different nodes at the same time (a\ndifferent prompt, or a different model for each), write ONE parallel state\nwith named `branches`. Do not split it into several Workflows.\n\n- Each branch is its own graph: `initial`, `states` and an optional `input`\n  template (else the value that arrived).\n- Its routes stay inside it. Each end is a branch end: `succeeded` is\n  success. A branch has no `catchAll`; an error it does not route ends it.\n- State ids are unique across the Workflow, so each agent node has its own\n  `agent_models` entry at start.\n- `concurrency` defaults to the number of branches: all run at once. Above\n  16 branches, set it (at most 16).\n- `joined` gives `{ \u003Cname>: output }`. With `join: { first: k }` (k at most\n  the branches) it holds the winners only; a `blocked` or `timed_out` report\n  lists every branch with its `name`.\n- `${branch.name}` (a script's `context.branch.name`) names the branch.\n- Give the parallel state `timeoutSeconds` and a `timed_out` route when a\n  branch runs an agent: without one, the join waits as long as the slowest\n  branch (the compiler warns `WORKFLOW_BRANCH_UNBOUNDED`).\n\n```yaml\n# example: two-views\napiVersion: pilotswarm.dev\u002Fv1\nkind: Workflow\nmetadata: { name: two-views, version: \"1.0.0\" }\ndescription: Summarizes one text twice at once and joins both by name.\ninputs:\n  schema:\n    type: object\n    additionalProperties: false\n    required: [text]\n    properties:\n      text: { type: string, minLength: 1 }\ninitial: views\ninitialInput: { text: \"${inputs.text}\" }\nstates:\n  views:\n    type: parallel\n    timeoutSeconds: 2400 # bounds the join: a branch runs an agent\n    branches:\n      quick:\n        initial: quick_summary\n        states:\n          quick_summary: # its own state id: its own agent_models entry\n            type: agent\n            invoke: { prompt: \"Summarize the text in your input in one sentence.\" }\n            outcomes: [done]\n            timeoutSeconds: 600\n            transition: { next: { done: quick_done, failure: quick_failed } }\n          quick_done: { type: terminal, outcome: succeeded, output: \"${input}\" }\n          quick_failed: { type: terminal, outcome: failed, output: \"${runtime.error}\" }\n      careful:\n        initial: careful_summary\n        states:\n          careful_summary:\n            type: agent\n            invoke: { prompt: \"Read the text in your input closely and summarize it in one paragraph. Keep every number and name.\" }\n            outcomes: [done]\n            timeoutSeconds: 1800\n            transition: { next: { done: careful_done, failure: careful_failed } }\n          careful_done: { type: terminal, outcome: succeeded, output: \"${input}\" }\n          careful_failed: { type: terminal, outcome: failed, output: \"${runtime.error}\" }\n    transition:\n      next: { joined: done, blocked: failed, timed_out: failed, failure: failed }\n  done: { type: terminal, outcome: succeeded, output: \"${input}\" } # { quick: ..., careful: ... }\n  failed: { type: terminal, outcome: failed, output: \"${input}\" }\n```\n\n## When the branches are data: the router pattern\n\nThe older form, for branches that come from a list (each item names its\nlane): a parallel state over the list, with a router script first in the\nbody that sets its outcome to the lane and routes to that lane's node.\n`concurrency` is the number of lanes and `join` is `all`. Every lane ends at\none item end whose output names the lane; the results arrive in the list's\norder. The router decides nothing: it reads a lane written in the list, so it\nis mechanical work, which scripts may do. Judgment still goes to an agent\nnode. There is no switch node type.\n\n```yaml\n# example: two-lane-summary\napiVersion: pilotswarm.dev\u002Fv1\nkind: Workflow\nmetadata: { name: two-lane-summary, version: \"1.0.0\" }\ndescription: Summarizes one text twice at once, one lane per item.\ninputs:\n  schema:\n    type: object\n    additionalProperties: false\n    required: [text]\n    properties:\n      text: { type: string, minLength: 1 }\ninitial: lanes\nstates:\n  lanes:\n    type: parallel\n    forEach: [{ lane: quick }, { lane: careful }] # one item per lane\n    concurrency: 2 # every lane at once\n    join: all\n    body:\n      initial: route\n      states:\n        route:\n          type: script\n          timeoutSeconds: 30\n          outcomes: [quick, careful]\n          source: |\n            await setResult(context.branch.item.lane, { lane: context.branch.item.lane, text: context.inputs.text });\n          transition:\n            next: { quick: quick_summary, careful: careful_summary, failure: lane_failed }\n        quick_summary:\n          type: agent\n          invoke: { prompt: \"Summarize the text in your input in one sentence.\" }\n          outcomes: [done]\n          timeoutSeconds: 600\n          transition: { next: { done: lane_done, failure: lane_failed } }\n        careful_summary:\n          type: agent\n          invoke: { prompt: \"Read the text in your input closely and summarize it in one paragraph. Keep every number and name.\" }\n          outcomes: [done]\n          timeoutSeconds: 1800\n          transition: { next: { done: lane_done, failure: lane_failed } }\n        lane_done:\n          type: terminal\n          outcome: succeeded\n          output: { lane: \"${branch.item.lane}\", summary: \"${input}\" }\n        lane_failed:\n          type: terminal\n          outcome: failed\n          output: { lane: \"${branch.item.lane}\", error: \"${runtime.error}\" }\n    transition:\n      next: { joined: done, blocked: failed, failure: failed }\n  done: { type: terminal, outcome: succeeded, output: \"${input}\" }\n  failed: { type: terminal, outcome: failed, output: \"${input}\" }\n```\n\n## A polling loop\n\nA route back to a state brings it the previous state's output. Here\n`check_ci`'s closed `inputSchema` refuses `ciState`, so `wait_ci` maps the\noutput back with `input:`; KV is read with a default. `get_ci_state` stands\nfor a tool of your own.\n\n```yaml\n# example: ci-poll\napiVersion: pilotswarm.dev\u002Fv1\nkind: Workflow\nmetadata: { name: ci-poll, version: \"1.0.0\" }\ndescription: Checks CI until it is not pending.\ninitial: check_ci\ninitialInput: { checks: 0 }\nstates:\n  check_ci:\n    type: script\n    inputSchema: { type: object, additionalProperties: false, required: [checks], properties: { checks: { type: integer } } }\n    outcomes: [pending, done]\n    source: |\n      const checks = context.input.checks + 1;\n      const { state } = await callTool(\"get_ci_state\", {});\n      const most = context.kv.maxChecks ?? 30; \u002F\u002F KV may be unset\n      await setResult(state === \"pending\" && checks \u003C most ? \"pending\" : \"done\", { checks, ciState: state });\n    transition: { next: { pending: wait_ci, done: done, failure: failed } }\n  wait_ci:\n    type: wait\n    seconds: \"${kv.pollSeconds ?? 60}\"\n    input: { checks: \"${input.checks}\" } # what check_ci takes, not ciState\n    transition: { next: { elapsed: check_ci, failure: failed } }\n  done: { type: terminal, outcome: succeeded, output: \"${input}\" }\n  failed: { type: terminal, outcome: failed, output: \"${runtime.error}\" }\n```\n\n## Testing these patterns\n\nA test's fixtures (`workflow-tools`) answer by state id, so each branch's\nagent node has its own: `{ operation: agent, state: quick_summary, ... }`\nand `{ operation: agent, state: careful_summary, ... }`. A For each body's\nnode runs once per item; one fixture answers every item, and `visit`\ncounts per item. In a loop, `visit: n` answers the n-th round of a state;\na fixture without `visit` answers the other rounds. A receive gets its\nmessage from `{ operation: receive, state: \u003Cid>, visit?, response: { kind:\nsuccess, value: \u003Cmessage> } }`. The report's `path` names each step's\n`branch` (its name, or `item N`) and `enteredBy`.\n","# Workflow patterns\n\nCall `load_skill` with name `workflow-authoring` first. This skill adds three patterns to it.\n\n## Different work in each branch at once: named branches\n\nWhen different branches must run different nodes at the same time (a\ndifferent prompt, or a different model for each), write ONE parallel state\nwith named `branches`. Do not split it into several Workflows.\n\n- Each branch is its own graph: `initial`, `states` and an optional `input`\n  template (else the value that arrived).\n- Its routes stay inside it. Each end is a branch end: `succeeded` is\n  success. A branch has no `catchAll`; an error it does not route ends it.\n- State ids are unique across the Workflow, so each agent node has its own\n  `agent_models` entry at start.\n- `concurrency` defaults to the number of branches: all run at once. Above\n  16 branches, set it (at most 16).\n- `joined` gives `{ \u003Cname>: output }`. With `join: { first: k }` (k at most\n  the branches) it holds the winners only; a `blocked` or `timed_out` report\n  lists every branch with its `name`.\n- `${branch.name}` (a script's `context.branch.name`) names the branch.\n- Give the parallel state `timeoutSeconds` and a `timed_out` route when a\n  branch runs an agent: without one, the join waits as long as the slowest\n  branch (the compiler warns `WORKFLOW_BRANCH_UNBOUNDED`).\n\n```yaml\n# example: two-views\napiVersion: pilotswarm.dev\u002Fv1\nkind: Workflow\nmetadata: { name: two-views, version: \"1.0.0\" }\ndescription: Summarizes one text twice at once and joins both by name.\ninputs:\n  schema:\n    type: object\n    additionalProperties: false\n    required: [text]\n    properties:\n      text: { type: string, minLength: 1 }\ninitial: views\ninitialInput: { text: \"${inputs.text}\" }\nstates:\n  views:\n    type: parallel\n    timeoutSeconds: 2400 # bounds the join: a branch runs an agent\n    branches:\n      quick:\n        initial: quick_summary\n        states:\n          quick_summary: # its own state id: its own agent_models entry\n            type: agent\n            invoke: { prompt: \"Summarize the text in your input in one sentence.\" }\n            outcomes: [done]\n            timeoutSeconds: 600\n            transition: { next: { done: quick_done, failure: quick_failed } }\n          quick_done: { type: terminal, outcome: succeeded, output: \"${input}\" }\n          quick_failed: { type: terminal, outcome: failed, output: \"${runtime.error}\" }\n      careful:\n        initial: careful_summary\n        states:\n          careful_summary:\n            type: agent\n            invoke: { prompt: \"Read the text in your input closely and summarize it in one paragraph. Keep every number and name.\" }\n            outcomes: [done]\n            timeoutSeconds: 1800\n            transition: { next: { done: careful_done, failure: careful_failed } }\n          careful_done: { type: terminal, outcome: succeeded, output: \"${input}\" }\n          careful_failed: { type: terminal, outcome: failed, output: \"${runtime.error}\" }\n    transition:\n      next: { joined: done, blocked: failed, timed_out: failed, failure: failed }\n  done: { type: terminal, outcome: succeeded, output: \"${input}\" } # { quick: ..., careful: ... }\n  failed: { type: terminal, outcome: failed, output: \"${input}\" }\n```\n\n## When the branches are data: the router pattern\n\nThe older form, for branches that come from a list (each item names its\nlane): a parallel state over the list, with a router script first in the\nbody that sets its outcome to the lane and routes to that lane's node.\n`concurrency` is the number of lanes and `join` is `all`. Every lane ends at\none item end whose output names the lane; the results arrive in the list's\norder. The router decides nothing: it reads a lane written in the list, so it\nis mechanical work, which scripts may do. Judgment still goes to an agent\nnode. There is no switch node type.\n\n```yaml\n# example: two-lane-summary\napiVersion: pilotswarm.dev\u002Fv1\nkind: Workflow\nmetadata: { name: two-lane-summary, version: \"1.0.0\" }\ndescription: Summarizes one text twice at once, one lane per item.\ninputs:\n  schema:\n    type: object\n    additionalProperties: false\n    required: [text]\n    properties:\n      text: { type: string, minLength: 1 }\ninitial: lanes\nstates:\n  lanes:\n    type: parallel\n    forEach: [{ lane: quick }, { lane: careful }] # one item per lane\n    concurrency: 2 # every lane at once\n    join: all\n    body:\n      initial: route\n      states:\n        route:\n          type: script\n          timeoutSeconds: 30\n          outcomes: [quick, careful]\n          source: |\n            await setResult(context.branch.item.lane, { lane: context.branch.item.lane, text: context.inputs.text });\n          transition:\n            next: { quick: quick_summary, careful: careful_summary, failure: lane_failed }\n        quick_summary:\n          type: agent\n          invoke: { prompt: \"Summarize the text in your input in one sentence.\" }\n          outcomes: [done]\n          timeoutSeconds: 600\n          transition: { next: { done: lane_done, failure: lane_failed } }\n        careful_summary:\n          type: agent\n          invoke: { prompt: \"Read the text in your input closely and summarize it in one paragraph. Keep every number and name.\" }\n          outcomes: [done]\n          timeoutSeconds: 1800\n          transition: { next: { done: lane_done, failure: lane_failed } }\n        lane_done:\n          type: terminal\n          outcome: succeeded\n          output: { lane: \"${branch.item.lane}\", summary: \"${input}\" }\n        lane_failed:\n          type: terminal\n          outcome: failed\n          output: { lane: \"${branch.item.lane}\", error: \"${runtime.error}\" }\n    transition:\n      next: { joined: done, blocked: failed, failure: failed }\n  done: { type: terminal, outcome: succeeded, output: \"${input}\" }\n  failed: { type: terminal, outcome: failed, output: \"${input}\" }\n```\n\n## A polling loop\n\nA route back to a state brings it the previous state's output. Here\n`check_ci`'s closed `inputSchema` refuses `ciState`, so `wait_ci` maps the\noutput back with `input:`; KV is read with a default. `get_ci_state` stands\nfor a tool of your own.\n\n```yaml\n# example: ci-poll\napiVersion: pilotswarm.dev\u002Fv1\nkind: Workflow\nmetadata: { name: ci-poll, version: \"1.0.0\" }\ndescription: Checks CI until it is not pending.\ninitial: check_ci\ninitialInput: { checks: 0 }\nstates:\n  check_ci:\n    type: script\n    inputSchema: { type: object, additionalProperties: false, required: [checks], properties: { checks: { type: integer } } }\n    outcomes: [pending, done]\n    source: |\n      const checks = context.input.checks + 1;\n      const { state } = await callTool(\"get_ci_state\", {});\n      const most = context.kv.maxChecks ?? 30; \u002F\u002F KV may be unset\n      await setResult(state === \"pending\" && checks \u003C most ? \"pending\" : \"done\", { checks, ciState: state });\n    transition: { next: { pending: wait_ci, done: done, failure: failed } }\n  wait_ci:\n    type: wait\n    seconds: \"${kv.pollSeconds ?? 60}\"\n    input: { checks: \"${input.checks}\" } # what check_ci takes, not ciState\n    transition: { next: { elapsed: check_ci, failure: failed } }\n  done: { type: terminal, outcome: succeeded, output: \"${input}\" }\n  failed: { type: terminal, outcome: failed, output: \"${runtime.error}\" }\n```\n\n## Testing these patterns\n\nA test's fixtures (`workflow-tools`) answer by state id, so each branch's\nagent node has its own: `{ operation: agent, state: quick_summary, ... }`\nand `{ operation: agent, state: careful_summary, ... }`. A For each body's\nnode runs once per item; one fixture answers every item, and `visit`\ncounts per item. In a loop, `visit: n` answers the n-th round of a state;\na fixture without `visit` answers the other rounds. A receive gets its\nmessage from `{ operation: receive, state: \u003Cid>, visit?, response: { kind:\nsuccess, value: \u003Cmessage> } }`. The report's `path` names each step's\n`branch` (its name, or `item N`) and `enteredBy`.\n",{"name":5,"description":7},"main","7ee6eff4333dba9512363bc67d1fe177d9568636","packages\u002Fsdk\u002Fplugins\u002Fworkflow\u002Fskills\u002Fworkflow-patterns",10,"https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FPilotSwarm","https:\u002F\u002Fgithub.com\u002Fmicrosoft","https:\u002F\u002Fopensource.microsoft.com","Open source projects and samples from Microsoft","2026-11-15 00:36:04",{"source":8,"skillName":5,"commands":34,"prompt":44,"zipAvailable":45},[35,38,41],{"tool":36,"command":37},"npx","npx skills add microsoft\u002FPilotSwarm --skill workflow-patterns",{"tool":39,"command":40},"bunx","bunx skills add microsoft\u002FPilotSwarm --skill workflow-patterns",{"tool":42,"command":43},"pnpm","pnpm dlx skills add microsoft\u002FPilotSwarm --skill workflow-patterns","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FPilotSwarm\u002Fblob\u002Fmain\u002Fpackages\u002Fsdk\u002Fplugins\u002Fworkflow\u002Fskills\u002Fworkflow-patterns\u002FSKILL.md",true,[],[48,55,62,69,76,83],{"skillNo":49,"name":50,"nameZh":6,"description":51,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":52,"categories":53,"keywords":54,"publishedAt":19},"01M760N7TCZBTY635MYZQ8YAB0","workflow-testing","Load before you test a Workflow with mocked effects — the test, test_respond and test_advance operations, fixtures, interception ids, valid answers, the virtual clock, test evidence and what a test run does not prove.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FPilotSwarm\u002Fblob\u002Fmain\u002Fpackages\u002Fsdk\u002Fplugins\u002Fworkflow\u002Ftest-mode-skills\u002Fworkflow-testing\u002FSKILL.md",[],[],{"skillNo":56,"name":57,"nameZh":6,"description":58,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":59,"categories":60,"keywords":61,"publishedAt":19},"01M760N4RKD6BMYPGHD490SNN2","workflow-tools","Every argument of the Workflow tools, testing a revision, package definitions and the refusals you can fix. Load when a Workflow tool's short description is not enough.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FPilotSwarm\u002Fblob\u002Fmain\u002Fpackages\u002Fsdk\u002Fplugins\u002Fworkflow\u002Fskills\u002Fworkflow-tools\u002FSKILL.md",[],[],{"skillNo":63,"name":64,"nameZh":6,"description":65,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":66,"categories":67,"keywords":68,"publishedAt":19},"01M760N1P2VTGVE6C4N5WF3FVR","workflow-reference","Field reference for Workflow YAML (root keys, every state type, bindings, outputs, runtime error codes), what the engine guarantees, and a review fan-out example. For design, call load_skill with name workflow-authoring.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FPilotSwarm\u002Fblob\u002Fmain\u002Fpackages\u002Fsdk\u002Fplugins\u002Fworkflow\u002Fskills\u002Fworkflow-reference\u002FSKILL.md",[],[],{"skillNo":70,"name":71,"nameZh":6,"description":72,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":73,"categories":74,"keywords":75,"publishedAt":19},"01M760MWKBDJFEECRFAF3BAVQ2","workflow-authoring","Load before you create, edit, publish or run a Workflow (pilotswarm.dev\u002Fv1) — choosing states, bounded graphs, bindings, typed contracts, agent and parallel states, the lifecycle and failure diagnosis.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FPilotSwarm\u002Fblob\u002Fmain\u002Fpackages\u002Fsdk\u002Fplugins\u002Fworkflow\u002Fskills\u002Fworkflow-authoring\u002FSKILL.md",[],[],{"skillNo":77,"name":78,"nameZh":6,"description":79,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":80,"categories":81,"keywords":82,"publishedAt":19},"01M760MN4Y9199ARAY85DWD08X","tla-formal-validation","Required for any change to the core orchestrations (the durable session orchestration, session hydration and dehydration, and the Workflow controller and store). Teaches how to model the change in TLA+, update the existing models, run TLC with the repo runner, read the results, turn a counterexample into a fix and a regression test, and record the binding to the code.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FPilotSwarm\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Ftla-formal-validation\u002FSKILL.md",[],[],{"skillNo":84,"name":85,"nameZh":6,"description":86,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":87,"categories":88,"keywords":89,"publishedAt":105},"01M69A9CY8CXHED3AFC8DAT9G0","pilotswarm-three-tier","Reference for adding a Tier 3 worker AKS cluster to a PilotSwarm deployment. Covers provisioning, identity, Dockerfile changes, entrypoint, manifests, and verification.","https:\u002F\u002Fgithub.com\u002Fmicrosoft\u002FPilotSwarm\u002Fblob\u002Fmain\u002Ftemplates\u002Fbuilder-agents\u002Fskills\u002Fpilotswarm-three-tier\u002FSKILL.md",[],[90,91,92,93,94,95,96,97,98,99,100,101,102,103,104],"pilotswarm three tier","three","identity","cluster","for","deployment","dockerfile","worker","manifests","verification","changes","aks","entrypoint","provisioning","reference","2026-11-10 10:12:30"]