Skip to content
Fluxx

Build Categories

Fluxx is built across five categories. Each category is a coherent module with its own scope, vendor potential, and sequencing. The five-category framework is what the Financial Model v2.0 envelope ($6.4M to $12M build plus $2.4M to $4M per year maintenance) costs out against.

All five category names are explicit in Fluxx_Development_Plan_v0.3.docx. Source-faithful; no synthesis gap on naming.

Cat 1, DCC Pipeline Framework

Scope. The pipeline layer bridging DCC tools (Maya, Nuke, Houdini, Unreal, Blender, Resolve, Substance, AE) to Fluxx Automate (production tracking, Cat 3) and the Vault (asset library, Cat 3). Two parallel sub-tracks share a common spine:

  • Environment pipeline. Asset → environment graph. Per Kevin’s voice note: “not layout but going through assets, environments.” Feeds viz cascade from previs to near-final. Includes asset taxonomy plus entity types, environment composition, viz cascade integration, handoff seam to animation pipeline.
  • Animation / character pipeline. Animation plus tech animation (rigging, sim, cloth, hair) plus assigned departments. Separate workflow but shares Vault, ComposiTrack, viz cascade primitives.

AYON research as blueprint. Patterns Fluxx ports (rebuilt Fluxx-native, no AYON code at runtime): package.py manifest, four-folder addon layout, plugin path taxonomy, Pydantic-with-scope settings, bundle abstraction, event spine split, leecher / processor / transmitter. Patterns Fluxx rejects: LAN-and-file-system substrate, single-tenant data model, no-VM-lifecycle posture, local-launcher distribution. See AYON Port / Reject.

Build vs buy vs partner.

  • Pipeline service core (DCC connector layer): core team designs, mixed implementation.
  • Per-DCC plugins: outsourced specialist VFX pipeline TDs.
  • Environment plus animation pipeline workflow logic: core team plus outsourced workflow engineers.
  • Viz cascade dependency engine: held in core team (architectural).

Cost envelope. Per-DCC plugin bands:

  • Nuke $80K-$200K
  • Unreal Engine $150K-$400K (larger due to nDisplay plus engine integration)
  • Maya $80K-$200K
  • Houdini $80K-$200K
  • Blender / Resolve / Substance / AE $30K-$100K each (later phase)
  • Environment plus animation pipeline workflow logic: $100K-$300K each

Module-count band per dev plan rollup: 5 to 8 modules total, $700K to $1.7M outsourced.

Y1-Y5 v2.0 outsourced spend: $200K / $700K / $700K / $100K / $0. Front-loaded Y1-Y3.

Dependencies. Cat 1 blocks Cat 4 (plugin SDK and agentic harness build against Cat 1 contracts). Cat 1 consumes Cat 3 (DCC plugin bridge feeds Automate). Cat 1 consumes Cat 2 (VM lifecycle hooks).

Current status. In planning / dev. Not yet vendor-RFP’d. Priority DCC list for v0.1 is Nuke plus Unreal plus Maya (working assumption per Fluxx_Pipeline_Architecture_v0.1.md §10 gap item 4; precise cut not locked, Kevin call).

Cat 2, Fabrixx Virtual Cloud Infrastructure

Scope. Cloud substrate Fluxx productions run on. Two sub-tracks:

  • Virtual Machines. Fluxx-owned VM lifecycle (fifth Fluxx-native primitive). Per-artist / per-shot / per-session lifecycle. Per Kevin’s voice note: “There need to be virtual workstations and virtualizations of the whole pipeline.” Includes provisioning system, remote desktop protocol pick (Teradici / Parsec / NICE DCV / native, TBD), VM-to-pipeline-service event integration, cost-per-VM-hour budget feeding IaaS / per-shot pricing, DCC pre-installation per VM template.
  • Cloud Security. Multi-tenant isolation, encryption envelope, audit logging, full TPN audit. Non-negotiable for Sony / A24 / Netflix-tier productions. Includes multi-tenant VPC topology (per-tenant vs shared with tagging, Kevin call), tenant isolation primitives, full TPN audit (separate vendor budget), encryption at rest plus in transit, audit logging.

Build vs buy vs partner.

  • VPC plus tenant isolation architecture: core (cloud architect).
  • Cloud DevOps build-out: outsourced ($200K-$500K, TPN-aware cloud-DevOps shop, 16-24 weeks).
  • VM provisioning plus lifecycle service: core architect plus outsourced engineers ($150K-$300K).
  • Security policy plus audit logging: held in core (security engineer).
  • TPN audit plus remediation: outsourced auditor ($80K-$200K, one-time, required pre-production).
  • Cloud / GPU provider integration: core plus provider relationship (recurring opex).

Cost envelope. Module-count band 3 to 4 modules, $500K-$1.2M total outsourced. Plus TPN audit one-time.

Y1-Y5 v2.0 outsourced spend: $0 / $500K / $500K / $100K / $0. Front-loaded Y2-Y3. TPN audit one-time: $0 / $0 / $150K / $0 / $80K (Y3 initial, Y5 re-audit). Cloud / GPU opex (COGS): $72K → $240K → $400K → $700K → $1M.

Dependencies. Cat 2 blocks Cat 1 (pipeline runs on the VM substrate). Cat 2 blocks Cat 3 (Automate runs on the cloud substrate). TPN audit is the gate for any Sony / A24 / Netflix production.

Current status. Not yet vendor-RFP’d. GPU cloud provider stack pick is parked at Q-G49 §7.

Cat 3, Fluxx Automate

Scope. Production tracking plus automation, built in-house. Replaces ftrack reliance at the runtime layer; ftrack patterns inform reference design only. Per Kevin 2026-05-20: “The more I see this I feel we should build this ourselves.” Rationale: ftrack’s data model assumes a 2005-2015 production shape; Fluxx’s shot model is different (virtual stage, in-camera capture, two-track finish, ML-assisted provenance). Multi-tenancy by JV-licensee economics requires tenant-aware production tracking; ftrack is single-tenant per install.

Sub-deliverables.

  • Core Automate surface. Entity model (Project / Sequence / Shot / Asset / Version / Task, Fluxx-native not ftrack-inherited), status workflow engine, assignment plus scheduling, review / approval state machine, notes plus comments, audit log plus history per entity.
  • Automation framework. Job queue plus resource orchestration (per Norman V7 M4 plus M5), agentic telemetry plus observability, automated dependency push from master shot, AI QC integration (Claude QC Agent plus Slack supervisor approval, per Norman V7 M3).
  • Event spine (Port from AYON / ftrack patterns): webhook-style event emission, leecher / processor / transmitter pattern, pub/sub broker.
  • Integration surface. DCC plugin bridge (consumed by Cat 1), Vault asset library bridge, VM lifecycle event integration (Cat 2), optional ftrack import / export for migration.

Build vs buy vs partner.

  • Norman V7 M4 plus M5 outsourced to GlassBox (vendor).
  • Entity model plus schema redesign: core (Automate product owner).
  • Automation workflow engine forward: core plus possibly outsourced ($100K-$300K).
  • Migration tooling (ftrack import / export): outsourced ($60K-$150K).
  • Multi-tenant production tracking: core plus outsourced backend ($200K-$400K).

Cost envelope. Module-count band 4 to 6 modules, $700K-$1.5M total outsourced (includes Norman V7 remaining). Norman V7 cumulative stated total: $517,000. V7 not-yet-invoiced: $406,070.

Y1-Y5 v2.0: Cat 3 GlassBox V7 remaining $406,070 (Y1) only. Cat 3 Automate forward modules: $0 / $300K / $400K / $100K / $0.

Dependencies. Cat 3 blocked by Cat 2 (runs on cloud substrate). Cat 3 consumed by Cat 1 (DCC plugins call Automate APIs).

Current status. Norman V7 M1-M3 completed (with reconciliation flags); M3.5 in progress (engine direction shift Unreal vs Chaos V-Ray); M4 plus M5 planned. Engine direction call pending per M3.5. Vendor selected (GlassBox / Norman) for V7 milestones; forward work beyond V7 not yet vendor-RFP’d. Full M1-M5 timeline at Dev Plan v0.3 > Norman V7.

Cat 4, Agentic Build Assist (HEAVY INVEST)

Scope. Covers all DCC software packages Fluxx productions use: Maya, Nuke, Houdini, Unreal, Blender, Resolve, Substance, AE, 3ds Max, plus longer-tail tools. The “agentic” part: automated build of per-DCC plugins from master spec, plus agentic tasks that populate shot dependencies from master shot. Per Kevin 2026-05-20: quality here determines third-party adoption ceiling. Plugin SDK is the moat.

Sub-deliverables.

  • Fluxx-native DCC plugin SDK (AYON Port patterns rebuilt). See Plugin SDK.
  • Event spine (AYON Port, Fluxx-native implementation).
  • Agentic build harness: automated per-DCC plugin generation from master spec.
  • Agentic dependency population: master shot defines tasks, viz cascade auto-populates downstream shots.
  • Initial DCC plugin set v0.1 (priority TBD).
  • Plugin testing plus validation framework.
  • Plugin distribution model.

Build vs buy vs partner.

  • Plugin SDK architecture plus agentic harness: core (2-3 dedicated TDs per Kevin).
  • Agentic dependency engine: core.
  • Per-DCC specialist module work: outsourced (per-DCC contractors, $30K-$300K each).
  • Plugin testing plus validation framework: core plus outsourced QA ($100K-$200K).
  • Plugin registry plus distribution: core (architecture call).

Cost envelope. Core team annual run rate (Cat 4 portion): 2-3 senior TDs @ $160K-$220K each fully loaded = $320K-$660K. Plus 1 agentic build engineer @ $180K-$240K and 0.5-1 QA engineer @ $100K-$160K. Cat 4 core team annual run rate: $600K-$1.06M. Plus outsourced per-DCC contractor spend $1M-$2M total during initial build phase.

Y1-Y5 v2.0 outsourced spend: $100K / $500K / $800K / $400K / $200K. Highest sustained line.

Dependencies. Cat 4 builds against Cat 1 contracts. Cat 4 consumed by every DCC integration in production.

Current status. TDs not yet hired. Open questions: plugin SDK scope at v0.1 (public for third-party studios or internal-only), priority DCC list, TD hiring profile (generalist senior or specialist per DCC), agentic harness build vs evaluate vendor offerings first.

Cat 5, AI Token Budget (Opex)

Scope. Per Kevin 2026-05-20: “I want to put aside a token budget for AI use by the software developers. $150-$200 per day per developer.” Recurring opex line, not a build cost. Funds AI-assisted development (Claude, Cursor, Copilot, similar) across the engineering team, core team plus outsourced module developers when contractually agreed.

Math. Rate × 5 days × 50 weeks × team size. At $150-$200/dev/day:

  • 3 devs = $112K-$150K
  • 5 devs = $187K-$250K
  • 8 devs = $300K-$400K
  • 12 devs = $450K-$600K

Coverage. All core team devs by default (pipeline backend, DCC TDs, cloud infra, Automate, agentic harness). Outsourced module work gets budget when contractually agreed (billable back as opex). Non-dev roles (designers, producers) get smaller AI budgets under G&A. Covers actual API / token spend, not subscription tooling (Cursor / Copilot subs separate under G&A).

Y1-Y5 v2.0 spend: $175/dev/day midpoint × dev team size 3 → 7 → 10 → 12 → 14 = $131K / $306K / $438K / $525K / $613K.

Dependencies. None. Recurring opex, scales with team size.

Current status. Active budget line. Open questions: per-dev hard cap vs pool model, approved AI providers (Anthropic, OpenAI, Google, local, all), reporting cadence, contractor budget treatment.

Build sequencing across categories

Per S123 plus the dev plan §13: vendor RFPs out for Cat 1 plus Cat 4 first (small RFP per module to 2-3 vendors before committing). Norman V7 is the Cat 3 data point already in hand. Cat 2 unblocks when GPU cloud provider stack is picked (Q-G49 §7).

Per the Y2 (Series A close) timeline at Dev Plan v0.3, first fresh RFPs go to: Cat 2 Cloud DevOps shop (TPN-aware), Cat 4 per-DCC specialists (starting Nuke), Cat 1 per-DCC pipeline TD for Nuke.

Source dependencies

  • 02_Working/Strategy/Dev_Roadmap/Fluxx_Development_Plan_v0.3.docx (primary, Cat 1-5 named explicitly in §3-§9)
  • 02_Working/Financial_Models/v2.0_Fluxx_Financial_Model.xlsx (cost envelope, Y1-Y5 spend)
  • 03_Fluxx_Private/Legal/Norman_V7_Milestones_Review_2026-05-12.md (Cat 3 vendor data point)

Audience visibility

investor, counsel.