FlyNow

The moment

“Watson, come here — I want to see you.” In 1876 one sentence proved a whole new medium was real. This is that kind of threshold — the first time an AI carried a single design idea, unbroken, through every discipline of a modern engineering enterprise and committed it to the system of record.

Alexander Graham Bell didn't just transmit a voice; he collapsed the distance between intent and reception. The digital thread has the same ambition — collapse the distance between a requirement and the as-built configuration, across mechanical, electrical, software, and reliability engineering, so nothing is lost in translation between tools or teams.

What's documented below is a live demonstration of that thread being authored end-to-end by an agent: reliability physics in MADe becoming requirements; requirements becoming functions; functions becoming a logical architecture; the architecture becoming an electrical schematic and wiring harness in Capital and a mechanical assembly in NX; and all of it materialized as configuration-managed items in Teamcenter. One idea. Every domain. No handoff lost.

The aircraft

QX-250 at a glance

A 5-inch freestyle-class quadcopter — the vehicle the whole thread describes.

The thread

One idea, carried through every domain

Each stage is real work in the real tool. Screenshots are captured directly from the running applications.

0

Reliability & safety physics ✓ MADe

The design starts from failure physics, not geometry. A MADe (PHM) model of the quadcopter produced an FMECA, a fault tree, and an RBD: loss-of-thrust probability 1.85×10⁻⁴/h, mission reliability R(1h)=0.99982, and — critically — 24 order-1 minimal cut sets: every single fault drops the aircraft, because a quad cannot fly on three rotors. That finding drives the safety requirements and a recommendation to trade toward a hexacopter.

1

Requirements → Functions → Logical ✓ authored

50 requirements across 10 domains, with the reliability set traced line-by-line to the MADe artifacts. Nine functions (F1–F9: store energy, distribute power, drive motor, convert to rotation, generate thrust, sense, stabilize, receive command, provide structure) with a Quad-X mixer. Seven logical blocks and a ten-interface register, each function allocated to a block and every interface accounted for.

2

Electrical schematic ✓ Capital

The power and signal architecture as a wiring schematic: a 4S battery feeds a 4-in-1 ESC that drives four 3-phase motors; an F7 flight controller closes the loop over DShot600, takes commands over an ELRS/CRSF link, and reads voltage/current sense. 29 nets, 27 wires, connector pinouts.

3

Logical design in Capital ✓ in-tool

The functional architecture was authored natively in Capital Systems Architect: nine functions with their signal connectivity, generated as a live diagram in the tool. Then the platform architecture was synthesized into a Capital Logic Designer logic design — the automated bridge from architecture to schematic — surfacing the two active controllers (the 4-in-1 ESC and the F7 flight controller) with the full harness toolset (devices, conductors, multicores, highways) ready for detailing.

The complete device-level wiring (all 10 devices, 29 nets) is the authored schematic in stage 2; the physical wiring harness is realized in 3D in NX below.

4

Mechanical design & routing in NX ✓ finished + routed

The airframe in Siemens NX, taken from a conceptual frame to a finished assembly: the parametric Quad-X frame (250 mm wheelbase, central plate, four circular-patterned arms, a motor on each arm) now carries the electronics stack (PDB/ESC + flight controller), the LiPo battery, and — the key step — the motor wiring routed in 3D: a wire run from the central stack out along each arm to its motor, patterned four-up. That's the harness realized physically, closing the loop from the Capital schematic to real geometry.

5

Materialized in Teamcenter PLM ✓ pushed

The whole logical architecture was pushed into the live Pre-Integration Teamcenter over the SOA gateway: 57 items (components → Fnd0LogicalBlock, functions → Functionality, carriers, signals, Fnd0LogicConn connections, Seg0Interface contracts) and 115 relations (all function→component allocations, interface contracts, trace links). Verified by read-back. This is the system of record — the as-designed configuration now lives in PLM.

How it was built

The tools, and the bridge between them

The hard part of a digital thread isn't any one tool — it's the seams. Here's how the seams were crossed.

How it was built — in detail

Crossing the seams between the tools

The hard part of a digital thread is that each tool owns its own model. Here is exactly how one description of the QX-250 was moved, losslessly, across all of them.

1 · A neutral contract in the middle

Every tool speaks a different dialect. Rather than N² point-to-point translators, the thread uses one neutral Logical-BOM JSON contract — components, ports, functions, allocations, networks, signals, connections, and requirement links — as the single interchange. The QX-250 was authored into that contract as quad_bundle.json: 10 components, 9 functions, 10 allocations, 3 carriers, 7 signals, 18 connections. It was validated through the import engine before anything was written anywhere — 0 errors, 0 warnings.

2 · Into Teamcenter, over SOA

A zero-dependency Python client logs into Teamcenter's JSON-REST SOA gateway (the live Pre-Integration instance) and materializes the bundle as configuration-managed items. A read-only existence check ran first — 0 collisions — then the push:

57 items and 115 relations created, idempotent and re-runnable, then verified by reading them back from the live server. The as-designed configuration now lives in PLM.

3 · Into Capital, as a native project

The same merged head was rendered to a Capital project.dtd XML and imported through Project Manager — creating the QX-250 Quadcopter project with a functional design and a platform design. Generate Diagrams produced the functional architecture sheet natively; Generate Logical Designs synthesized a Capital Logic Designer logic design from the platform architecture. Nothing was hand-redrawn — the schematic is a projection of the same model.

4 · Into NX, as geometry — and back to a harness

The airframe is parametric NX geometry (the wheelbase, arm length, and motor spacing are driving dimensions). The finishing step routed the motor wiring in 3D — a wire run per arm, patterned four-up — which is the harness (defined by the 27-line wire schedule) realized as physical geometry.

Design decisions

Why the design is what it is

Build log

What happened, when

Newest at the bottom. Times are local.