tldr: Flow is built to find a lot more kinds of bugs than what TypeScript is built for.
Flow avoids as much gratuitous unsoundness as possible in order to find more bugs: It never infers any, it models variance for objects/functions/type parameters soundly (this is critical), it minimizes type precision loss, it has sound support for various dynamic features with inference (Function.prototype.bind()/Function.prototype.call()/Object.assign()/etc), etc.
Flow infers and understands more kinds of types with fewer annotations. Extensive inference was important to us for easing the process of converting untyped code without missing errors as much as possible. It also helps reduce boilerplate when writing new, typed code. You get to decide if and when you want to express types in your code (with type annotations), but Flow will pick things up from there without much worry of losing type info.
Flow is built on top of a more general level of code understanding that will enable it to do much more than just typecheck in the future (see ReactEU talk about the Flow graph).
Flow also runs extremely efficiently (highly parallelized). For example, it already has to scale up to millions of lines of code at Facebook.
Love the direction of Flow. It's been great to see the rapid pace of development. Talks like the recent on you gave and explanations such as this gist are a great source of insight for users like myself. Thanks for taking the time to elaborate on the "why" of Flow. 👍