End-to-end document parsers provide a unified interface, but serialize page layouts and regional contents into one autoregressive sequence. This formulation forces independent regions onto a decoding path whose length grows with the total content, whereas crop-based two-stage parsers expose region-level parallelism at the cost of repeated visual prefills and fragmented page context. To retain full-page context while removing dependencies, we propose PaDoc, a layout-grounded parser that treats the predicted layout as a branching structure over a shared page representation. Under a region-sufficiency assumption, we derive a prefix-conditioned factorization in which the layout stream and regional content branches advance concurrently, reducing the decoding depth to the longest layout-content path. We realize this factorization within a single MLLM: packed variable-length ancestor attention preserves the visibility under standard next-token training, while masked parallel decoding creates branches that the evaluated vLLM backend serves as concurrent requests with cache-resident shared-prefix reuse. On OmniDocBench Full, PaDoc attains an Overall layout F1 of 91.1 and, among end-to-end parsers, a top-tier Overall score of 94.24 together with the best Text Edit (0.038) and Formula CDM (95.59). On a 384-page subset and one A800 GPU, it is the fastest end-to-end parser at five concurrency levels, improving valid-page throughput by 67.4-118% and reducing P95 latency by 39.2-54.9% relative to a same-backbone Sequential SFT baseline. Code is available at https://github.com/Longin-Yu/Padoc
Alex: Welcome to another episode of ResearchPod. Today we're looking at a document parsing system called PaDoc.
Sam: So this paper is asking how to speed up the way AI reads complex documents — things like contracts, research reports, financial filings?
Alex: Exactly. The core puzzle is that standard AI reads a document the way a person reads a novel — one word at a time, in a single, unbroken line from start to finish. It never looks ahead.
Sam: And I imagine that becomes a real problem with a 500-page document packed with tables, headers, and images.
Alex: It does. Because the AI forces everything into one long sequential list, it can't skip around or work on different parts of the page at the same time. It has to finish processing the header before it can even look at the paragraph below it.
Sam: So it's just... waiting on itself, constantly.
Alex: That's a good way to put it. The system spends most of its time blocked by its own previous output, rather than taking in the full picture of the page.
Sam: So the question PaDoc is trying to answer is: what if the AI understood the overall structure of a page first, and then handled each section independently?
Alex: Precisely. And the way PaDoc does this is by treating the page layout like a tree. The overall structure — where the title sits, where the columns are, where the tables live — that's the trunk. Each individual content region is a branch.
Sam: And once you've built the trunk, all the branches can grow at the same time, rather than one after another.
Alex: Exactly. The technical name for this approach is "prefix-conditioned factorization," but the plain-language version is: figure out the skeleton first, then fill in all the details in parallel.
Sam: How does it avoid getting confused, though? If it's processing a table and a paragraph simultaneously, how does it keep track of what belongs where?
Alex: That's the clever part. Every branch still has access to the full page image. So even while it's working on just one section, it can always see the whole page and understand how that section fits into the larger document. It never loses the big picture.
Sam: So it's not slicing the document into isolated pieces. It's more like giving multiple workers the same blueprint, and letting them each build their section at the same time.
Alex: That's a useful way to think about it. And to make sure each branch also remembers its own place in the logical structure — like knowing it's a sub-section under a particular heading — the system uses something called "ancestor attention." It's essentially a memory mechanism that tracks the branch's position in the tree.
Sam: So the branch always knows both where it sits on the page and where it sits in the document's hierarchy.
Alex: Right. That combination — shared visual context plus hierarchical memory — is what allows the parallel processing to stay coherent.
Sam: Did the paper show a meaningful difference in speed?
Alex: The results are notable. Across their tests, the system more than doubled throughput in some cases, and cut the time needed to finish processing a document by more than half. And critically, it achieves this without adding new components to the underlying model. It works within the existing architecture.
Sam: So the gain isn't coming from more computing power or a bigger model. It's coming from a smarter way of organizing the work.
Alex: That's the key finding. The same model, doing the same job, but structured differently — and the result is a meaningful improvement in efficiency. It suggests that for complex documents, how you sequence the problem matters just as much as how much processing power you throw at it. Thanks for listening to ResearchPod.