This is the plan for how MindAptiv turns existing work (agent skills, API schemas, ERP integrations, workflow nodes, standards documents, legacy code, and even a plain-English UI script pulled from an old App Store title) into Aptivs: trust-certified, meaning-coordinated units that Synergy® can govern. The Creator can also skip assimilation entirely and describe intent to Synergy directly. Both roads produce the identical artifact.
Every organization already has a body of working knowledge encoded somewhere: an agent's SKILL.md, an OpenAPI schema, a SAP BAPI integration, an n8n workflow node, a standards document, a hand-rolled script. That work is real. It should not be rewritten from scratch just because it wasn't built inside Essence® to begin with.
The plan below covers every input path we support for turning that existing work, or a Creator's fresh intent, into an Aptiv. As proof that the pipeline is domain-agnostic, this plan uses the same worked example throughout: a plain-English UI and logic script written for a basketball scoreboard app once sold on Apple's App Store. Synergy assimilates it exactly the way it assimilates a SAP integration or an OpenAPI file: same eight phases, same grammar, same governance.
The Assimilator doesn't produce one output; it produces a small, fixed set of governed artifacts, and every source we feed it (a workaround, a Creator's own words, or existing code via Elevate) lands in this same set.
Generated from any workaround (agent skill, API schema, ERP integration, workflow node, standards document) by the Assimilator's own pipeline. Every claim in a Spec cites the source field it came from. Nothing is invented.
A Spec that has cleared the pipeline is registered into the shard library with a name, domain, and posture (Propose · Execute · Observe), and shown with a live Meaning Surface of typed inputs and outputs a Creator can call directly.
The declarative ("Outside / Inside," "Explain," "Add," "Define") script Synergy reads to regenerate the Aptiv's view and behavior on demand. This is the same grammar whether the source was an enterprise integration or a basketball scoreboard.
Generated in real time, for example when a Creator clicks View Aptiv, to preview structure and behavior before anything is sourced or committed. Unlike a Spec, it is not derived from any workaround or existing code; it's a mock, not a claim about a real source.
A separate SDK path (Import, Detect, Wrap, Combine & Deploy) that scans real existing code, data, or toolchains and wraps them without rewriting, shipping the result as a trust-certified .wv deployment unit. The original code remains the execution layer; the Aptiv layer is what governs it. Elevate runs alongside the Assimilator today, not as one of its eight phases.
Eight phases. Thirteen LLM agents. Two embedded deterministic analyzers that sit inside the pipeline but aren't counted toward the agent total, because they run no model at all. Every Aptiv Spec must trace to a real source. GenAI proposes; Synergy® resolves.
The Assimilator and the Health Monitor are two different workflows. The eight phases above run once, when a source is first ingested into an Aptiv Spec. The Health Monitor is separate and continuous: it re-scores Aptivs already living in the shard library against a 100-point rubric (Intent Fidelity 40, Structural Integrity 25, Domain Accuracy 20, Governance Compliance 15), routing anything under 75% to a Repair Agent. It does not run the 13 agents or the 2 embedded analyzers; it audits their output after the fact.
The proof case for this plan is a raw, plain-English script written for an iOS scoreboard app, the kind of thing that used to live inside a compiled App Store binary and nowhere else. Pasted into the Assimilator's workaround field exactly like an ERP schema or an agent skill, it defines a glossary of point values (a 3-pointer, a 2-pointer, a free throw), a wrapping PERIOD counter and a wrapping POSS possession flag, then lays out the on-screen structure top to bottom: home, game-clock, and away panels with LCD-style score readouts; a middle row of quarter indicators, possession arrows, and a shot-clock countdown; a bottom row of foul and timeout counters for both teams; and a 3×3 control panel wiring point buttons, foul and timeout buttons, and clock controls to that state, plus conditional logic that fires a buzzer at zero on the shot clock and a spoken line and fireworks when either team pulls ahead by a set margin.
Run through the same eight phases as any enterprise workaround (extraction, critique, synthesis, normalization, validation, generation, ensemble construction, deduplication) that script resolves into an Aptiv Spec with a Meaning Surface of typed inputs and outputs, and an Aptiv Script that Synergy can regenerate on demand. The grammar in that generated script (Outside Explain PANEL as…, Add TEXTBOX as a single-line input box…) is the identical declarative structure the Assimilator already writes for enterprise tools like “Access Local File System.” The source doesn't dictate the shape of the output. The pipeline does.
Outside Add a huge Section called HomeSpace in layout box. Inside Explain MYPANEL as panel text fill. Define SCORE_BIG as huge number set to 0 named HOME_SCORE with Font LCD Red ontop just number, leading zero, align center. Add PTS name +2. On press grow HOME_SCORE by FG2. Add name Foul. Increments HOME_FOUL. Add name Timeout. Decrements HOME_TOL. Add tiny text when SHOT_CLOCK is equal to 0. Hide. Then play buzzer.
Outside Explain PANEL as a large rounded card with a subtle border and padding. Outside Explain FIELD_LABEL as tiny mono uppercase text with a normal-weight description after. Outside Explain TOGGLE as an on/off switch defaulting to Off. Outside Explain RUN_BUTTON as a full-width filled accent button.
Every Aptiv reaches the shard library by one of two roads. The Assimilator handles the bottom-up road: bulk, source-grounded, built for the backlog of work an organization already has. Synergy's Create surface handles the top-down road: a Creator expresses intent directly, and Synergy routes it through Direct Synergy, AI-Proposed (Single or Multi-GenAI Composite, Chaperoned Aptiv, or Multi-Aptiv Ensemble), By Industry, the Use Case Plan Builder, Custom Use Cases, or Aptiv Discovery, whichever path fits how bounded, how large, or how likely-to-already-exist the intent is.
Two of those Direct Synergy entry points are worth walking through on their own, since each targets a different moment in the sales or delivery motion.
A Creator names a Company / Customer, picks an Industry, adds up to two Functions (HR, Finance, Supply Chain, Legal, Operations, IT/Sec, Procurement, Safety, or custom), and sets Focus: Scope (Department, Process, Workflow) and Priority (Governance, Efficiency, Compliance). Configure feeds Intent Mapping, which feeds Use Cases, a Synergy Preview, and an Intent Economy view showing what Synergy permits, constrains, and governs at the end state for that specific account.
Build with AI drafts a use case from a short description; New Manual starts from a blank plan. Either way the result merges with the standard scenario library rather than living apart from it: once approved it joins the UCP Library alongside the pre-built scenarios; everything still in progress stays here until it's approved or discarded.
Every Aptiv carries a grounding state. A newly assimilated Aptiv Spec is marked UNGROUNDED: structural validity only until its cited sources are verified against the underlying system. The Library Integrity Scanner runs continuously against all 30,000+ loaded Aptivs, checking four failure modes (structural, semantic, provenance, and alignment) on a sample, a shard, or the full library, with a nightly cron report as the standing baseline.