Work Orders

Work orders are structured, traceable tasks that move the system toward the target state defined in your PRD and blueprints. Each work order bundles everything a contributor needs to execute: title, status, assignee, timing, full description, upstream context, implementation guidance, and collaboration history.

Every work order brings together:

• Core metadata – ID, title, status, assignees, and phase.
• Rich description – purpose, acceptance criteria, and out-of-scope notes, written in a rich text editor
• Knowledge graph connection – links to upstream requirements and/or blueprints, with the ability to fetch concrete references.
• Implementation plan (optional) – a step-by-step, file-level implementation outline for engineering work.
• Activity & comments – a chronological feed of changes and threaded discussions, including attachments.

Before you dive into individual tasks, set up the planning structure so everything downstream behaves the way you expect.

Set your work order extraction strategy

• Choose a default extraction style (e.g., feature-slice vs specialist-oriented).
• Optionally define a custom extraction strategy by giving the agent explicit instructions on how to break blueprints into tasks.
• These settings control how subsequent “Extract Work Orders from Blueprints” operations behave.

This upfront configuration ensures future work orders, phases, and agent-driven planning all share a consistent structure.

You can create work orders in two main ways:

Agent-driven extraction from blueprints

• Use the agent action “Extract Work Orders from Blueprints” to generate work orders from updated blueprints.
• The agent reads the relevant blueprints and requirements, applies your extraction strategy, and proposes a set of work orders for you to review.

Manual work order creation

• Click the “+” control in outline panel (left-side) to open the creation form.
• Drafts are automatically cached locally if you navigate away, and restored when you return.

Once work orders exist, they appear in the main table view, where you can search, filter, and open any work order into its detail panel.

With work orders created, the next step is to shape a realistic delivery plan by assigning phases and sequencing tasks within each phase.

1. Assign work orders to phases

• In the Table View, use the Phase column to set or change a work order’s phase via the inline dropdown.
• Group the table by Phase to see work organized into collapsible sections with their phase ranges.
• Use the agent’s Phase Planning action when many work orders are unassigned—the agent can propose a phase plan and apply it once you confirm.

2. Sequence work within a phase using drag-and-drop

• When grouped by Phase, work orders can be dragged and dropped to define execution order:
• Drag a work order up or down within the same phase to resequence priority.
• Drag a work order into a different phase group to both reassign it to that phase, and place it at a specific position in that phase’s ordering.
• This drag-and-drop sequencing gives teams a clear, visual sense of what should be done first, second, and so on within each timebox.

3. Use filters and search to refine the plan

• Filter by assignee, status, phase, deliverable type, or feature to focus on specific slices of the plan (e.g., “all Phase 1 work assigned to me”).
• Use the search input to quickly locate specific work orders by title before you move or resequence them.

Over time, managing phases and sequencing becomes the core “planning loop”: new work orders are created or extracted, then placed into phases and ordered so the team always knows what’s next.

Software Factory supports integration with external development tools through MCP (Model Context Protocol) connections. MCP allows developers to interact with work orders directly from their local development environment, reducing context switching between planning and implementation.

Once connected, supported development tools gain secure, project-scoped access to work order context, including:

• Listing work orders assigned to the developer
• Reading full work order details, including descriptions and implementation plans
• Updating work order status (e.g., moving a task to In Review)
• Staying aligned with the current phase and execution order without leaving the editor

From the table view, use the MCP Connection button to open the connection dialog.

1. Open the MCP Connection Setup dialog.
2. Follow the setup instructions shown for your selected coding agent. Some agents support one-click installation directly from the dialog, others provide a configuration JSON to copy into a .mcp.json file in your project.
3. If prompted by your coding agent, select Use This MCP server to confirm the connection.

Once setup is complete, the connection status updates to Connected, and Software Factory tools become available in your coding environment immediately.

After connecting, developers can:

• Query work orders that are assigned to the user and in "Ready" state
• Search for additional context in Software Factory requirements, blueprints and artifacts
• Update work order status as development progresses

These interactions are reflected immediately in Software Factory, keeping the project plan accurate without requiring manual updates in the web interface.

The agent can:

Create and edit work orders

• Draft new work orders with proposed title, description, assignees, status, and phase.
• Update existing work orders (e.g., retitle, reword descriptions, change phases) based on natural language instructions.

Batch-edit multiple work orders

• Apply the same change across a set of work orders (e.g., “Move these to Phase 2 and set them to Ready”).

Software Factory is designed to keep work orders in sync with upstream design and downstream implementation.

Background agents monitor blueprints for significant changes and surface them in work orders:

• Create Work Orders from Blueprints: When a blueprint is newly completed or heavily updated, the system may suggest new work orders. An alert in the agent panel indicates how many blueprints are ready for extraction and lets you trigger the extraction workflow.
• Update Work Orders from Blueprints" When existing work orders are now out-of-date compared to their blueprints, Software Factory flags the affected work orders, raises a “Work Orders Need Updates” alert, and guides you through suggested updates to bring tasks back in line with the design.

• Curate how work orders are written using Work Order Settings.
  Use Overview → Project Settings to configure phase cadence and, most importantly, work order extraction strategies. This is where you define what “good” work orders look like for your team—size, scope, and level of detail. Treat these settings as the contract between blueprints and execution.
• Always ground tasks in upstream context.
  Use Knowledge Graph connections and “Find References” so each work order traces back to a requirement and/or blueprint. This reduces misinterpretation later.
• Use the description sections rigorously.
  Treat Purpose, Acceptance Criteria, and Out of Scope as non-optional. Clear boundaries here prevent scope creep and confusion during implementation and review.
• Keep implementation plans realistic and concise.
  Plans should be specific enough to unblock a developer, but not so detailed that they try to mirror every line of code. Focus on files, key changes, and integration points.
• Let the agent handle the mechanical work.
  Use agent actions for bulk updates, extraction from blueprints, and phase planning so humans can focus on judgment calls, not data entry.
• Review and sync regularly.
  Make it routine to respond to alerts, refresh work orders from updated blueprints, and adjust implementation plans as the codebase evolves. Avoid letting drift pile up.