Questions we expect. And the ones we ask ourselves.

Pre-traction, by design at this stage. The Decomposition Engine runs end-to-end and Pre-Production (the Asset Studio) is proven live — locked reference images and a working turntable-style reference video, generated and reviewed through the real UI. What doesn't exist yet is a paying customer base. That's precisely what the $185K bridge buys: 6-9 months to a demo-ready pipeline before the seed round funds go-to-market.

Three things that don't copy quickly: locked reference contracts (the same approved asset travels through every shot — an architectural commitment, not a feature toggle), automatic multi-model routing built on live-verified pricing and performance data across 14+ models, and the Decomposition Engine's instruction set — the product of many sessions of specialized prompt engineering that encodes how a screenwriter-director actually thinks, not a generic "summarize this" prompt.

Real, and named rather than hidden. Pre-seed is exactly the stage built for one technical founder to prove the hardest part alone — traction follows the raise, not the other way around. Next hires are already scoped for post-funding: a sales lead, a co-founder with complementary design/distribution strength, and a part-time technical PM from month three.

The primary wedge is film producers — reached through direct outreach to 20 producers in active pre-production during the bridge period, with 3–5 free pilot runs on real scripts and a goal of signed Letters of Intent before the seed closes. Organic reach follows through Stage 32, No Film School, and IndieWire communities, plus partnership outreach to screenwriting platforms such as Coverfly and Final Draft. Honestly: CAC isn't known yet, because there's no traction to measure it against. That's an open item, not a hidden one.

Because we removed the parts that didn't hold up. An independent review flagged that our original burn-multiple claims (as low as 0.70× in Year 1) would have beaten the best-in-class 2025-2026 AI-native cohort before the product was even fully built — not credible, so it's gone from the pitch. What remains is grounded in real per-unit economics: 14 actual AI models benchmarked, every production outcome carries at least a 10× margin floor even under worst-case model routing — that floor applies to the underlying AI generation cost regardless of how credits are priced in the platform. One specific note on the Series A: the 5% dilution on a $2.5M raise reflects a projected pre-money valuation of approximately $50M — consistent with 2025–2026 AI-native SaaS benchmarks of 10–15× ARR at that stage (Carta, PitchBook, SVB data). We are not underpricing the round. We are sizing the raise to what the bridge period milestone actually requires, against a valuation the market already supports at $4M ARR.

Dilution compounds — it doesn't add. Here's the actual math: After the bridge (10% issued): founders hold 90%, bridge investors hold 10%. After the seed (20% new shares issued): every existing holder is diluted by 20%. Founders move from 90% to 72%. Bridge investors move from 10% to 8%. New seed investors hold 20%. After the Series A (5% new shares issued): existing holders diluted by 5%. Founders: 68.4%. Bridge: 7.6%. Seed: 19%. Series A: 5%. Total investor ownership: 7.6 + 19 + 5 = 31.6%. Founders retain 68.4%. The gap between 35% (simple addition) and 31.6% (compounding) is the difference between how dilution actually works and how most people instinctively calculate it.

Not sized yet. We'd rather say that plainly than back into a number that sounds impressive and means nothing. It's an explicitly open item for this raise.

Big labs build generation primitives — better images, better video. We build the production workflow on top: continuity, versioning, shot assembly, and a director who never has to think about which model did the work. That's a different product and a different buyer relationship. We treat their models as suppliers, not as something we compete with.

Yes — which is exactly why automatic multi-provider routing is the architecture, not a slide. We proved this live during development: one video model failed outright at a task, and the system routed to a different provider's model without any change to the product experience. Model selection is a database row, not a code dependency.

Every production package now carries at least a 10× margin even in the worst-case scenario (premium-tier model routing, fastest production pace) — priced from real cost data across 14 models, not a single cheapest-model guess.

AI generation crossed into usable quality, and the field moves every week — new releases, quiet deprecations, sudden jumps in fidelity. Nobody has connected the full pipeline yet. Building now means the platform compounds automatically with every model improvement, instead of waiting on one breakthrough that may never arrive on anyone's schedule.

From market data, not ambition. The benchmarks used: Series A (~Y3, $4M ARR): 10–15× ARR is the current range for AI-native SaaS at Series A stage, per Carta and PitchBook 2025–2026 data. A $50M pre-money on $4M ARR sits at the lower end of that range — deliberately conservative. Mid case (~Y4, $8M ARR): 8–10× ARR, reflecting a maturing platform with proven retention and expanding segments. $65M–$100M range. Target case (~Y5, $16M ARR): 8–12× ARR for a cash-flow-positive orchestration-layer SaaS with compounding model advantages and three active buyer segments. $130M–$195M range. The 2021-era 20–30× multiples are not used here. These are built on post-correction benchmarks from SVB, Carta, and PitchBook — the same sources institutional investors reference in due diligence.

A wrapper calls one API and shows the result. We run 14+ models across three providers with automatic routing, a per-generation cost ledger, a director-rating system that retrains routing decisions over time, and a versioned identity system that keeps a character's reference consistent across an entire production. The generation call is one component of that — not the product.

We watched this happen during development, not just modeled it: a video model that should have worked failed outright on a real task. Fixing it was a database update to the routing table and a different provider's model — not a code rewrite, not downtime. That resilience is built, not promised.

Locked reference contracts: once a director approves a reference, that exact asset — same face, same costume, same identity — travels through every downstream shot. Versioning lets a director branch new wardrobe, age, or condition variants while the original identity stays anchored. This runs today in the Asset Studio, not as a diagram.

Rebuilt from real per-generation cost data — and deliberately not from the cheapest available model. A live test proved the cheapest video model for a given task simply couldn't do it; we priced around the average of the top three cost-benefit-ranked models per category instead, specifically because "cheapest" and "reliable" aren't the same thing.

Different core competency and a different customer relationship. Runway, Kling, and similar companies are optimized to make their own model better and faster — not to solve continuity, versioning, and director-facing simplicity across a whole production. They're our suppliers, not our competitors: every model that improves makes our output better, which is a bet that's already paying off as new models ship.

Because there isn't a real comparable to benchmark against. It's not text summarization or professional script coverage (a few pages of notes) — it's a complete structured shootable production blueprint: full cast, scenario, and prop breakdown with cinematographic specs, the actual input every downstream phase depends on. We're not matching a market rate here. We're setting one.

When the cheapest video model failed a real task during development, fixing it took actual engineering: a queue-based dispatch protocol (some models can't be called synchronously at all), a first/last-frame interpolation architecture using two locked reference images instead of one, and a review UI to approve or reject the result. None of that is "call an API and show a picture." It's a production system with real failure modes — and real fixes.