Insurance policies and contracts
Coverage limits, exclusions and the clause types whose absence matters as much as their text.
A policy and a commercial contract are not documents in the sense that an invoice is a document. They are assemblies. The operative text of an insurance policy is a printed base form, amended by a stack of endorsements listed by number on a page that does not contain them; the operative text of an agreement is a body, amended by exhibits, statements of work and side letters that may or may not take precedence over it. Extracting a field means resolving that assembly, not reading a page.
Which is why the interesting output of an extraction over these documents is often a negative. A schedule that names an endorsement the file does not contain, a claims-made policy with no retroactive date, an indemnity with no cap, an agreement with no order-of-precedence clause — each is a fact about the document that no field-by-field reading produces. These pages are about getting the fields out and about knowing, arithmetically or structurally, when what you got out is wrong. They are about parsing. What any of it means for a particular matter is a question for somebody qualified to answer it.
Extracting Claim Numbers and Dates of Loss From an Insurance Claim Form
How to pull the identifiers and the date of loss off a first notice of loss when four different numbers on the page look identical and none of them has a check digit.
10 min read
Extracting Coverage Limits and Deductibles From an Insurance Policy
Why a limit is printed in two places that can disagree, and how deductible, sub-limit, retention and coinsurance differ as arithmetic.
11 min read
Extracting Exclusions From an Insurance Policy Document
Exclusions arrive by endorsement number rather than inline, so extraction is a reference-chain resolution and a missing endorsement is itself the finding.
11 min read
Extracting an Explanation of Benefits Into Structured Fields
A per-line schema for billed, allowed, paid and patient responsibility, with the arithmetic that must reconcile and the cases where it legitimately will not.
11 min read
Extracting Renewal and Effective Dates From an Insurance Policy
Five dates print within an inch of each other on a declarations page, the policy period does not start at midnight, and one of them may not be there at all.
10 min read
Extracting Governing Law and Jurisdiction Clauses From a Contract
Three different clauses live in one section and answer three different questions, and the wording that separates them is narrower than it looks.
10 min read
Extracting Termination Clauses From a Contract
For cause and for convenience are different rights with different notice, and the cure period is the number most often extracted into the wrong field.
10 min read
Extracting Indemnification Language From a Contract
The indemnity clause does not contain its own cap, the parties are usually defined terms rather than names, and the duty to defend is a separate obligation.
11 min read
Extracting Payment Terms From a Services Contract
The clause states the mechanics and an exhibit states the amounts, they can contradict each other, and an order-of-precedence clause decides which wins.
10 min read
Extracting Auto-Renewal Terms From a Contract
How to turn an evergreen clause into a cancel-by date, and why the same clause yields two different deadlines depending on how the term end is read.
9 min read
Extracting Non-Compete Terms From an Employment Agreement
Why a restrictive covenants section is a list of covenants with different durations rather than one field, and how to split scope, duration and geography without inventing precision.
9 min read
Extracting Confidentiality Obligations From an NDA
How to tell a mutual NDA from a one-way NDA by clause structure rather than by title, and which sub-fields the obligation actually decomposes into.
10 min read
Extracting the Term and Survival Period From an NDA
Why one NDA contains two unrelated durations, how the three common survival architectures produce different last-obligation dates, and when that date is not computable at all.
9 min read
Extracting Parties and Signature Dates From an NDA
Why party names appear two or three times in one NDA and disagree, and how to pick an effective date when the preamble is blank and two signatures carry different dates.
9 min read
Extracting Rent Escalation Schedules From a Lease
How to turn a mixed flat, percentage and CPI escalation clause into a year-by-year rent table, and why compounding and the anniversary date change the answer.
10 min read
Extracting Square Footage and Premises Description From a Lease
Why one suite has two correct square footage numbers, how the load factor relates them, and what conflating them does to a per-square-foot rent.
8 min read
Extracting Option-to-Renew Terms From a Commercial Lease
How to derive the exercise window from a commencement date, why an option has two deadlines rather than one, and what conditions precedent do to the extracted record.
9 min read
Extracting Security Deposit Terms From a Residential Lease
Why a deposit stated as a multiple of rent is not a number, what fields the holding and return terms decompose into, and why jurisdiction has to be an extracted field.
9 min read
Other topics
- LLM fundamentals & architecture
- Tokens, tokenization & context windows
- Prompt engineering
- Reasoning models & test-time compute
- Multimodal AI: vision, audio, video
- RAG & retrieval
- Embeddings & vector search
- AI agents & tool use
- Structured output & function calling
- Fine-tuning & post-training
- Local inference errors, string by string
- Running local models day to day
- Testing code that calls an LLM
- Snapshot and property testing for model output
- Regression suites for prompts
- Eval gates in CI
- Flaky tests against a model
- Determinism and the cost of testing
- Contract and streaming tests
- Testing tool calls and retrieval
- Inference, serving & latency
- Rolling out a prompt change
- Testing AI systems in practice
- Forecasting a time series
- Machine learning on tabular data
- Geospatial data and models
- Understanding audio that is not speech
- Understanding video
- Core computer vision tasks
- Machine learning on graphs
- Point clouds and 3D
- Evaluation, benchmarks & LLM-as-judge
- Sensor and IoT data
- Logs and event streams
- Models over biological sequences
- Machine learning on molecules
- Embedding and searching code
- Extracting invoices and purchase orders
- Receipts, statements and tax forms
- Deeds, court filings and patents
- Extracting from medical records
- Observability & LLMOps
- CVs, certificates and identity documents
- Shipping, customs and technical documents
- Meetings, email, chat and filled-in forms
- Building an extraction pipeline
- Business, property and inspection documents
- Contract clauses and insurance claims
- Regulated and compliance documents
- Consumer, travel and closing documents
- Mapping one chat API onto another
- SDK and framework migrations
- Hallucination & failure modes
- Re-embedding and model deprecation
- Cutting over between providers
- Parity gaps, shims and legacy endpoints
- Moving between model versions
- Migrating vector stores and caches
- Mapping capabilities and parameters
- Migrating pipelines and agents
- Contracts, runbooks and rollback
- Auditing a codebase before a cutover
- Compliance and fine-tune migration
- LLM cost engineering
- Routing, cost tracking and multi-tenancy
- What a migration does to your prompts
- AI security & prompt injection
- Privacy, compliance & data residency
- AI governance, policy & society
- Building reliable AI applications
- AI hardware, GPUs & compute
- Open-weight models & local inference
- AI for developers & coding agents
- AI in industry: vertical playbooks
- AGI, superintelligence, alignment & the long future
- Machine learning foundations
- NLP fundamentals & classical tasks
- Data engineering for AI
- Synthetic data & dataset curation
- AI product design & UX
- Search, ranking & recommendation
- Enterprise adoption & change management
- AI careers, skills & teams
- Reading AI research
- AI in science & discovery
- Robotics & embodied AI
- AI economics, markets & business models
- AI myths, hype & media literacy
- Context engineering
- Shipping AI features: patterns & anti-patterns
- Build it: end-to-end AI tutorials
- Python for AI: hands-on recipes
- TypeScript, React and the web
- Frameworks and SDKs
- Errors and troubleshooting
- AI facts, numbers and statistics
- The history of AI
- The maths behind AI
- Architectures beyond the transformer
- Reinforcement learning
- Diffusion and generative media
- Speech, audio and voice engineering
- Benchmarks, one at a time
- AI search visibility
- Infrastructure and operations
- Databases and storage for AI
- Knowledge graphs and structured knowledge
- Classical ML in production
- Regulation, jurisdiction by jurisdiction
- Prompt recipes and pattern library
- AI for people who do not write code
- Writing, media and creative work
- Edge and on-device AI
- Interpretability and model internals
- Field notes
- OpenAI model behaviour
- Claude model behaviour
- Gemini model behaviour
- Llama model behaviour
- Mistral model behaviour
- Qwen model behaviour
- DeepSeek model behaviour
- Cohere model behaviour
- Grok model behaviour
- Small model behaviour
- Hybrid model architectures
- Token cost by language and script
- Transliteration, romanization and script handling
- Locale-correct output
- Multilingual generation quality
- Multilingual pipelines
- The EU AI Act, article by article
- AI under the GDPR and EU data law
- US AI regulation, state and sector
- International AI governance and standards
- AI litigation and enforcement
- Running AI workloads on AWS
- Running AI workloads on Google Cloud
- Running AI workloads on Azure
- AI at the edge: Workers, Vercel and Netlify
- Serving models on Kubernetes
- Operating AI infrastructure
- Quantization formats and what they cost
- llama.cpp, flag by flag
- Ollama and the desktop local-model runtimes
- Local models on Apple Silicon
- Hardware for local inference
- Running speech and embedding models locally
- Model files, adapters and conversion
- VRAM arithmetic for local models