Workflow Guides

Floor event → design → ForgeOps

This is the flagship Forge workflow. A machine on the shop floor raises an event (a failed part, a tooling change request, a maintenance finding), and that event flows all the way through to a design revision and a new job brief — without anyone leaving their station or emailing a file.

Step 1: Machine event raised in ForgeMaint

A technician on the floor identifies that a worn fixture is producing out-of-spec parts. They raise a work order in ForgeMaint from their iPad, standing next to the machine. The work order includes the measured deviation and a photo.

# ForgeMaint raises the event automatically when a WO is created.
# Event published to ForgeHub:
{
  "event": "maintenance.work_order.created",
  "machine_id": "VMC-01",
  "work_order_id": "WO-2026-0847",
  "type": "fixture_deviation",
  "measured_deviation_mm": 0.12,
  "affected_part": "PART-4821"
}

Step 2: ForgeCAD opens the relevant design

ForgeHub routes the event to a registered handler. The handler looks up which ForgeCAD document owns PART-4821 and opens it:

import forgecad as fc

hub = fc.ForgeHub(api_key="fsk_live_xxxx")

@hub.on("maintenance.work_order.created")
def handle_fixture_deviation(event):
    if event["type"] != "fixture_deviation":
        return

    # Find the document that owns this part
    doc = fc.Document.find_by_part(event["affected_part"])

    # Open and check current fixture tolerance
    fixture = doc.get_feature("fixture_body")
    print(f"Current tolerance: {fixture.tolerance_mm}mm")
    print(f"Deviation reported: {event['measured_deviation_mm']}mm")

Step 3: Design revision

The engineer updates the fixture tolerance parameter and publishes a new revision. ForgeCAD automatically rebuilds dependent geometry and updates the BOM.

    # Update the tolerance parameter
    doc.set_param("fixture_clearance", fixture.tolerance_mm + 0.05)

    # Rebuild and validate
    result = doc.rebuild()
    if not result.success:
        raise ValueError(f"Rebuild failed: {result.errors}")

    # Publish the revision with a reference to the work order
    doc.publish_revision(
        message=f"Increased fixture clearance — ref {event['work_order_id']}",
        work_order_id=event["work_order_id"]
    )
    # Triggers: design.revision.published → ForgeHub → ForgeOps, ForgeMachine, ForgeProcure

Step 4: ForgeOps generates a brief dispatch

ForgeOps receives the design.revision.published event and automatically creates a job brief for the updated fixture. The brief includes the revised BOM, estimated machine time, and material cost.

The complete brief dispatch workflow is covered in the next section.

ForgeOps automated brief dispatch

When a design revision is published, ForgeOps can automatically generate and dispatch a job brief to ForgeMachine. The brief includes the revised BOM, estimated machine time based on historical OEE data, and a cost estimate.

Configure the dispatch rule

import forgecad as fc

ops = fc.ForgeOps(api_key="fsk_live_xxxx")

# Register a dispatch rule: auto-brief on revision publish
ops.add_dispatch_rule(
    trigger="design.revision.published",
    filter={"document_tags": ["production"]},   # only production-tagged docs
    actions=[
        {"type": "create_job_brief", "assign_to_machine": "auto"},
        {"type": "notify_scheduler", "channel": "forgehub"},
    ]
)

What the brief contains

ForgeOps builds the brief automatically from live data:

• BOM — pulled directly from the published ForgeCAD revision
• Machine time estimate — based on historical cycle times for similar parts from ForgeMachine OEE data
• Material cost — current prices from ForgeProcure vendor list
• Capacity check — ForgeMachine reports current queue depth; ForgeOps assigns to the optimal machine

Brief dispatch event

# ForgeOps publishes this to ForgeHub when a brief is dispatched:
{
  "event": "ops.job_brief.dispatched",
  "brief_id": "BRIEF-2026-0391",
  "document_id": "doc_abc123",
  "revision_id": "rev_xyz789",
  "assigned_machine": "VMC-01",
  "estimated_cycle_time_min": 47,
  "material_cost_usd": 84.20,
  "start_window": "2026-06-02T08:00:00Z"
}

ForgeMachine job flow

Once a job brief is dispatched, ForgeMachine manages the full execution lifecycle:

• Schedule — brief appears in the ForgeMachine job queue with estimated start time
• Setup — operator receives tooling list and setup instructions on the shop floor display
• Run — cycle time tracked against the estimate; OEE calculated in real time
• Complete — job.completed event published to ForgeHub; ForgeOps updates job margin
• Deviation — if cycle time exceeds threshold, ForgeMaint receives an alert and can auto-create a PM work order

# Listen for job completion and update cost actuals
machine = fc.ForgeMachine(api_key="fsk_live_xxxx")

@machine.on("job.completed")
def on_job_complete(event):
    ops = fc.ForgeOps(api_key="fsk_live_xxxx")
    ops.record_actuals(
        brief_id=event["brief_id"],
        actual_cycle_time_min=event["cycle_time_min"],
        scrap_count=event["scrap_count"]
    )