What is a work breakdown structure?
A WBS is a hierarchy of everything a project has to deliver, with the whole project at the top and the smallest manageable pieces at the bottom. NASA's Work Breakdown Structure Handbook (NASA/SP-20210023927, November 2021) defines it as "a product-oriented family tree that identifies the hardware, software, services, and all other deliverables required to achieve an end project objective." Its purpose, the handbook says, is "to subdivide the project's work content into manageable segments to facilitate planning and control of cost, schedule, and technical content."
Three terms come up in every WBS:
- Levels. Level 1 is the entire project. Each level below splits its parent into smaller products. NASA projects can split work as deep as they need, but the agency's financial system "currently limits the ability to capture costs to a maximum of seven levels". Most software work needs far fewer.
- Work packages. The lowest pieces that get planned and tracked. NASA's glossary calls a work package "the point at which work is planned, progress is measured, and earned value is computed."
- WBS dictionary. A companion document that "describes the work content of each WBS element", so nobody has to guess what a box on the tree means.
A WBS is about what gets delivered, not when. The handbook describes it as the structure that "serves as the framework for schedule development": you schedule the pieces once you have them.
What makes a good work breakdown structure?
A good WBS follows four rules drawn from the NASA handbook, and each rule matters more when agents pick up the pieces.
| Rule | What the handbook says | Why it matters for agents |
|---|---|---|
| Cover all of the scope, and nothing extra | "Work scope not contained in the project WBS should not be considered part of the project." The WBS "should never contain unauthorized work scope." | An agent works from its card. Work that is not on a card does not get done, and work outside the cards should not get done either. |
| No overlap | A properly structured WBS lets cost, schedule and performance data roll up "without allocation of a single element of work scope to two or more WBS elements." | Two leaves that cover the same file or feature invite two agents to change it at once. Flux does not lock cards, so keeping leaves separate is your protection. |
| Deliverables, not departments or phases | "Design, Engineering, Manufacturing, Phase A ... are not products and typically should not be used for WBS element sub-divisions." | A card called "Testing" has no finish line. "API tests for expired links" does. |
| Completion you can verify | "Completion of an element is both measurable and verifiable based upon specific completion criteria." | This is the check the agent runs before it hands the card back. |
Project managers often call the first rule the 100% rule: the children of every element add up to exactly the scope of their parent, with nothing missing and nothing extra. Keeping elements from overlapping is a companion principle, and it is the second rule here.
Work breakdown structure example: a software feature
A software feature such as invite links for a team app fits in a three-level WBS, written here the way you would put it on a board. The code shows the level: 1 is the project, 1.2 a deliverable, 1.2.1 a leaf.
1 Team invite links 1.1 Invite link API 1.1.1 Create-link endpoint (expiry, role) 1.1.2 Redeem-link endpoint 1.1.3 API tests for expired and reused links 1.2 Invite UI 1.2.1 "Copy invite link" button in team settings 1.2.2 Join page for invited people 1.3 Invite email 1.3.1 Email template with the link 1.4 Docs and release 1.4.1 Help article 1.4.2 Changelog entry and release
Note what is missing: no "Backend" box and no "QA phase". Every element is something you can point to when it is finished. Tests sit next to the thing they test (1.1.3), and release work has its own branch so nobody forgets it. The handbook makes the same point about shared work such as project management: it "must also be reflected" in the WBS, not left off the tree.
How small should a WBS leaf be for an AI agent?
A leaf for an AI agent should be smaller than a classic work package: one outcome the agent can finish and check in a single session. NASA's guidance is that each branch "only needs to be subdivided as far as needed to allow for adequate management, insight, and control." That is the right stopping point for people, who ask questions and fill gaps as they go. An agent working alone often fills a gap with a guess, so its leaf has to carry everything it needs.
The coding-agent vendors describe the same shape. GitHub's guide to getting the best results from Copilot cloud agent says an ideal task includes "a clear description of the problem to be solved or the work required", "complete acceptance criteria on what a good solution looks like" and "directions about which files need to be changed". It lists "complex and broadly scoped tasks" among the ones you may want to keep for yourself. Anthropic's Claude Code best practices offer a size test for deciding whether a task needs a plan first: "If you could describe the diff in one sentence, skip the plan."
Borrow that test as your stopping rule. If you can describe a leaf's change in one sentence, it is ready for an agent. If you can't, split it again, or make the first card a planning card whose output is more cards.
| Point | Work package (people) | Leaf card (agents) |
|---|---|---|
| Sized for | Planning, budgeting and tracking progress | One session's work and one check |
| Described in | The WBS dictionary | The card description |
| Owned by | A team or organization unit | One agent or person at a time |
| Done when | Its completion criteria are verified | The agent's check passes and a person reviews the result |
| If something is unclear | Someone asks | The agent may guess, so the card has to say |
A leaf card needs five things: the outcome, where to work (files, routes or pages), a check, what is out of scope, and the parent it belongs to. Our guide to acceptance criteria for AI agents covers how to write the check.
How does a WBS map onto a kanban board?
The tree becomes parent and child cards, the dictionary becomes card descriptions, and the columns show progress. A WBS has no status of its own. A board does.
| WBS part | On a Flux board |
|---|---|
| Level 1, the project | The board itself, or one parent card for a smaller project |
| Deliverables (levels 2 and 3) | Parent cards, linked to their children |
| Leaves | Child cards that agents and people pick up |
| WBS code (1.2.1) | A prefix in the card title. Flux also gives every card its own short ID. |
| WBS dictionary entry | The card description |
| Progress | The column each card sits in, with a review column before Done |
In Flux you link cards from the Related section of a card, as parent, child or related. Open a parent card and you see its child tickets grouped by column, so you can see how much of a deliverable is finished without opening each leaf. If your team already splits epics into stories, this is the same move. A WBS applies it to the whole scope and insists that the pieces add up.
Can Flux break a card down for you?
Yes. People working in the Flux app can use the Split ticket button on a card. It sends the card's title, description and checklist to an AI model and asks for 2 to 5 smaller sub-tickets that together cover the original "without large overlaps", which is the no-overlap rule written as a prompt. You can edit, delete or add sub-tickets before anything is created. When you confirm, each one becomes a card in the parent's column, linked to it as a child.
Three limits, as of October 2026. Split ticket needs a signed-in browser session, so API keys can't call it. It suggests at most five pieces per split, so a deeper tree takes several rounds, one level at a time. And splits have a daily cap set by your plan (20 a day on the Free plan).
Treat the suggestions as a draft. The model sees only the card, not your codebase, so check every sub-ticket against the four rules above before an agent picks it up.
How do agents create and read the tree?
Agents can create leaf cards over MCP, but linking them needs the REST API. The Flux MCP server has 12 tools, including create_card, but none of them link cards, and get_card does not return a card's parent or children. That has two consequences:
- Copy the parent context into each leaf. A "Parent" section with the parent's title, its ID and what the whole deliverable is for gives an MCP agent everything it needs from
get_cardalone. - Build the links from a script or CI job. Use the REST API with a key that has the Write scope and a member role on the board. Column IDs come from
GET /api/boards/{boardId}.
The request shapes, from the Flux API:
# Generate the key once, and reuse it if you retry this request
KEY=$(uuidgen)
# 1. Create a leaf card (API key with the Write scope)
curl -sS -X POST https://flux.umin.ai/api/cards \
-H "Authorization: Bearer $FLUX_API_KEY" \
-H "Content-Type: application/json" \
-H "X-Idempotency-Key: $KEY" \
-d '{"boardId":"BOARD_UUID","columnId":"BACKLOG_COLUMN_UUID",
"title":"1.1.2 Redeem-link endpoint","description":"## Outcome\n..."}'
# {"card":{"id":"CHILD_UUID", ...}, ...}
# 2. Link it under its parent
curl -sS -X POST https://flux.umin.ai/api/cards/PARENT_UUID/relationships \
-H "Authorization: Bearer $FLUX_API_KEY" \
-H "Content-Type: application/json" \
-d '{"targetCardId":"CHILD_UUID","type":"child"}'
# 201 {"relationship":{...}} (409 if the two cards are already linked)
# 3. Read the parent with its children (Read scope is enough)
curl -sS https://flux.umin.ai/api/cards/PARENT_UUID -H "Authorization: Bearer $FLUX_API_KEY"
# {..., "relatedCardIds":[{"id":"CHILD_UUID","type":"child"}],
# "linkedCards":[{"id":"CHILD_UUID","humanId":"INV-7","title":"...","columnId":"...","assigneeIds":[]}]}
Card creation is recorded in the new card's activity history and the link in the parent card's, both under the name of the person who created the API key. Sending the link request again for the same two cards returns 409 instead of adding a second link, so it is safe to retry. Card creation is safe to retry when you resend the same X-Idempotency-Key.
A work breakdown structure template you can copy
A WBS template for agent work has two parts: an outline for the parent card, and one description shape for every leaf. The outline goes in the parent card's description:
1 [Project or deliverable] what "finished" means for the whole thing 1.1 [Deliverable] something you can point to when it is done 1.1.1 [Leaf] one-sentence change, one check 1.1.2 [Leaf] 1.2 [Deliverable] 1.2.1 [Leaf] 1.N Docs and release the work everyone forgets Rules: children add up to exactly their parent. No two leaves cover the same work. No phase or department boxes. Every leaf has a check.
Each leaf card's description, filled in for leaf 1.1.2 from the example (paths and the card ID are placeholders):
## Outcome
One sentence: the change, the way you would describe the diff.
## Parent
1.1 Invite link API (card INV-4). The endpoints teams use to create
and redeem invite links. Siblings: 1.1.1 create, 1.1.3 tests.
## Where
- src/api/invites.ts
- tests/invites.test.ts
## Done when
- [ ] Redeeming an expired link returns 410 and adds no member.
Check: npm test -- invites
- [ ] The existing members API is unchanged. Check: npm test
## Out of scope
- The UI (1.2) and the email (1.3) Then tell your agents, in their instruction file, to read the Parent section first, work only inside Where, run every check under Done when, post the results as a comment and move the card to a review column. A person moves it to Done. That review step is the layout we describe in the kanban board for AI agents guide. It is a rule in the agent's instructions, not a lock: Flux does not stop an agent with a Write key from moving a card to Done.
If your plan comes from a spec tool such as Spec Kit, you may already have the leaves: its tasks.md template is a numbered checklist (T001, T002 and so on), with [P] marking tasks that can run in parallel. Our post on spec-driven development shows how to turn that list into cards. The WBS view adds the part a flat list lacks, the check that the leaves add up to the whole and do not overlap.