TL;DR: Jev for 10-K data extraction works best as a fast, calibrated decision layer: pre-extract candidate values with regex or a generative model, then let Jev’s Choice and Noul primitives select the correct field, confirm presence, and score confidence. Teams process sections of Form 10-K filings (revenue recognition notes, risk factors, MD&A) at $0.042 per million input tokens and 70–500 ms latency, routing only low-confidence fields to heavier models or humans. The pattern eliminates parse-retry loops and keeps arithmetic and assembly in deterministic code.

Jev for 10-K data extraction is not another generative model that invents numbers from a financial report. TypeSafe AI’s System One model (released 15 September 2026) accepts unstructured state—chunks of a Form 10-K—and returns typed decisions with calibrated probabilities. You still need a lightweight extractor to surface candidate revenue figures, accounting policies, or risk-factor language; Jev then picks the right candidate, decides whether a required disclosure is present, and tells you how confident it is. This post shows the exact architecture, worked examples from Item 8 notes, and the one place the pattern fails. By the end you will have a production-ready cascade that auto-routes clean extractions and flags only the ambiguous residue.

Table of contents

1. Why Jev for 10-K data extraction beats pure LLM pipelines
2. The correct architecture: candidates first, then Jev
3. Worked example: revenue recognition from Item 8
4. Scoring risk factors and MD&A language
5. Full pipeline with confidence gating
6. Key numbers and cost reality
7. Who this does not apply to
8. FAQ
9. Conclusion

Why Jev for 10-K data extraction beats pure LLM pipelines

Jev for 10-K data extraction turns the expensive “generate then parse and retry” loop into a cheap select-and-gate step. A typical 10-K contains dozens of tables, notes, and narrative blocks. Asking a frontier model to extract every revenue line, every ASC 606 policy phrase, and every material risk produces variable JSON, occasional hallucinations, and repeated validation cycles. Jev never generates free text; it only chooses among options you supply and returns a probability distribution plus confidence.

Public companies file Form 10-K under SEC rules that still require the familiar Item structure (Business, Risk Factors, MD&A, Financial Statements). Large accelerated filers must file within 60 days of fiscal year-end; accelerated filers have 75 days; all others have 90 days. Those deadlines create predictable seasonal volume that rewards low-latency, low-cost decision layers. SEC Investor.gov guide to reading a 10-K.

Key takeaway: Jev does not replace the extractor; it replaces the unreliable post-processing and routing layer.

The correct architecture: candidates first, then Jev

The single most important rule for structured extraction with Jev is simple: never ask it to invent a value. Ask it to pick from candidates you already found.

1. Chunk the 10-K (by Item or by note) and run a fast candidate generator—regex, table parser, or a small generative model.
2. Pass the raw text (or the candidate list) as state and a set of Choice / Noul / Score questions.
3. Jev evaluates every question in parallel and returns typed answers with probabilities.
4. Code owns arithmetic, date assembly, currency normalization, and final validation.

TypeSafe’s own cookbooks and the community extraction pattern both emphasize this cascade. A generative model is good at proposing plausible numbers; Jev is good at selecting the right one and refusing to guess when the field is missing. TypeSafe Models documentation.

Key takeaway: candidates → Choice/Noul → deterministic code.

Worked example: revenue recognition from Item 8

Item 8 of a 10-K contains the audited financial statements and the accompanying notes. Revenue-recognition language under ASC 606 is usually concentrated in a single note. Suppose a pre-processor has already extracted three candidate policy paragraphs and three candidate total-revenue figures from the consolidated statements.

State (simplified):

{
  "note_text": "Revenue is recognized when control of the promised goods is transferred... five-step process under ASC 606...",
  "candidates_revenue": ["$10,140 million", "$9,631 million", "$8,722 million"],
  "candidates_policy": ["paragraph_A", "paragraph_B", "paragraph_C"]
}

Questions sent to Jev in one call:

• revenue_2025 (Choice): Which candidate is total Merchant Solutions revenue for the year ended 31 December 2025?
• policy_is_asc606 (Noul): Does the supplied note describe the five-step ASC 606 model?
• control_transfer (Noul): Does the policy state that revenue is recognized upon transfer of control?
• confidence_needed (Score 0–2): How complete is the disclosure relative to typical large-accelerated-filer notes?

Jev returns the selected revenue figure, two high-probability Noul scores, and a calibrated confidence. Code then stores the number, flags any Noul below 0.85 for human review, and never has to parse free-form JSON. Real 10-K notes follow exactly this five-step language; see recent EDGAR filings for the pattern. Example revenue-recognition note on EDGAR.

Key takeaway: one parallel request replaces multiple generative calls and validation retries.

Scoring risk factors and MD&A language

Item 1A (Risk Factors) and Item 7 (MD&A) are narrative-heavy. Jev excels at classification and severity scoring rather than free-text summarization.

Typical questions:

• Choice: Which category best describes this risk paragraph? (liquidity / litigation / cybersecurity / supply-chain / regulatory / other / not_stated)
• Score: Severity of the described risk on a 0–4 rubric (none → material and unresolved)
• Noul: Does the paragraph contain forward-looking language that requires safe-harbor consideration?
• Noul: Is a quantitative impact disclosed?

Because every question is evaluated independently against the same state, you obtain a full probability distribution for each risk factor in a single 100–300 ms call. Downstream code can rank risks by severity × confidence and surface only those above a threshold for the investment committee or the audit committee package.

Key takeaway: treat risk-factor extraction as multi-label classification plus severity scoring, not generation.

Full pipeline with confidence gating

A production cascade for 10-K processing looks like this:

1. Ingest the EDGAR HTML or iXBRL filing and split by Item / note.
2. Run a cheap candidate extractor (regex + table parser + optional small LLM).
3. Batch every field as a Jev question set; keep state under the 32 k token budget for the longest question.
4. Gate on confidence:
   • confidence ≥ 0.90 and Noul ≥ 0.85 → auto-store
   • 0.70–0.90 → second-stage generative model or senior analyst
   • < 0.70 → human review queue
5. Log every probability for later calibration monitoring.

The same pattern appears in TypeSafe’s invoice-processing workflow and in community extraction cookbooks. Arithmetic (year-over-year change, margin calculation, ratio analysis) stays in code; Jev never attempts it.

Key takeaway: confidence thresholds turn probabilistic outputs into deterministic routing rules.

Key numbers and cost reality

Current Jev 1.13 economics (as of 18 September 2026):

• Input price: $0.042 per million tokens ($42 per billion)
• Output: free
• Latency: 70–500 ms end-to-end
• Context: 64 k tokens total; 32 k for state + longest question
• Rate limits: 250 000 tokens per second / 1 200 requests per minute (dynamic under load)

A 50-page 10-K chunked into 40 state blocks of ~1 500 tokens each, with eight questions per block, costs a few cents and finishes in seconds rather than minutes. That is the practical difference when hundreds of filings arrive in the same two-week window after fiscal year-end.

Key takeaway: label: value (source, date)
Input price: $0.042 / MTok (TypeSafe Models docs, 18 Sep 2026)
Typical latency: 70–500 ms (TypeSafe announcement, 15 Sep 2026)
Large-accelerated 10-K deadline: 60 days after fiscal year-end (SEC rules)

Who this does not apply to

Teams that need free-form narrative summaries, full MD&A rewriting, or open-ended question answering over the entire filing should keep a generative model in the loop. Jev also cannot yet ingest images or native PDF layouts; text or iXBRL must be supplied. If your extraction volume is a handful of filings per quarter, the engineering cost of the candidate-generation stage may outweigh the savings. Early-access rate limits can still throttle very large concurrent jobs.

Key takeaway: Jev is a decision and verification layer, not a general-purpose 10-K reader.

Conclusion

Jev for 10-K data extraction succeeds when it is treated as a high-speed, calibrated decision engine sitting on top of ordinary candidate generation. The economics ($0.042 per million input tokens, free output, sub-second latency) and the inability to hallucinate outside the supplied schema make it a natural fit for the seasonal flood of annual reports. Keep generation and arithmetic where they belong—outside Jev—and the remaining work becomes a clean, auditable pipeline of typed choices and confidence scores.

Read next

• Is There Still an Accountant Shortage? 2026 Trends & Data — capacity pressure that makes low-cost extraction pipelines more valuable
• TypeSafe AI official System One announcement — primary source for architecture and pricing
• TypeSafe Models documentation — current limits, aliases, and rate information

↑ Back to top