Skip to content
Skills Library
AI & agents · Planning

task-decomposition

/task-decomposition

Break a user's goal into a small DAG of sub-tasks for the JarvisVR specialist team, then emit it as an orchestration.plan. Use whenever a request needs more than one capability or agent, e.g. "what's on my desk and the weather in Tokyo, and start a 5-minute timer", multi-step errands, or any goal mixing perception, research, productivity, smart-home, navigation, media, comms, or stage work. Triggers: plan, decompose, break down, multi-step, "and also", "while you're at it", several things at once.

Repository
jarvisvr ↗
Licence
MIT
Last repository change
10.06.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 10.06.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Break a user's goal into a small DAG of sub-tasks for the JarvisVR specialist team, then emit it as an orchestration.plan. Use whenever a request needs more than one capability or agent, e.g. "what's on my desk and the weather in Tokyo, and start a 5-minute timer", multi-step errands, or any goal mixing perception, research, productivity, smart-home, navigation, media, comms, or stage work. Triggers: plan, decompose, break down, multi-step, "and also", "while you're at it", several things at once.

Triggers from the description

whatand alsowhile you
Original author description

Break a user's goal into a small DAG of sub-tasks for the JarvisVR specialist team, then emit it as an orchestration.plan. Use whenever a request needs more than one capability or agent, e.g. "what's on my desk and the weather in Tokyo, and start a 5-minute timer", multi-step errands, or any goal mixing perception, research, productivity, smart-home, navigation, media, comms, or stage work. Triggers: plan, decompose, break down, multi-step, "and also", "while you're at it", several things at once.

How it works

  1. When to use
  2. Steps
  3. Output: orchestration.plan (protocol §9.2)
  4. Dependency patterns
  5. Edge cases
  6. Hand-off
Original SKILL.md headings · 86 lines, 574 words
SKILL.md preview
---
name: task-decomposition
description: >-
  Break a user's goal into a small DAG of sub-tasks for the JarvisVR specialist
  team, then emit it as an orchestration.plan. Use whenever a request needs more
  than one capability or agent, e.g. "what's on my desk and the weather in
  Tokyo, and start a 5-minute timer", multi-step errands, or any goal mixing
  perception, research, productivity, smart-home, navigation, media, comms, or
  stage work. Triggers: plan, decompose, break down, multi-step, "and also",
  "while you're at it", several things at once.
license: MIT
compatibility: >-
  Requires the JarvisVR agent-backend running the Jarvis orchestrator (protocol
  v1.2 orchestration.* messages, see docs/PROTOCOL.md §9).
metadata:
  agent: jarvis
  category: orchestration
  version: "1.0"
  author: jarvisvr
---
# Task Decomposition

You are **Jarvis**, the L0 orchestrator. This skill turns one user goal into a
small, dependency-aware plan that the specialist roster can execute. You never do
domain work here — you only plan and publish the plan as `orchestration.plan`.

## When to use

- Use when the goal needs **two or more** specialists, or one specialist across
  **sequential** steps with dependencies.
- Skip (single dispatch) when the goal is one obvious sub-task for one agent —
  hand straight to `agent-routing` instead.

## Steps

1. **Normalize the goal.** Strip filler, keep intent + entities (cities, device
   names, durations, people). If it is ambiguous *and* blocking, stop and run
   `clarify-intent` first.
2. **Enumerate atomic sub-tasks.** One verb + one object each ("get Tokyo
   weather", "start 5-minute timer", "identify object on desk").
3. **Assign a role** to each sub-task by matching it to the roster in
   `docs/ORCHESTRATION.md §3` (do the actual matching with `agent-routing`).
4. **Wire dependencies.** Mark which sub-tasks are independent (run in parallel)
   vs. which consume another's output (sequence them). Keep the graph shallow.
5. **Allocate agent ids.** `jarvis` is L0; L1 agents are `a1, a2, …`; sub-agents
   use dotted ids (`a1.1`). Keep depth ≤ 3.
6. **Emit `orchestration.plan`** once, up front, then let the dispatcher drive
   `orchestration.agent_status` per agent.

## Output: `orchestration.plan` (protocol §9.2)

For *"what's this on my desk, and the weather in Tokyo? Start a 5-minute timer."*

```json
{
  "plan_id": "uuid-v4",
  "goal": "identify the desk object, show Tokyo weather, start a 5-minute timer",
  "agents": [
    { "agent_id": "jarvis", "role": "orchestrator", "name": "Jarvis", "parent": null, "level": 0 },
    { "agent_id": "a1", "role": "perception-agent", "name": "Perception", "parent": "jarvis",
      "level": 1, "subtask": "identify the object on the desk", "skills": ["identify-object"] },
    { "agent_id": "a2", "role": "research-agent", "name": "Research", "parent": "jarvis",
      "level": 1, "subtask": "get current weather for Tokyo", "skills": ["web-research"] },
    { "agent_id": "a3", "role": "productivity-agent", "name": "Productivity", "parent": "jarvis",
      "level": 1, "subtask": "start a 5-minute timer", "skills": ["manage-timers"] },
    { "agent_id": "a4", "role": "stage-agent", "name": "Stage", "parent": "jarvis",
      "level": 1, "subtask": "lay the results out comfortably", "skills": ["compose-workspace"] }
  ],
  "edges": [
    { "from": "jarvis", "to": "a1" }, { "from": "jarvis", "to": "a2" },
    { "from": "jarvis", "to": "a3" }, { "from": "a1", "to": "a4" },
    { "from": "a2", "to": "a4" }, { "from": "a3", "to": "a4" }
  ]
}
```

`a1`–`a3` are independent and run **in parallel**; `a4` (stage) depends on all
three so it sequences **last**. Emit `agent.thinking{stage:"planning"}` before
the plan.

## Dependency patterns

- **Fan-out / parallel:** independent reads (weather + identify + timer).
- **Pipeline:** `research-agent` → `summarize-source` → `stage-agent present-data`.
- **Gather/synthesize:** always route the final compositing to one
  `stage-agent` node so holograms don't collide (see `result-synthesis`).

## Edge cases

- **Single capability** → don't emit a plan; dispatch one agent directly.
- **Unknown / unsupported sub-task** → drop it from the plan and note it for the
  spoken summary; never invent a role that isn't in the roster.
- **Destructive or gated actions** (unlock door, spend money) → keep them as
  their own node so consent can gate that step (perception/tool actions stay
  user-gated per v1.1).
- **Too many sub-tasks (>6)** → group related ones under one specialist subtask
  rather than spawning a wide, noisy graph.
- **Cyclic dependency** → you mis-modeled it; collapse the cycle into a single
  sequential node.

## Hand-off

Pass each `{agent_id, role, subtask}` to the dispatcher; per-step routing detail
lives in `agent-routing`, and the final spoken/visual merge lives in
`result-synthesis`.

Versions

RepositoryScoreLicence
This page · sumitaich1998/jarvisvr100MIT
aws-solutions/konductor100Apache-2.0
rohitg00/skillkit100Apache-2.0

Database snapshot: 13.11.2026 · package version eff78825532f (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100pipeline
    Design and execute a custom multi-agent pipeline for any goal. Analyzes the goal, selects appropriate specialist agents, designs a DAG of steps with dependencies, and executes them via factory CLI with gate decisions between steps. Use when the user says 'run a pipeline for X',…
  • 100agent-orchestrator
    Turn a multi-step goal that is too big for one prompt into an orchestration plan: sub-tasks, which can run in parallel, the handoff format between steps, checkpoints for human review, failure handling, and a ready-to-use brief for each sub-agent. Use when a professional,…
  • 100workflow-orchestration
    Coordinate structured thinking and multi-agent parallel execution for complex tasks. Use when tackling multi-step projects, planning parallel work, breaking down complex problems, coordinating specialist tasks, facing architectural decisions, or when user mentions "workflow",…
  • 95team-dispatch
    Use when a request requires multi-agent workflow orchestration (task decomposition + dependency/DAG + parallel execution), needs durable task tracking across context compaction, or needs retries/fallbacks and completion notifications.
  • 100operad-task-decomposition
    Use operads to formally model hierarchical task decomposition for multi-agent systems. Covers typed composition, wiring diagrams, and the relationship to DAG-of-agents architectures. Use when decomposing complex tasks for multi-agent execution, designing DAG topologies,…
  • 100orchestrate
    Orchestrate multi-task execution plans using Claude's native Agent tool (DAG-based, no external engine). Use when: executing a plan.json file with parallel/sequential task dependencies. Not for: producing the plan in the first place — use /plan; single tasks with no dependencies…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.