Catching Fake-Company Fleets by Their Shared Layout Mistakes

When a platform onboards businesses, it usually asks for a registration document, such as a state filing that names the company, its officers and its registered agent. This is a Sybil setting: one adversary poses as many independent participants, here by registering dozens or hundreds of shell entities. The adversary can randomize every name, number and address with no effort. What they cannot cheaply randomize is how the documents were made. A fabrication script places text into a template with the same small offsets, font metrics and rendering artifacts every time.

We propose to detect such fleets at the moment of onboarding, before any transaction history exists. The method measures each document's deviation from the authentic layout of its jurisdiction and then looks for groups of documents whose deviations are suspiciously alike. It does not flag documents for looking similar to each other. Genuine filings from the same state share a template by design, so similarity alone would flag every Delaware company. The signal is correlated error: independent genuine filers deviate from the template independently, while a fabrication pipeline deviates the same way every time.

Core Claim

Layout-aware document models can represent text, word positions (bounding boxes) and page pixels jointly. Once a document's layout is aligned to the known authentic template for its jurisdiction, what remains is a residual: field offsets, box sizes, baseline and kerning statistics, and compression or rendering traces. We claim this residual is a strong fingerprint of the production process, and that it can link Sybil documents that share no text entities.

Concretely, let $g(d)$ be a geometric-and-visual feature vector for document $d$, and $t(d)$ its jurisdiction template. The residual is

$$r(d) = g(d) - \mathbb{E}[\,g \mid t(d)\,],$$

where the expectation is estimated from verified genuine filings of that template. A candidate group $S$ is scored by how far its mean pairwise residual similarity exceeds what genuine same-template pairs produce:

$$\text{score}(S) = \frac{1}{|S|(|S|-1)}\sum_{i\neq j \in S} \cos\big(\phi(r_i), \phi(r_j)\big) - q_{0.999}^{\text{genuine}}.$$

Here $\phi$ is a learned residual encoder, and $q_{0.999}^{\text{genuine}}$ is the 99.9th percentile of pairwise similarity among genuine same-template documents. That percentile gives a null distribution calibrated per template, so the false-positive rate on honest filers can be controlled rather than hoped for.

This also reframes Sybil resistance in the usual economic terms. We do not claim to make fabrication impossible. We claim to force the attacker to inject independent, realistic noise into every identity. That eventually means physically printing and scanning each document, which raises the marginal cost per fake identity.

Where This Sits

Three lines of work motivate the gap without covering it. Recurrent Few-Shot Model for Document Verification detects tampering in single ID cards and receipts with patch CNNs and recurrent units, reaching AUC 1.0 on SIDTD. Each document is judged alone, so a fleet of internally consistent, untampered fabrications is invisible to it. BuDDIE releases 1,665 US state business-registry filings and explicitly motivates them with KYC (know-your-customer) onboarding. It benchmarks only benign extraction. Detecting Sybil Addresses in Blockchain Airdrops finds Sybil clusters from star, tree and chain transaction subgraphs. It needs transaction history that does not exist at onboarding.

The method draws on two sources. LayoutLMv3 jointly encodes text, 2D coordinates and image patches, and supplies our backbone features. A Bounding Box is Worth One Token maps each box to a single learned layout token; we use this as a compact way to feed per-field geometry into the residual encoder.

The design is constrained by one tension in the file. The document-verification paper found local CNN features beat Vision Transformers on tampering textures, while LayoutLMv3 found patch Transformers win on layout understanding. We therefore split the residual into two parts: a geometric part from layout coordinates and a local-texture part from a CNN. We ablate each.

The calibrated null borrows its motivation from the "power-user problem" in Bucks for Buckets and ADAGE. Both are defenses against model stealing across many accounts, and both risk penalizing legitimate heavy users. Our equivalent heavy users are commercial registered agents and filing services, which legitimately appear on thousands of filings.

Research Program

Build a benchmark. No Sybil-document dataset exists, so we build one. BuDDIE filings serve as genuine documents, supplemented with additional public registry filings to raise per-jurisdiction counts, since 1,665 documents spread across states leaves some templates thin. We construct fleets with four families of fabrication pipeline, chosen so we can test generalization across families:

  • template filling onto a scanned blank form;
  • rendering from generated HTML or PDF;
  • image-editing a genuine filing, in the style of SIDTD forgeries;
  • an adaptive attacker who adds random jitter to positions, fonts and compression at controlled strength.

Every fleet randomizes company names, officers, addresses and IDs.

Train the residual encoder. We align each document's OCR boxes to its template using key-field anchors, the printed labels whose positions are fixed. We then compute the geometric residual and extract the texture residual. The encoder $\phi$ is trained contrastively: positives are documents from the same generator instance, and negatives are genuine same-template documents. Whole generator families are held out at test time.

Detect fleets. Documents arrive in a stream. Each new document is compared to a residual index within its template, and groups whose score exceeds the calibrated threshold are flagged.

Baselines

The naive reference is per-document screening with no cross-document linking. We run the recurrent few-shot verifier, retrained on our genuine data and the image-editing fleets, and flag any document it scores as forged. Its reported per-document result is AUC 1.0 on SIDTD. No reported result was found on Lacuna for detecting fleets of fabricated registry documents, which is the actual question here. Beating it means higher fleet-level detection on the template-filled and rendered families, where no single document is tampered.

The strongest competitor on this question is text-entity linking. We extract officers, agents, addresses and entity IDs with a fine-tuned layout-aware extractor, then connect documents that share normalized entities. On BuDDIE entity extraction, DocLLM reports 89.97 F1 and LayoutLMv3 reports 86.49 F1 (BuDDIE), so extraction quality is high. This baseline is the real threat whenever attackers reuse an address or agent. We run it on the same fleets and the same genuine pool, and give it the same tuning budget for its link threshold. Beating it means better detection at a matched false-positive rate under entity randomization. We also require that it does not collapse when legitimate filing services appear on many genuine documents.

The third baseline is similarity clustering on raw features. We cluster documents by perceptual image hashes, and separately by LayoutLMv3 document embeddings, without subtracting the template. This doubles as the key ablation: it uses the same backbone and the same clustering, and differs only in the template-conditioned residual. If it matches our method, the core claim fails.

Further ablations remove, in turn, the geometric residual, the texture residual, and the per-template calibrated null (replacing it with one global threshold). All methods share the same data splits, backbone compute and hyperparameter search budget.

Why not just…?

Why not just link documents that share names, addresses or registered agents? Because the attacker controls text for free, and randomized entities defeat this baseline by construction. Where attackers are lazy it will work, and we will report that honestly. Its other weakness is false positives. Commercial registered agents legitimately appear across huge numbers of genuine filings, so entity overlap mixes honest and fraudulent structure. We measure its false-positive rate on genuine data directly. The strongest deployed system is likely text linking combined with residuals, and we test that combination.

Why not just use perceptual hashing or embedding similarity to find near-duplicates? Genuine same-jurisdiction filings are near-duplicates at the layout level, so similarity without template subtraction should flag honest filers en masse. The raw-embedding ablation tests this directly. If the ablation performs as well at a 0.1% false-positive rate, the residual idea is unnecessary and we would say so.

Why not just wait and catch the Sybils from transaction graphs? Subgraph-based LightGBM reports 0.9806 AUC on the BAB airdrop, but it depends on funding and dispersal histories that postdate onboarding. By then the fake entities already hold accounts. Document-time detection is complementary. We cannot run a joint comparison because no dataset in the file pairs filings with transactions, and we note this as a limitation.

Why not just run a better single-document forgery detector? Template-filled and freshly rendered fakes contain no tampered pixels, so there is nothing local to detect. The per-document baseline measures exactly how much of the fleet signal lives only in cross-document correlation.

Proposed Experiments and Decisive Checks

The primary metric is fleet recall at a fixed false-positive rate of one genuine document flagged per 1,000 onboardings, for fleet sizes from 5 to 200. We also report fleet-level AUC, and the minimum fleet size detected with 90% recall. Every result is reported on held-out generator families.

The first decisive check is the residual-versus-raw-similarity ablation at matched false-positive rate. The claim lives or dies here.

The second is an entity-randomization sweep. We vary the fraction of fleets that reuse a real address or agent, and show where text linking and residuals cross over.

The third is a cost curve under the adaptive jitter attacker. We plot detection against the attacker's injected noise variance, relative to the variance observed among genuine filings. We also include a small print-and-scan fleet. We expect detection to fall as injected noise approaches genuine variance. The informative quantity is how much per-document effort that requires.

The fourth is a robustness check. We degrade scans to test sensitivity to OCR error in the geometric residual, which is a known weakness of box-based models. We report whether the texture residual compensates.

If the residual method beats both text linking and raw similarity on unseen generator families at a 0.1% false-positive rate, the paper establishes cross-document layout forensics as a practical Sybil defense at onboarding. If it does not, the benchmark still shows which of the simpler defenses suffices.