AI Engineer
Visual redactions that place black boxes over text fail to scrub underlying PDF streams, exposing suppressed records to hybrid parsers that combine computer vision with metadata extraction.
AI-assisted summary of Parsing the Epstein Files for JMail — Palak Agarwal & Omar Alhait, Reducto — original source. Check the original for full context.
Source published:
Key ideas
- Reducto processed over three million pages of the unsealed Epstein court files to power the viral JMail ecosystem, which logged over 450 million visits and 18 million unique visitors across products like JDrive, JFlights, and JPhotos. (2:02)
- Flawed government redactions in the source PDFs consisted of visual black boxes drawn over digital text streams, causing Reducto's parser to extract underlying personally identifiable information and forcing manual suppression routines. (13:48)
- Reducto relies on an agentic, vision-first OCR architecture with an iterative feedback loop instead of a single forward pass, dynamically balancing raw PDF metadata against visual OCR for edge-case enterprise documents. (0:12)
- Product evaluations show that consumer-style familiar interfaces like webmail drive significantly higher user engagement on public records corpora than standard open-ended RAG chat bots. (23:44)
Detailed notes
## Background Published on YouTube by AI Engineer on October 11, 2026, this presentation features Reducto's Palak Agarwal and Omar Alhait explaining how their document processing platform extracted structured data from messy, redacted Epstein files for JMail. The video description details how the speakers walk through the extraction pipeline behind JFlights, demonstrate schema generation in Reducto Studio, address challenges like reading order and PDF redaction leaks, and conclude with an interactive developer exercise.
## TL;DR Palak Agarwal and Omar Alhait showcase how Reducto's vision-first, agentic document platform parsed over three million chaotic, handwritten, and redacted pages from the Jeffrey Epstein court documents to power viral tools like JMail and JFlights. Alhait demonstrates Reducto Studio's extraction workflows, contrasting basic schema generation with document-aware approaches and explaining how flawed black-box redactions exposed raw text in PDF metadata streams. The technical walkthrough covers hybrid OCR prioritization, multi-layered nested schemas, and the foundational role of layout-aware parsing for downstream tasks. Concluding with practical advice, the speakers urge engineers to start evaluations with lean visual checks rather than complex benchmark suites, emphasizing that pairing robust extraction with intuitive, familiar consumer interfaces is what turns raw document dumps into usable products.
## Atmosphere & style The presentation strikes an engaging, pragmatic workshop tone that blends technical startup grit with lighthearted, candid humor about hacking together viral projects under cultural pressure. Palak Agarwal delivers polished, authoritative context on enterprise document architectures, while Omar Alhait brings an authentic, builder-first energy as he jokes about late-night on-call alerts and tools working 'a little too well' on government redactions. The atmosphere is open, responsive, and grounded, inviting continuous audience interaction and technical debate before seamlessly handing off to a collaborative live hacking session.
## Bulletin - [02:02](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=122s) Reducto processed over three million pages of the unsealed Epstein court files to power the viral JMail ecosystem, which logged over 450 million visits and 18 million unique visitors across products like JDrive, JFlights, and JPhotos. - [13:48](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=828s) Flawed government redactions in the source PDFs consisted of visual black boxes drawn over digital text streams, causing Reducto's parser to extract underlying personally identifiable information and forcing manual suppression routines. - [00:12](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=12s) Reducto relies on an agentic, vision-first OCR architecture with an iterative feedback loop instead of a single forward pass, dynamically balancing raw PDF metadata against visual OCR for edge-case enterprise documents. - [23:44](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1424s) Product evaluations show that consumer-style familiar interfaces like webmail drive significantly higher user engagement on public records corpora than standard open-ended RAG chat bots.
## Key takeaways - [00:12](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=12s) Reducto has raised $108 million from investors including Accel and Benchmark, processing over two billion documents for enterprises like Harvey and Scale AI. - [00:12](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=12s) Rather than relying on PDF text layer embeddings or character bounding boxes that scramble reading order, Reducto uses vision-first rasterization combined with an iterative agentic OCR loop that recorrects low-confidence regions. - [00:12](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=12s) The document manipulation architecture is built on five modular primitives: Parse, Split, Extract, Edit, and Classify. - [02:02](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=122s) JMail started as a five-hour hackathon prototype styled after Gmail by Riley Walz and Luke Farritor before growing into a full suite covering JFlights, JDrive, and JPhotos. - [03:14](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=194s) Standard large language models fail unpredictably on government forms, handwritten logbooks, and complex tabular accounting sheets due to ambiguous spatial layouts and non-linear reading orders. - [05:27](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=327s) Handwritten aviation logs in JFlights required Studio-configured extraction schemas to convert degraded scans and margin notes into structured entities for calendars and search queries. - [09:07](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=547s) Validated schemas in Reducto Studio can be immediately deployed to production as unified REST API endpoints or programmatic pipeline code snippets. - [11:18](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=678s) Reducto supports both rapid prompt-only schema generation and enhanced document-aware schema generation that inspects parsed sample layouts before drafting nuanced field definitions. - [13:48](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=828s) Incomplete digital redactions leave underlying text streams intact beneath visual black rectangles, creating major data sanitization risks for automated ingestion pipelines. - [15:34](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=934s) The extraction engine supports deeply nested schemas up to five layers deep and over 150 distinct fields while running post-processing models to attach exact provenance coordinates. - [17:41](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1061s) Hybrid OCR configurations resolve conflicts between corrupted metadata text streams and visual scans by dynamically predicting which source to prioritize per document region. - [19:23](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1163s) Extraction pipelines do not operate on raw file bytes; high-fidelity parsing of layout boundaries, reading order, and tables forms the prerequisite foundation for all downstream agentic tasks. - [20:43](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1243s) Document extraction differs from traditional needle-in-a-haystack retrieval because models must reliably collect 'all the needles in a haystack' across long, dense layouts without hallucinations. - [22:50](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1370s) Teams evaluating document parsers should begin with visual sanity checks in Studio before investing in 100-to-1,000 document programmatic benchmarks tailored to their unique document artifacts. - [23:44](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1424s) Packaging complex public records into a familiar webmail UI proved vastly more engaging and intuitive for casual discovery than an open-ended RAG chat assistant. - [23:44](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1424s) Proprietary document model accuracy still ultimately relies on human-supervised data labeling and bounding-box curation rather than purely synthetic or off-the-shelf foundation models. - [26:12](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1572s) Agentic configuration modules allow engineers to bind custom prompts and sub-models to handle specialized requirements like logo recognition and architectural blueprint parsing.
## Detailed walkthrough ### [00:12](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=12s) Reducto's Document Platform and the Vision-First Architecture
Palak Agarwal introduces Reducto as an agentic document platform designed to transform messy, unstructured enterprise documents into accurate data that AI models can consume. Over the preceding three years, Reducto raised $108 million from venture capital firms including Accel and Benchmark, processing more than two billion documents for clients such as Harvey, Scale AI, and a top-five global hedge fund. Operating at this scale exposed their platform to virtually every pathological edge case found in real-world files: skewed scans, upside-down pages, intricate tabular data, and complex charts.
Agarwal emphasizes that while running a standard frontier model on a clean, born-digital PDF is trivial, enterprise documents are overwhelmingly unstructured. Reducto acts as an intermediary processing layer positioned directly upstream of the user's foundation models. Rather than relying on underlying PDF text layer embeddings or character bounding boxes—which frequently scramble reading order—Reducto employs a vision-first rasterization approach.
Reducto processes documents using an iterative OCR architecture instead of a single forward pass:
```mermaid flowchart LR accTitle: Reducto Agentic OCR Processing Flow accDescr: Pipeline showing document rasterization followed by iterative validation before reaching the output stage.
subgraph Ingestion ["Ingestion Stage"] A["Unstructured Document"] --> B["Document Rasterization"] end
subgraph AgenticLoop ["Agentic OCR Stage"] B --> C["Initial OCR Pass"] C --> D{"Confidence Check"} D -- "Low Confidence" --> E["Flag & Recorrect"] E --> D end
subgraph FinalStage ["Output Stage"] D -- "High Confidence" --> F["Model Ready Data"] end ```
As Palak Agarwal puts it: “Everything is powered by our agentic OCR framework where rather than making a single pass and committing to an answer the model flags things that it's uncertain about corrects them and then moves on to the next step.”
- Reducto organizes its document manipulation capabilities into five core primitives: **Parse**, **Split**, **Extract**, **Edit**, and **Classify**. - The platform makes its web-based Studio environment self-service for developers to test and inspect extraction quality before committing to automated runs.
---
[02:02](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=122s) The JMail Phenomenon and Parsing the Epstein Corpus
Agarwal asks the room for a show of hands to see who has interacted with JMail, noting broad recognition across the audience. She recounts how the project originated when Riley Walz and Luke Farritor hacked together the initial prototype in just five hours following the public release of the Jeffrey Epstein court documents in November. The core premise was simple: fork Gmail's user interface and allow users to browse the released emails through an inbox styled as if they were Jeffrey Epstein.
The initial proof-of-concept rapidly evolved into a full satirical mock software suite, expanding into JDrive, JFlights, JAmazon, and JPhotos. By February, the JMail ecosystem had logged over 450 million visits and served 18 million unique visitors. Reducto handled the parsing layer beneath the entire public archive, processing a corpus of more than three million pages. This collection was plagued by uneven scanning conditions, heavy government marker redactions, dense official forms, complex tabular accounting sheets, and varied, semi-legible handwriting across hundreds of authors.
---
[03:14](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=194s) The Extraction Bottleneck and Layout Challenges
Omar Alhait, a founding engineer at Reducto who collaborated directly with the JMail engineering team during the November document dump, takes over the technical deep-dive. He recalls working downstairs alongside Luke Farritor, the founder of Kino, brainstorming ways to plug Reducto into a major cultural and historical news event. While the frontend concept of an Epstein-themed email client was funny and engaging, delivering it required overcoming severe data processing hurdles.
To illustrate the technical challenge, Alhait displays a raw government filing cover sheet filled with misaligned boxes, inconsistent margins, and handwritten margin notes. He points out that standard large language models fail unpredictably when fed documents with ambiguous spatial arrangements. As Omar Alhait explains: “The reading order of this is also somewhat subjective, right? And so we needed something to basically solve this bottleneck so that we could work on all of these cool little, you know, products downstream.”
---
[05:27](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=327s) JFlights: Extracting Handwritten Flight Records
Alhait switches to a live demonstration of JFlights, a specialized spin-off interface that catalogs the complete private aviation history of Epstein and his associates, tracking flights carrying diplomats, high-profile figures, and private guests between various destinations and his private island. The primary source material for this product consisted of heavily degraded, handwritten aircraft logbooks, which proved significantly harder to parse than typed court filings.
```mermaid flowchart TD accTitle: JFlights Data Pipeline Architecture accDescr: Pipeline moving from raw handwritten aviation logs through Reducto configuration to end user applications.
subgraph Extraction ["Extraction Pipeline"] A["Handwritten Aviation Logs"] --> B["Reducto Parse Stage"] B --> C["Flight Extraction Schema"] C --> D["Validated Flight Entities"] end
subgraph Applications ["Downstream Products"] D --> E["JFlights"] D --> F["JCal"] D --> G["JMail Client"] end ```
Alhait walks through the extraction pipeline configuration he authored when the documents were first unsealed. In the Reducto Studio interface, engineers can drop in a difficult scan, adjust parser parameters, and view the structured output in real time. This immediate feedback loop allows developers to verify extraction quality on edge cases—such as logs mentioning public figures like Woody Allen or lines obscured by physical marker redactions—before executing the pipeline across millions of pages.
- Alhait recalls running huge bulk extractions overnight, frequently triggering infrastructure alerts for fellow engineer Alvin, who was on call during the initial drop: “Alvin was sending me a lot of fun messages late at night like, 'Hey, bro, can you slow down?'” - The normalized data extracted from these logbooks was subsequently reused across complementary interfaces, including JCal (a calendar representation of scheduled appointments) and Gemini-powered search integrations.
---
[09:07](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=547s) Studio Configuration and Deployment to Production
Alhait demonstrates how the Reducto Studio bridges exploratory prompt-and-schema design with production software engineering. Once an extraction schema is validated against a small sample of representative documents, engineers can deploy it directly from the interface. Reducto compiles the configuration into either a single REST API endpoint or a lightweight programmatic pipeline code snippet that can be pasted into downstream applications.
Alhait highlights the rapid iteration speed of this flow: “So the name of the game here is like stick your documents in this platform and then immediately start, you know, visualizing your data and you could immediately also productionize it afterwards.”
An audience member asks how extraction schemas should be authored and whether Reducto can generate them automatically. Alhait answers affirmatively, using an artistic metaphor to describe the schema's central role in the architecture: “Your extract schema is sort of like the paintbrush on your Reducto canvas, right? So, it definitely drives everything that you, you know, you get out of the schema.” He begins demonstrating the schema generation tooling by setting up a fresh extraction pipeline to parse applicant resumes, walking through how the system handles schema definitions directly from document structures.
[11:18](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=678s) Live Resume Extraction and Schema Generation Modes
Omar Alhait resumes the live demonstration in Reducto Studio after generating an extraction schema for resumes. With the schema ready, he notes that it is up to the developer to review whether the generated fields match their actual requirements. He uploads a batch of sample resumes directly into Studio and kicks off the extraction job.
```mermaid flowchart TD accTitle: Reducto Schema Generation Workflow accDescr: Diagram contrasting basic out-of-the-box schema generation with enhanced document-aware schema generation. subgraph BasicFlow["Out-of-the-Box Flow"] P1["User Prompt"] --> LLM["Standard LLM Call"] LLM --> S1["Generic JSON Schema"] end subgraph EnhancedFlow["Enhanced Document-Aware Flow"] DOCS["Raw Documents"] --> PARSE["Reducto Parse"] PARSE --> CONTENT["Parsed Content Analysis"] CONTENT --> TAILOR["Enhanced Generation"] TAILOR --> S2["Nuanced Tailored Schema"] end S1 -.-> EXTRACT["Downstream Extraction"] S2 -.-> EXTRACT ```
While waiting for the processing models to run, an audience member asks about validation and how schemas are generated. Omar explains that Reducto offers two tiers of schema creation:
- **Standard schema generation**: An out-of-the-box LLM call that immediately writes a JSON schema based strictly on the user's natural language prompt. This is ideal for quickly bootstrapping a pipeline and getting initial values on screen. - **Enhanced schema generation**: A document-aware workflow where Reducto parses sample documents first, inspects their extracted layout and text, and then writes detailed field descriptions tailored directly to the specific nuances found in those files.
Addressing when to use each approach, Omar clarifies: “If you are a lot more interested in like nuance, uh I definitely suggest parsing the documents first and then kind of passing them in.”
---
[13:48](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=828s) Flawed PDF Redactions and Metadata Leaks
An audience member asks about how Reducto handled redactions in the Epstein files. Omar explains that Reducto extracts underlying PDF metadata in addition to running visual models, which exposed severe flaws in how the source files were originally prepared. In several government documents, the party responsible for redactions had simply drawn black rectangular shapes on top of the visual layer without scrubbing the digital text beneath them.
Because Reducto's parser extracts text directly from underlying streams and metadata, it uncovered the exact names and details hiding beneath the visible black boxes. This put unexpected legal and ethical pressure on the JMail team, who had to manually ensure that personally identifiable information intended for suppression was not exposed to the public. As Omar warns:
> “Because you can't just stick a box on a PDF and then expect it to actually be fully redacted, right?”
He reflects on the intense burden this created during development: “And so yeah, there was a you know a a heavy kind of level of responsibility on our shoulders to make sure that whatever was intended to be redacted was actually redacted. Our our our tool was working a little too well.”
---
[15:34](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=934s) Schema Nesting Depth and Post-Processing Citations
The Q&A shifts to schema complexity and entity resolution. Asked how many fields a schema can support, Omar recalls reviewing a customer schema with 156 distinct fields requesting disparate pieces of information. He notes that Reducto easily accommodates schemas with four to five layers of nested objects, inviting users to push the system's structural limits.
When asked about entity resolution, Omar explains that while he is abstracted from the core ML research team, Reducto runs extensive post-processing routines after extraction. One major capability is their citation model, which traces every extracted value back to its exact coordinate and text provenance in the original source document. Omar mentions recent industry research from NVIDIA on accelerating provenance determination (referencing work similar to "Find Everything") and jokes, “If you're interested about these things, we are hiring and so uh come speak to us after.”
---
[17:41](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1061s) Figure Extraction and Hybrid OCR Prioritization
Omar navigates back to Studio to demonstrate figure extraction, adjusting his settings to enable figure returns on the resume dataset. An audience question prompts Omar to consult his teammate Alvin, who built Reducto’s hybrid OCR model.
Omar explains that choosing between raw PDF metadata and computer vision OCR is one of the most complex challenges in document processing:
- Digital PDFs frequently contain corrupted, hidden, or overlapping metadata text layers that do not match the visual page. - Scanned elements or embedded screenshots require visual optical character recognition. - Reducto’s hybrid OCR configuration intelligently predicts whether to prioritize the programmatic text stream or the visual OCR result for each document region.
Omar highlights that balancing these inputs is an intricate engineering effort that could easily fill an entire dedicated presentation.
---
[19:23](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1163s) Parsing as the Bedrock for Downstream Extraction
Omar emphasizes that document extraction is entirely dependent on the quality of the initial parse. In Reducto's architecture, extraction pipelines do not run on raw, unformatted file bytes; they consume structured, layout-aware parse representations.
```mermaid flowchart LR accTitle: Reducto Foundation Architecture accDescr: Pipeline showing parsing as the foundation feeding downstream agentic tasks. A["Raw Document (PDF/Scan)"] --> B["Reducto Parse\n(Reading Order, Layout, Tables)"] subgraph AgenticTasks["Downstream Agentic Layer"] B --> C["Region Splitting\n(Chapters/Sections)"] B --> D["Structured Field\nExtraction"] B --> E["Summarization &\nCitations"] end ```
By establishing clean reading order, table boundaries, and semantic chunks during the parse stage, downstream workflows can split complex documents into logical sub-regions—such as splitting a mathematics textbook chapter by chapter—and execute targeted extractions or summaries on individual segments. Omar sums up their foundational approach:
> “So like parse is kind of like the um, you know, it it is it is what made Reducto Reducto in the first place, right? And then we can do a lot of cool things, you know, downstream of Reducto.”
---
[20:43](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1243s) Training for "All the Needles in a Haystack" and Evaluation Realities
When an audience member asks proprietary questions about their training dataset and methodology, Omar jokes, “Man, if I answer that question, I might lose my job tomorrow.” He and Palak Agarwal explain that training targets areas where off-the-shelf models struggle, such as long-context recall. Palak points out that unlike typical retrieval benchmarks that search for a single key, structured document extraction requires gathering every relevant token across long, dense layouts:
> “Specifically for extract um it's it's not really like needle in a haystack. It's like all the needles in a haystack if you think about it.”
Turning to the question of benchmarks, Omar shares that Reducto plans to publish public benchmarks to provide objective industry data points rather than forcing teams to run whole datasets like ARC-AGI just to compare tools. However, Palak offers a candid piece of advice on how evaluation actually works in production:
> “Yeah. So we're going to release some benchmarks soon. But the real deeper answer here is you typically have to make your own benchmarks unfortunately.”
Every serious enterprise customer evaluating document processing vendors inevitably has to build and run an in-house evaluation dataset reflecting their own documents' unique artifacts and formatting quirks.
[22:50](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1370s) Benchmarks and Practical Evaluation
Evaluating document parsing pipelines often comes down to direct head-to-head comparisons against alternative tools. Palak Agarwal explains that when prospective customers benchmark Reducto against other solutions, suboptimal performance usually boils down to running default or improper configurations rather than a deficiency in the engine itself. Reducto actively assists users during these bake-offs, advising them on which flags and settings to toggle to achieve the desired balance between cost, speed, and accuracy. Once configured properly, Reducto consistently wins these evaluations on raw extraction performance.
Agarwal advises engineers against building elaborate, over-engineered benchmarking suites right out of the gate. The recommended workflow is to start lean: assemble a minimal dataset, inspect parsing results visually inside Reducto Studio, and perform a quick vibe-based sanity check. Only after confirming that the basic layout and text blocks make sense should teams invest the effort into scaling up to 100 or 1,000 documents for systematic, programmatic evaluation. Reducto's internal team also works directly with enterprise clients to help craft these larger evaluation pipelines.
“So as with most projects you know gather a simple data set you can do some like vibe eval just look look in studio see if the outputs make sense and then like as you want to scale it out then get like 100 documents a thousand documents do something more systematic and you can also work with our team where we have a lot of people to you know work with customers to help you do your emails but yeah.” — Palak Agarwal
```mermaid flowchart TD accTitle: Recommended Document Evaluation Workflow accDescr: Step-by-step pipeline starting from small visual inspection in Reducto Studio up to systematic enterprise-scale benchmarking.
subgraph Phase1["Phase 1: Initial Exploration"] A["Small Sample Dataset"] --> B["Reducto Studio Inspection\n('Vibe Eval')"] end
subgraph Phase2["Phase 2: Configuration & Tuning"] B --> C["Tune Flags & Trade-offs\n(Speed vs. Accuracy)"] end
subgraph Phase3["Phase 3: Systematic Scaling"] C --> D["Scale to 100–1,000+ Docs"] D --> E["Systematic Benchmarking &\nHead-to-Head Tests"] end ```
[23:44](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1424s) Product Design and Training Data
Omar Alhait reflects candidly on the origins of JMail and the challenge of making parsed data engaging. His initial proof-of-concept was an uninspired retrieval-augmented generation (RAG) chatbot where users could ask questions about the Epstein document dumps. While theoretically useful for investigative reporters, Alhait realized that an open chat box lacked intuitive appeal for everyday exploration. Instead, wrapping the extracted data in an interface modeled directly on Gmail unlocked immense virality: users already know how to browse inboxes, open message threads, and search sender names. Alhait describes this pairing of consumer-grade UX with robust parsing as an unbeatable combination.
Palak Agarwal reinforces this dynamic by sharing her personal reaction to the release of the unredacted Epstein files. Faced with three million scanned, chaotic pages, the prospect of manual reading was utterly daunting. Yet the moment Alhait published JMail, she found herself spending hours casually querying the inbox for names of famous public figures. Agarwal stresses that unstructured documents are ubiquitous across enterprise back-offices, and the core value proposition of modern AI tooling is extracting that locked information into formats people and systems can actually consume.
When asked about building the proprietary extraction models that power Reducto, Alhait emphasizes that there are no shortcuts around human-supervised data preparation. Training specialized document models requires a dedicated data-labeling team systematically sifting through mountains of varied paperwork, classifying bounding boxes, and validating data sanctity. While Alhait acknowledges this classification work is tedious, repetitive, and unglamorous, it is the foundational bedrock upon which state-of-the-art vision and layout models compound.
“It's it's testament to the fact that a nice product on top of a really really nice novel, you know, uh document extraction solution is what is going to kind of be a onetwo punch here.” — Omar Alhait
“At the end of day, at the end of the day, you still have to label that data.” — Omar Alhait
- **The Product Lesson of JMail**: An open-ended RAG chat interface felt utilitarian and dry; packaging millions of parsed legal records inside a familiar webmail UI transformed a difficult data dump into an addictive consumer product. - **The Reality of Model Training**: High-performance layout and OCR models depend on high-effort, manual data labeling and rigorous curation rather than relying solely on automated synthetic data or off-the-shelf foundation models.
[26:12](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1572s) Tailor Document Configurations
Addressing an audience inquiry regarding how to handle diverse document layouts and specialized metadata rules within a single ingestion pipeline, Omar Alhait outlines Reducto's agentic configuration capabilities. Real-world business documents rarely conform to uniform templates: a single batch may contain corporate filings, invoices, and blueprints, each requiring dedicated extraction logic and custom downstream schemas.
To handle these variations, Reducto provides an agentic module that allows developers to bind specialized models and custom system prompts to specific document profiles. Alhait provides two concrete examples:
1. **Complex Figure and Logo Extraction**: If an organization needs to distinguish between corporate brand marks—such as telling Lincoln Financial apart from Google in incoming paperwork—developers can provide custom prompts that instruct the vision sub-model how to isolate and identify the visual signatures of those specific logos. 2. **Specialized Technical Blueprints**: In domains like construction or architectural engineering where standard left-to-right, top-to-bottom reading orders collapse, engineers can calibrate the layout prompt directly within Reducto's configuration. This guides the parsing agent on how to traverse technical drawings, callout annotations, and diagram keys accurately across entire project portfolios.
“So you can actually apply all of these different, you know, uh, configs and apply like, uh, system prompts on top of separate models that will do specific processing that's tailored directly to what you're asking for.” — Omar Alhait
[27:59](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=1679s) Interactive Exercise Instructions
To close out the workshop, Omar Alhait and Palak Agarwal transition the room into a hands-on building session. With approximately 30 minutes remaining in the scheduled block, attendees are invited to sign up for Reducto Studio and test extraction workflows on their own real-world files or test sets.
Alhait displays a QR code containing sample starter snippets designed to be pasted directly into development environments like Claude Code or Codex for instant execution. Participants are challenged to spend the next 25 minutes building out an extraction concept, an agentic configuration, or a specialized single-shot prompt. Reducto offers company merchandise, swag, and prizes for attendees who present their parsing recipes during the final five minutes of the workshop. Both founders spend the remaining time circulating throughout the room to answer technical questions about Reducto's model architecture, enterprise training strategies, and hiring opportunities.
“So we're going to give you guys about 30 minutes and by you know maybe around like five minutes uh like at the five minute remaining mark we'd love to kind of see what you guys have cook uh cooked up and we have a bunch of cool swag and a couple of cool prizes for you guys uh to just kind of show us what you got um with respect to document extraction.” — Omar Alhait
## Notable quotes > [00:12](https://www.youtube.com/watch?v=HGfsfKaVuGY&t=12s) Everything is powered by our agentic OCR framework where rather than making a single pass and committing to an answer the model flags things that it's uncertain about corrects them and then moves on to the next step. — Palak Agarwal
## Mentioned Reducto, JMail, JFlights, JDrive, JAmazon, JPhotos, JCal, Palak Agarwal, Omar Alhait, Riley Walz, Luke Farritor, Jeffrey Epstein, Kino, Accel, Benchmark, Harvey, Scale AI, NVIDIA, Gemini, Claude Code, Codex, Google, Lincoln Financial, Woody Allen
## Video description Handwritten flight logs and heavily redacted PDFs stand between a pile of documents and a searchable product. Palak Agarwal and Omar Alhait show how Reducto turned the Epstein files into structured data for JMail and its related applications. Agarwal introduces the document processing layer; Alhait walks through the extraction pipeline behind JFlights, showing how a schema turns difficult pages into usable records. The workflow starts with parsing, tests extraction results in Studio, and exposes the configured pipeline through an API call or code snippet. The product demonstration makes the bottleneck visible: reading order, handwriting, layout, and inconsistent documents need to survive extraction before an interface can make them useful.
A live resume example shows how to generate a JSON schema, upload documents, and inspect the resulting fields. The discussion distinguishes a quick schema from one informed by parsed document content, then explores nested fields, citations, figures, and the choice between OCR and PDF metadata. Alhait also describes why drawing a black box over text can leave information exposed, and how the team handled material intended to remain redacted. Questions move from model training and document specific configurations to practical evaluation: inspect a small sample first, then build a representative benchmark before scaling. The recording ends with instructions for an interactive extraction exercise, connecting the JMail case study to participants' own document workflows.
Speaker info: - https://palakagarwal.me/ - https://www.linkedin.com/in/palak06/ - https://www.linkedin.com/in/oalhait - https://github.com/oalhait - https://docs.reducto.ai/overview
Timestamps: 0:00 - Document processing and Reducto 2:02 - The JMail case study 3:10 - Omar on the parsing challenge 5:27 - JFlights and handwritten logs 6:35 - Configure and inspect extraction 7:41 - Scaling the document pipeline 9:07 - Deploy an API pipeline 10:14 - Generate a resume schema 12:38 - Schemas informed by document content 13:48 - Redaction and PDF metadata 15:34 - Nested schemas and citations 17:41 - Figures and hybrid OCR 19:23 - Parsing as the foundation 21:30 - Benchmarks and practical evaluation 23:44 - Product design and training data 26:12 - Tailor document configurations 27:59 - Interactive exercise instructions
---
Watch along with the corrected transcript, summary, timestamps and resources on this talk's official AIE page: https://ai.engineer/talks/HGfsfKaVuGY-youtube-79b0f112f4cbb4109538
Join our upcoming AI Engineer conferences (see https://ai.engineer landing page):
- AIEi Shanghai, November 5–6 — the first for meeting top Chinese labs and engineers - AIE CODE in SF, November 10–12 — the top AI Coding conference returns - AIEi Sydney, December 7–8 — the first AIEi run alongside NeurIPS 2026 in Sydney
---
[Source](https://www.youtube.com/watch?v=HGfsfKaVuGY)