Reducto Parser Exposes Leaked Text Under Epstein Redaction Boxes

Parsing the Epstein Files for JMail — Palak Agarwal & Omar Alhait, Reducto — AI Engineer

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)

Reading summary

At an AI Engineer presentation, Reducto founders Palak Agarwal and Omar Alhait explained how vision-first, agentic document parsing bridges the gap between chaotic real-world files and downstream language models, citing their infrastructure support for the viral JMail Epstein corpus browser. Vision-First Parsing Versus Text Layer Assumptions (0:12) Reducto was designed as an intermediary processing layer upstream of foundation models, built to ingest messy enterprise documents that break conventional digital extractors. Rather than relying on underlying PDF text layers or bounding boxes—which frequently scramble reading order in skewed scans, complex tables, and forms—the platform uses a vision-first rasterization pipeline. Agarwal reported that Reducto raised $108 million from investors including Accel and Benchmark and processed over two billion documents for clients like Harvey and Scale AI. The core engine applies an agentic loop: instead of a single forward pass, the system flags low-confidence readings, recorrects them iteratively, and structures outputs across primitives like Parse, Split, Extract, Edit, and Classify. Stress-Testing Real Files on the Epstein Archive (2:02) The platform's extraction pipeline was stress-tested during the public release of the Jeffrey Epstein court files, when developers Riley Walz and Luke Farritor created JMail. By packaging a corpus of more than three million degraded pages into an interface modeled after Gmail, the JMail ecosystem expanded into JFlights, JDrive, and JPhotos, registering over 450 million visits and 18 million unique visitors by February. Omar Alhait highlighted JFlights, which processed degraded, handwritten aviation logs tracking flights and associates such as Woody Allen. The handwritten and poorly scanned documents required visual extraction tuning in Reducto Studio before outputs could be reliably structured for downstream calendar and search tools. Hybrid OCR and the PDF Redaction Trap (13:48) Alhait cautioned that processing digital files requires balancing raw PDF metadata with computer vision OCR. Digital files often carry corrupted, hidden, or overlapping text streams that do not correspond to the visible page, whereas scans require pure optical character recognition. Reducto implemented a hybrid OCR model to predict dynamically whether programmatic streams or visual OCR should take precedence for each region. This dual-layer approach revealed critical flaws in government filings: several official documents had black marker rectangles drawn over names on the visual layer without sanitizing the underlying digital text. Because Reducto extracted from both the visible layout and digital metadata streams, it surfaced text hiding under black boxes, forcing the team to manually verify that legally sensitive personally identifiable information was not improperly exposed. Schema Authoring, Provenance, and Enterprise Evaluation (9:07) For downstream extraction, Reducto supports both standard prompt-driven JSON schema creation and an enhanced document-aware mode that inspects sample layouts to define nuanced fields. The engine supports schemas with deep nesting—handling customer jobs with over 150 fields across four to five layers—and pairs outputs with citation models linking extracted entities back to exact source coordinates. Alhait and Agarwal emphasized that parsing quality remains the prerequisite for complex retrieval or section splitting. Addressing performance benchmarks, Agarwal advised enterprise developers to avoid prematurely over-engineering benchmark suites, recommending instead that teams start with small sample sets inside Studio before scaling up to 100 or 1,000 custom documents tailored to their organization's proprietary artifacts. Consumer UX and the Realities of Data Labeling (23:44) Reflecting on product design, Alhait noted that an early retrieval-augmented generation (RAG) chatbot failed to capture user interest because open chat prompts are unintuitive for dense document archives. Mapping the same underlying data to a webmail client succeeded because users intuitively grasp how to navigate inboxes and search senders. Despite advances in vision-language models, Alhait stressed that training specialized document models still depends heavily on manual human data labeling. Teams must systematically classify bounding boxes and verify layout sanity across varied paperwork rather than relying exclusively on synthetic generation or generic frontier models. While Reducto plans to release standardized public extraction benchmarks, Agarwal maintained that enterprise teams must ultimately construct in-house evaluation sets to capture their own layout edge cases, emphasizing that high extraction accuracy requires meticulous manual data labeling and tailored parser configurations rather than off-the-shelf defaults.

Source quotes

[0:12] Palak Agarwal: 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.

Original transcript

[0:12] Hi everyone, my name is Ple. I lead [0:15] developer redu relations at Reductto. [0:17] Um, and before we dive into Jmail, I'd [0:20] love to give you a little background on [0:21] what we do. Uh we're an agent document [0:24] platform which basically means we help [0:26] teams turn messy unstructured documents [0:28] into data that AI can actually use [0:30] accurately. Um to give you some context [0:34] in the last three years we've raised 108 [0:37] million from investors like ACCNC [0:39] benchmark and more and processed over [0:41] two billion documents across customers [0:43] like Harvey Scale and a top five global [0:46] hedge fund. Um, and operating at that [0:48] scale means that we've basically dealt [0:50] with every document you can possibly [0:52] think of. Um, and we've iterated [0:54] reductive product to handle anything. [0:58] Um, now getting to AI to work on a clean [1:01] PDF with a frontier model is not that [1:04] hard, but the truth is that most of [1:07] enterprise documents are unstructured. [1:09] That means like scan documents, rotated [1:12] documents, charts. Um, and that's when [1:14] things get really complex. Reductto is [1:16] the layer that sits right before your [1:18] model. Um we handle complex layouts but [1:21] also um as well as post-processing so [1:25] you can focus on building your actual [1:26] product. Um the reason this works is [1:29] that we take a rasterizationbased [1:31] approach that means we look at your [1:33] document like a human would look at the [1:34] document instead of the underlying [1:36] embedding. Um everything is powered by [1:39] our agentic OCR framework where rather [1:41] than making a single pass and committing [1:43] to an answer the model flags things that [1:46] it's uncertain about corrects them and [1:48] then moves on to the next step. Uh we'll [1:50] give you access to our studio. Um we've [1:53] made it self-s served just for this [1:54] session. Uh but in total we have five [1:57] core capabilities. Parse, split, [1:59] extract, edit, and classify. [2:02] Um now a quick show of hands. Who here [2:05] has heard of Jmail or looked through [2:07] Jmail before? [2:09] Okay. Wow, that's a that's a good chunk [2:11] of people. Um, but I'll I'll give a [2:13] quick rundown in case you haven't. So, [2:15] Jmail was originally built by Riley [2:17] Walls and Luke in five hours last [2:20] November. That's when the Epstein files [2:22] were released. Uh, the concept is [2:24] basically Gmail forked and you can log [2:26] into the inbox like your Epstein and [2:29] then that grew into a full suite. So you [2:31] can think of like J drive, JFlight, J, [2:33] Amazon, J photos and so much more. Um by [2:36] February there were over 450 million [2:39] visits and 18 million users that had [2:41] access Jmail. And we're really proud to [2:44] share that Reduct was behind parsing all [2:46] of the documents. And that's not a small [2:48] number. It's over three million pages of [2:50] redacted PDFs, scanned documents, and [2:52] messy government files as well. And to [2:55] give you an idea, like this ranged from [2:57] anything like really complex forms and [2:59] tables to like messy handwriting of like [3:02] so many different people. Um, now I'm [3:05] going to hand it over to Omar, who's one [3:06] of our founding engineers and worked [3:08] very closely with the Jail team back in [3:10] November. Um, and he'll give you a [3:12] technical rundown and more. [3:14] >> Alrighty, who's ready to talk about some [3:17] documents. Yippee. [3:20] All right. So, um, [3:22] yeah. So, uh, walking us back to, you [3:25] know, a very fateful night in November, [3:26] right? Um, I was talking with the [3:29] founding team and we were trying to [3:30] figure out, you know, what would be a [3:32] great way to use Reduct with this kind [3:35] of transformational cultural event that [3:38] was, you know, going to be unveiled to [3:41] the public, right? Um it just so [3:44] happened that um you know we're very [3:46] close to Luke uh who is a founder at [3:49] Kino and is working downstairs and we [3:51] were all just kind of talking about you [3:53] know what would be cool to build what [3:54] would be funny. Haha. Um and then uh it [3:58] kind of snowballed into this idea of [4:00] like what if you could um you know sign [4:03] into your email as if you were Jeffrey [4:05] Epstein and view um you know your email [4:09] as if you were him. And so um you know [4:12] it was a really really cool concept as a [4:14] product but there was one really hard [4:17] problem to solve that you know was [4:19] basically a barrier between us and the [4:21] productized solution. um and you're [4:24] looking at part of it, right? So, [4:27] it's really really like I I would urge [4:29] you if you haven't done this before to [4:32] send this like uh you know uh cover [4:34] sheet to Chad GPT and try to get some [4:38] results out of it that and and just see [4:40] how accurate it is, right? It's a very [4:42] very complex problem where you know [4:44] layouts are um pretty hard to [4:46] understand. The reading order of this is [4:49] also somewhat subjective, right? Um, and [4:52] so we needed something to basically [4:55] solve this bottleneck so that we could [4:57] work on all of these cool uh little, you [5:00] know, products downstream. And so this [5:02] is where Redto came in. So I'm actually [5:04] going to show you guys um what we had [5:07] used for a couple of our products, [5:09] right? So Oh yes, let me do this real [5:13] quick. [5:22] Alrighty. [5:24] Whoops. Gonna bring this over. [5:27] All righty. So, here you see a cool [5:30] product, right? JF flights. Basically, [5:33] all of Jeffrey Abstein and his [5:35] affiliates flight history, right? This [5:37] guy was flying people out. He was flying [5:39] diplomats out. He himself was flying [5:41] many places to and from his island, [5:43] right? Um what was basically the barrier [5:46] between us and finding out finding all [5:48] these flights were these pretty shoddy [5:51] handwritten documents, right? Um again, [5:54] if you were, you know, if you thought [5:55] that cover sheet was a little bit rough, [5:57] think about handwriting, right? So [6:01] we can see here [6:03] a pipeline that I had actually set up [6:05] way back when uh when we were trying to [6:09] build a good config to basically make [6:12] our parsing really really good, right? [6:14] And so in this case uh we had for the [6:17] for the flights use case, you know, an [6:19] idea had flown out that like what if we [6:22] um you know spin this off as a [6:23] completely separate product where you [6:24] could just see all of his flights. Um [6:27] and so what that meant is taking all of [6:29] his flight documentation and then [6:30] applying a separate you know extraction [6:33] config for it. And so what you'll see [6:35] here is um kind of a little tour as to [6:38] how Reduct works, right? So Reduct uh [6:41] within the document extraction use case [6:43] first parses the document, right? And so [6:45] this kind of shows you, you know, you [6:47] could stick any document that you would [6:48] like here and you could just click run, [6:50] right? Configure any of our bells and [6:52] whistles and see real-time results, [6:55] right? So this was sort of the canvas [6:58] for myself that I was playing around [6:59] with to kind of understand before I [7:01] start, you know, scaling this up to a [7:03] million different documents and run up a [7:05] quick check on Reduct's, you know, on [7:07] Reduct's uh um you know, uh receipts, [7:10] let me make sure that our um extraction [7:14] accuracy is what I would expect it to [7:16] be. And so here is kind of what we ended [7:19] up with. Um you could see here for a [7:22] couple of these different documents, you [7:23] know, some redactions that we had to [7:25] deal with. Um Woody Allen, I know that [7:28] guy. Um but yeah, just like a lot of [7:31] different um you know, use cases that we [7:34] had to handle through one extraction [7:36] schema um for the flights use case, [7:39] right? And so we parsed all the [7:41] documents uh very quickly. And actually [7:44] a fun story about this um is Alvin in [7:47] the room? Alvin is in the room. So, um, [7:51] back when the, uh, the, uh, first, uh, [7:54] drop came out, I was paging Alvin maybe [7:57] like, you know, a couple times a night, [7:59] uh, he was, he just happened to be on [8:01] call, uh, the night that I was parsing [8:03] all these documents. And we were trying [8:05] to parse them very, very quickly. And [8:06] so, we put a, you know, a decent amount [8:09] of stress on our infra. And so, Alvin [8:12] was sending me a lot of fun messages [8:13] late at night like, "Hey, bro, can you [8:15] slow down?" Um, but yeah, we got through [8:17] them. We got through them in time. And [8:19] then um once we had this kind of corpus [8:21] of documents that we were able to um you [8:25] know um kind of take as a ground truth, [8:28] we then spun off a a billion different [8:30] products, right? And so Paula kind of [8:32] touched on this a little bit, but I'm [8:35] going to go back to Gmail. [8:40] So, you know, we we spun up any anything [8:42] from Jazm to Jlights to Gemini, right? [8:46] Um yeah. So, and I and also JCAL. This [8:50] was actually a product that I um worked [8:53] on myself. So, some fun stuff there. Um [8:57] cool. And so, I guess you know if you [8:59] could kind of take uh anything out of [9:01] this, [9:02] I do want to say actually [9:07] um yeah, so if you could take anything [9:09] out of this, right, like the simplicity [9:11] from this is really like you know [9:13] getting a schema, right? looking at [9:16] these results, making sure that the [9:17] results look like what I would expect, [9:20] and then just deploying. Right? So, if I [9:22] was to deploy this code snippet, I'll [9:24] just redeploy here for our use case, [9:27] [snorts] [9:28] and I can get either a direct API call [9:30] or just a pipeline code snippet that I [9:33] can invoke very quickly, right? Um so [9:35] the name of name of the game here is [9:37] like stick your documents in this [9:38] platform and then immediately start um [9:41] you know visualizing your data and you [9:44] could immediately also productionize it [9:46] uh afterwards. So I'm going to stop here [9:48] real quick. Um do we want does anybody [9:51] have any questions thus far about um [9:54] Jmail or Reduct in general before we can [9:57] kind of start uh working on a little [10:00] interactive exercise? [10:02] >> Yeah. [10:05] Yeah, [10:11] >> great question. So, we can actually come [10:12] up with this for you, right? Um, you [10:14] know, my uh my fun analogy here is that [10:17] like your extract schema is sort of like [10:19] the paintbrush on your reductto canvas, [10:22] right? So, it definitely drives [10:24] everything that you um you know, you get [10:27] out of the schema. So, for example, [10:29] right, I could create a new pipeline [10:31] here, right? and create a new extract [10:34] pipeline and just call this I don't know [10:38] let me make a resume schema because I [10:40] want to parse some résumés right [10:45] >> oh whoops sorry about that actually I'm [10:47] going to do this real quick [10:51] so anyway I I'll do this again because [10:53] it's very simple [10:56] so I'll create a new extract pipeline [10:58] here by the way we could do a lot of [11:00] things with documents par split extract, [11:02] edit, even classify. Um, and so what I'm [11:06] going to do here is [11:09] create a resume schema. [11:12] Oops. [11:15] Uh, my Wi-Fi is not being helpful with [11:18] me today. There we go. [11:21] >> All righty. [11:23] So, I got a fun schema here. And now [11:24] it's up to me to basically decide [11:26] whether or not this schema is like [11:28] satisfactory or not. Right. it it's [11:30] really given it's going to give me [11:31] exactly what I'm asking for and you know [11:34] once I plug a document in here I might [11:35] realize like ah this is actually not [11:38] what I want right so I have a bunch of [11:41] handy dandy resumes I'm going to stick [11:42] them in here [11:46] upload [11:49] and then [11:51] just run this [11:54] so yeah um I hope that answered your [11:56] question [11:58] any other questions while We wait for [12:00] this. [12:09] >> How do you validate? [12:15] >> You're talking about the loading state. [12:17] Uh that's just like a fun loading state [12:18] at the end of the day, right? Like our [12:20] product is like a really, you know, it's [12:22] a suite of different models uh and [12:23] different VLMs that we deploy, right? Um [12:26] I'm I'm [12:27] >> sorry, it's not the [12:29] I was following what you were saying. [12:34] >> Yeah. [12:38] >> Oh, that's a great question. So, if I'm [12:40] understanding correctly right, what [12:41] you're saying here? [12:44] >> Yeah. Yeah. So, this specific um this [12:47] specific like schema generation that I [12:49] had just used is really out of the box [12:51] and it's just kind of like a a quick LLM [12:53] call that describe like builds a JSON [12:55] schema exactly for what I asked for. [12:57] However, we do have an enhanced schema [13:00] generation, right? And so what this will [13:02] do is let's say I've parsed my [13:03] documents, it will then take the output [13:06] of like what's in the documents and [13:08] tailor a schema description directly for [13:10] them. So like if you're looking for [13:12] example for, you know, something just [13:14] really quick to just get up on the [13:16] screen and just see some results, I [13:18] would recommend regular, you know, uh [13:20] schema generation. But if you are a lot [13:22] more interested in like nuance, uh I [13:25] definitely suggest parsing the documents [13:26] first and then kind of passing them in. [13:29] All you would have to do is just click [13:30] enhance schema generation. And what we [13:32] will be able to do is um you know run [13:34] the documents first, try to get an [13:36] understanding of what's in the in the [13:38] documents so that we can tailor these [13:40] schema descriptions directly for that. [13:43] Make sense? [13:44] >> Cool. Cool. Cool. Cool. [13:48] you had some reduction. [13:51] >> Yeah. [13:54] [clears throat] [13:54] >> Correct. Yes. So I mean yeah like at the [13:57] end of the like this is a great [13:58] question. Right. So reductto actually [14:00] parses PDF metadata as well right. So [14:03] some like sometimes uh and this is [14:06] honestly testament to like uh who was [14:09] doing the redaction, right? Sometimes [14:11] the redaction was actually not that [14:12] great, right? And so what that ended up [14:14] being or the responsibility ended up [14:15] being on us as the JML team to then have [14:18] to do a bunch of redaction, right? [14:21] Because you can't just stick a box on a [14:22] PDF and then expect it to actually be [14:24] fully redacted, right? Um yeah, seems [14:27] like there was some uh a lack of [14:28] understanding when whoever who whoever [14:30] was cooking up that redaction. [14:37] um I will say it's like for the files [14:40] that came out and myself looking through [14:42] them that's not the case right some [14:44] files were actually redacted correctly [14:46] um but there was some files where we [14:48] were just able to see who was like you [14:50] know who the redaction was behind and um [14:54] so it became a really really serious you [14:56] know situation right because we're [14:57] dealing with you know people's data that [14:59] like um you our data is redacted for a [15:03] reason, right? And uh you want to really [15:05] make sure that you're not the one that [15:07] like ends up getting sued at the end of [15:09] the day because of this. Um and so yeah, [15:12] there was a you know a a heavy kind of [15:14] level of responsibility on our shoulders [15:16] to make sure that whatever was intended [15:18] to be redacted was actually redacted. [15:20] Our our our tool was working a little [15:22] too well. [15:24] >> Cool. Yeah. at the front and then I'll [15:26] after you [15:28] >> questions [15:34] or thousands of different things. [15:38] >> Yeah. Yeah. Yeah. Uh it's a great [15:40] question. Um [15:42] I'll give you some like you know an [15:44] example, right? There was there was a [15:46] schema that I was looking at maybe on [15:47] Friday uh that had like 156 fields, [15:50] right? um and all of these different [15:52] fields, you know, need like they were [15:55] requesting something completely [15:56] different, right? Uh and so I urge you [16:00] to kind of put our schema to the test. I [16:02] think like our um the like nesting uh [16:07] limits to our schema or maybe like four [16:09] or five layers. Uh but in if you want [16:11] to, you know, ask for everything in the [16:12] world, you can still technically be able [16:14] to fit it in in a schema. [16:19] >> Do you have any capabil [16:21] resolution [16:23] >> entity resolution. Can you give me an [16:24] example? [16:30] >> So this is a good question. Um there is [16:33] a lot of post proc postprocessing that [16:35] we end up doing, right? Let's say like [16:37] on the extraction side. Um I'm [16:39] personally a little bit farther [16:41] abstracted away from like the ML side of [16:42] things. Uh but I can tell you that we [16:44] are doing a decent amount of [16:45] post-processing to basically link um you [16:48] know entities together. For example, we [16:50] have like a citation model, right? Where [16:52] we know we have, you know, one model [16:54] that could be responsible for [16:56] extraction, right? But then there might [16:58] be another model that's also responsible [16:59] for once this data is extracted, where [17:02] is each piece kind of extracted from, [17:04] right? Uh Nvidia actually did a cool um [17:08] paper on this uh that they that I just [17:10] found out about like yesterday. I think [17:12] it's called like find everything or [17:13] something like that. um where they try [17:15] to address the bottleneck of like you [17:17] know citation uh determination and like [17:20] the speed at which you could find a [17:22] citation for something that's in a [17:24] document. [snorts] If you're interested [17:26] about these things, we are hiring and so [17:29] uh come speak to us after. Sorry. [17:33] >> Questions. [17:41] >> Yeah, absolutely. So, let me try to see [17:45] if one of the résumés I uploaded has an [17:47] image in it. [17:50] >> So, let's see here. Right. So, um we [17:53] have some figure models, right? that are [17:55] basically determining. Let me actually [17:56] also rerun this real quick so that it [17:58] can return figures. [18:18] >> Ah, that's a great question. Um, Alvin, [18:21] did you hear that? [18:22] >> No, no. So, I I'll explain. The reason [18:24] why um I I asked Alvin is because Alvin [18:27] worked on our hybrid OCR model, right? [18:29] Um and so we have a specific OCR uh like [18:32] you know configuration that you can [18:34] enable here that will pri figure out [18:36] kind of intelligently what to [18:38] prioritize, right? Um so in some cases [18:40] we will actually pick out like just you [18:42] know strict OCR data or we might pick [18:45] out like um you know metadata from the [18:47] PDF. Um yeah we've done a lot of work [18:50] here. Uh and it's it's not a simple sol [18:53] like it's not a simple answer. Um this [18:55] is something we could do an entire [18:56] different talk on. [18:59] >> Yeah. [19:23] So I'll be frank with you like this is [19:24] actually exactly what this pipeline is [19:26] doing, right? So like we first parse the [19:29] like the Hold on, let me turn return [19:33] figures. [19:35] Cool. So, um, while I rerun this, what [19:39] we're doing here, let me pick a [19:41] different example. Ah, actually, we're [19:43] gonna have to wait now. But what we're [19:46] actually doing in like extraction is [19:48] taking the parse results and then [19:49] feeding them into, you know, some [19:51] extraction pipeline downstream. So, like [19:54] parse is kind of like the um, you know, [19:57] it it is it is what made reductto [19:59] reductive in the first place, right? And [20:00] then we can do a lot of cool things, you [20:02] know, downstream of reductto. So uh you [20:05] know once we have that parse content for [20:07] example right we could split you know [20:09] the document into different regions and [20:11] figure out like if I'm parsing some you [20:13] know a math textbook I want to [20:15] understand like where exactly every [20:18] chapter you know starts and ends and [20:20] then for each chapter I might want to do [20:21] like an extraction based on that right [20:24] and uh get you know the chapter summary [20:26] or something like that right uh so parse [20:30] is really the kind of foundation for all [20:33] of these other agentic um document [20:36] processing u features. [20:43] >> Man, if I answer that question, I might [20:46] lose my job tomorrow. [laughter] [20:48] >> So, um I mean it's a Yeah, continue. [20:52] >> I think it depends on like what pro data [20:55] we collect um as well. So we [20:58] specifically um train on like certain [21:01] types of data. If we find that it's [21:04] doing poorly on certain types of data. [21:06] So we see that like long context recall [21:08] is not great. Then we got to like try [21:10] and fix that. Specifically for extract [21:12] um it's it's not really like Neil in a [21:15] haststack. It's like all the needles in [21:17] a haststack if you think about it. So [21:19] that's like a really um challenging like [21:21] research problem that our MLES are like [21:24] somehow able to figure out pretty well. [21:26] But yeah, happy to chat more later. [21:30] >> Yeah. [21:31] >> Oh, we've been neglecting you guys. [21:32] Yeah. What's up? You you you'll be Yeah, [21:35] you should you should stay tapped into [21:36] our uh like our our socials and you'll [21:39] find out about this very soon. I think [21:40] like benchmarking is you know always a [21:44] topic of discussion and something that [21:45] we want to really stay on top of [21:47] especially because you know somebody who [21:49] is testing who wants to do document [21:51] extraction might not you know know where [21:54] to go or who's better right without [21:56] actually testing themselves. Uh so [21:58] that's why benchmarking is like [22:00] something that's you know we're we're [22:01] prioritizing a lot uh especially in the [22:03] coming months to to try to show people [22:05] like how well we are doing. you know, we [22:07] try we're we're very confident in our [22:09] models and us being like, you know, the [22:11] premier document extraction solution on [22:13] the market. Uh but there need to be uh [22:16] more, you know, um data points that we [22:19] can rest on and that the, you know, [22:21] entire industry can kind of see at face [22:23] value uh without having to go test [22:25] themselves or pass in the all entire ARC [22:28] AGI data set to you know try to [22:30] understand uh you know how well reducto [22:32] is doing against another solution. [22:34] >> Yeah. So we're going to release some [22:36] benchmarks soon. But the real deeper [22:39] answer here is you typically have to [22:41] make your own benchmarks unfortunately. [22:43] So every single one of our customers [22:45] typically have some benchmark. They're [22:46] like, "Oh, we're evaluating document [22:48] providers. Uh we're going to run some [22:50] head-to-heads uh of like reducto versus [22:52] like all these other like use cases and [22:55] you know sometimes they don't use like [22:56] maybe our APIs really well because they [22:58] use the wrong config. So we work closely [23:00] with them like hey turn this on turn [23:03] this on you get this trade-off and then [23:05] uh we let them decide um and then like [23:08] we often like win these headto-heads in [23:10] like performance. So as with most [23:14] projects you know gather a simple data [23:16] set you can do some like vibe eval just [23:18] look look in studio see if the outputs [23:20] make sense and then like as you want to [23:22] scale it out then get like 100 documents [23:24] a thousand documents do something more [23:25] systematic and you can also work with [23:27] our team where we have a lot of people [23:29] to you know work with customers to help [23:31] you do your emails but yeah [23:34] >> cooly [23:36] um any more questions yeah sure well [23:38] yeah absolutely right um I I think [23:42] so I'll answer this uh pretty honestly [23:44] right I think when I was working on this [23:47] solution right or I was working on this [23:49] problem I was trying to figure out like [23:50] what is a good productized way to you [23:53] know surface our reducts parsing right [23:56] um and to be frank with you right like I [23:59] came up with something that was pretty [24:01] shoddy in the beginning um like [24:03] basically a you know rag chatbot [24:05] application where you can ask anything [24:07] about the emails right and it might be [24:09] something that would be really really [24:10] useful for like a journal journalist, [24:11] right? However, um I think it's [24:14] testament to the hundreds of millions of [24:16] people that you know were, you know, [24:18] using Gmail and and the tens of million [24:20] that still, you know, log on uh from [24:22] week to week nowadays. Um it's it's [24:25] testament to the fact that a nice [24:27] product on top of a really really nice [24:29] novel, you know, uh document extraction [24:31] solution is what is going to kind of be [24:33] a onetwo punch here. [24:35] >> Yeah. Like would you read three million [24:38] like scan documents? Honestly, no. And [24:40] honestly, when I saw the drop, I was [24:42] like, "This is like way too much work [24:43] for me." But once Omar built it, I just [24:45] like logged on and like started [24:47] searching like random like famous people [24:49] for fun. And so that's the beauty of it, [24:51] right? Like I think like unstructured [24:53] data is like everywhere. And sometimes [24:56] all you need to take all you need to do [24:57] is like to extract it and then like do [24:59] whatever you want with it. It's [25:01] basically what all our customers like do [25:04] um conceptually. So I think Gmail is a [25:06] pretty fun example but it's actually [25:08] very u it's exactly what happens in the [25:11] industry. [25:11] >> Yeah. You seen that? Come here. It's [25:15] it's just hard work, right? Like you [25:17] know we we have a data labeling team, [25:19] right? We have to go like par you know [25:21] like we have to sift through a lot of [25:22] documents if we're going to train a new [25:24] model on top of it. Um and be very very [25:26] certain in the outcomes of you know or [25:28] or the the sanctity of that data, right? [25:31] Um and so the short answer for you is [25:33] just [snorts] like it's a lot of hard [25:35] menial annoying work, right? Uh but [25:38] that's really what comes into like the [25:40] beauty of a machine learning model at [25:41] the end of the day, right? There's [25:43] nothing that you know really beats that [25:45] like really really hard, you know, just [25:47] wrote classification work uh that then [25:50] compounds into uh model training and [25:53] then you know then you can kind of [25:54] figure out like how to stagger your data [25:56] and like how to train you know on on top [25:57] of your training set. [25:59] At the end of day, at the end of the [26:00] day, you still have to label that data. [26:03] >> Cool. I think we'll take Yeah, we could [26:06] take one more, but um Yeah. Yeah. So, to [26:09] repeat the question uh and let me know, [26:10] you know, how how accurate it was, [26:12] right? But, uh it seems like, you know, [26:14] like there are cases in which uh you [26:17] need to really customize your logic on [26:19] top of different documents. Uh whether [26:21] it be corresponding to specific models, [26:23] right? Sometimes there might be metadata [26:25] set up in specific ways um in specific [26:28] documents and you want to really like uh [26:30] condition um for these specific use [26:33] cases, right? Um this is a fantastic [26:36] question, right? And so this is where [26:38] our agentic um section really comes in, [26:41] right? So you can actually apply all of [26:43] these different, you know, uh, configs [26:46] and apply like, uh, system prompts on [26:48] top of separate models that will do [26:51] specific processing that's tailored [26:53] directly to what you're asking for. So [26:55] for example, right, if uh you want to do [26:58] some complex figure extraction, let's [27:00] say I have a bunch of logos and I want [27:02] to try to determine like you know what [27:04] differentiates like I don't know uh some [27:07] you know uh Lincoln Financial from like [27:10] Google and like how to separate those [27:12] kinds of logos, right? I could add some [27:14] additional color here within our uh you [27:17] know prompts uh in this config to custom [27:21] kind of tailor u the outputs that I'm [27:23] looking for. So if you wanted some [27:25] specific metadata here, let's say like [27:28] uh you know some layout might be like [27:30] really really hard to read in uh I don't [27:32] know like a construction blueprint, [27:34] right? I would spend a lot of time in [27:36] the uh layout prompt kind of tailoring [27:38] to try to understand uh how well you [27:41] know uh my current extraction solution [27:43] is mapping across all of my different um [27:46] you know construction blueprints I guess [27:48] right cool. Um does that answer your [27:51] question? Fantastic. All right. So now [27:54] we want to kind of um spin this off [27:59] um into an interactive exercise. Right. [28:02] So, um, if you guys would like, we're [28:05] going to basically give you guys, you [28:08] know, um, however much time you would [28:09] like. I think we have about 30 minutes [28:10] left. Um, and you could sign up today [28:13] at, uh, at studio and essentially, uh, [28:17] just get started, uh, on some document [28:19] extraction solution, right? So, what [28:20] what you'll see here in a QR code is [28:22] something that you could basically paste [28:24] directly into a cloud code or a codeex [28:26] or whatever, and something you could [28:27] just get started uh, on uh, document [28:30] extraction with immediately. Uh so we're [28:32] going to give you guys about 30 minutes [28:34] and by you know maybe around like five [28:36] minutes uh like at the five minute [28:38] remaining mark we'd love to kind of see [28:39] what you guys have cook uh cooked up and [28:42] we have a bunch of cool swag and a [28:43] couple of cool prizes for you guys uh to [28:45] just kind of show us what you got um [28:47] with respect to document extraction. Um [28:49] it could totally be just like an idea um [28:51] and like a singleshot prompt but uh feel [28:54] free to just kind of uh give it a whirl. [28:57] >> Sound good? Also, we'll be kind of like [28:59] circling around if you guys have any [29:00] questions as to how to use Redto. Uh, I [29:03] want to come work for you guys, you [29:04] know, I want to hear about your models, [29:06] how you guys train, whatever. Um, we are [29:08] happy to answer. Sound good? [29:26] >> [music]