From latent grid to tokens
The pipeline up to this point is unchanged: an encoder compresses the image or clip into a latent, and denoising happens there. What changes is the network doing the denoising.
A diffusion transformer takes that latent grid and cuts it into small patches, commonly 2x2 latent cells each. Every patch becomes one token, gets a position embedding so the model knows where it came from, and then flows through a stack of identical transformer blocks. The timestep and any global conditioning are folded in by modulating the normalisation layers rather than by concatenating channels. At the end, tokens are projected back to patches and reassembled into a latent.
There is no downsampling path, no bottleneck, no skip connections. The spatial resolution of the token grid is constant through the whole network, and every layer does full self-attention. That is expensive, and it is the entire point: no layer is ever restricted to a local window.
Why it changed what prompts can do
Three capabilities arrived more or less together with this architecture.
Prompt adherence over many clauses. When text and image tokens share an attention operation across every block, a clause in the middle of a long prompt has as much access to the canvas as the first one. Convolutional backbones injected text at a handful of resolution levels and lost clauses accordingly.
Text in frame. Spelling is a global constraint on a local texture. Letters must agree with each other across a distance that spans many latent cells. Full attention can enforce that; local convolution cannot, which is why a whole generation of models produced convincing signage covered in nonsense.
Variable resolution and duration. A token sequence has no preferred length. The same weights can generate 1:1, 16:9 or 9:16, or a 5 second and a 10 second clip, because changing the output shape only changes how many tokens there are. Convolutional models learned composition at a fixed size and duplicated subjects when pushed off it.
Tokens are the cost model
If you want to predict how expensive or slow something will be, count tokens. For video the count is roughly the spatial latent area divided by the patch size, multiplied by the number of latent frames after temporal compression.
- Doubling duration doubles the tokens, and attention cost grows with their square.
- Going from 720p to 1080p multiplies the spatial term by about 2.25.
- Halving the patch size quadruples the tokens, which is why detail oriented variants are so much slower.
This is why platform pricing tiers cluster around resolution and duration rather than around prompt complexity, and why a model that offers 10 seconds at 1080p is doing far more work than the numbers on the spec sheet suggest. Video families in production use several strategies to keep this tractable: full 3D attention over space and time in the highest quality tiers, and factorised or windowed attention where speed matters more.
What to actually do with this
Treat the architecture as a filter, not a verdict. If your shot needs readable words, a specific object count, a layout you described in words, or an aspect ratio away from the usual, choose a transformer based family and expect it to hold. If your problem is grain, skin, a niche aesthetic, or a style adapter you already own, architecture will not decide the outcome and you should test rather than assume. And when a long clip is timing out or costing more than expected, the fix is almost always fewer tokens: shorter takes chained together, or a lower resolution pass finished with an upscaler.