Insurance is a context problem.

This is the first of a three-part series on how we're building Cooper, an AI coworker for insurance. Part one argues that the models are already smart enough, and that the actual bottleneck is something most agent builders are underestimating. Part two is about our AI agent that does insurance work all day but contains no insurance knowledge, and the five subsystems inside it that are each a billion-dollar company somewhere else, all built by a team of just eight engineers. The last one is about an AI agent that remembers how each organization works and proposes its own improvements from what it sees in production, and gets its pull requests rejected like everyone else.

Insurance runs on people, not software. That might sound surprising or even wrong, because if you walk into any insurance office you'll find plenty of software: a system of record, a pricing tool, a dozen partner portals, email, and, of course, Microsoft Excel holding the whole thing together. The industry spends billions on all of it. But if you watch a single piece of work move from an inbox to a decision, what you actually see is a person carrying it the whole way, reading a pile of PDFs, retyping the same facts into a form, chasing a number somebody never sent, and copying whatever one system produced into the next system's boxes. The software keeps the records but the people are doing all the work.

The software keeps the records but the people are doing all the work.

None of this is because people in insurance have been stubborn. When a shop gets busy it hires more people, because a person is the only "technology" the industry has ever had that's flexible enough for the job. You can tell them things and they do them, absorb exceptions, and learn how your shop actually runs within a few weeks of their first day. Software wants the opposite from you: learn its screens, configure its workflows, migrate your data, change how you work, and after months of that it still might not fit. A new hire just asks where to sit. Every client, every carrier, and every office does things a little differently, so hiring people was the correct engineering decision, and the industry kept making it, year after year, while the rest of the economy bought software.

But all of that has just changed, almost suddenly even, because software has stopped looking like software now. There's no screen to learn and no workflow to set up. You tell it things, you hand it documents, you forward it an email, and it goes and does the work, pretty much the way you'd ask a coworker to. For the first time in this industry's history the flexible option is a piece of software, and I suspect insurance is just one of the first few places where that will be obvious.

Software has stopped looking like software now.

Intelligence isn't the constraint anymore

One might think this is possible now because AI models finally got smart enough, but we don't think that's all that was needed. Frontier models crossed the threshold that matters a while ago. Put the right documents in the context window and ask a precise question, something like whether a particular shipment is covered under the exact wording of a policy, or which of these medical bills has no doctor's note behind it, and the model will basically get it right. Our estimate is that today's models are intelligent enough for more than 90% of the tasks this industry runs on, and that number keeps climbing. Intelligence isn't the constraint anymore, and the labs can fight over the extra 2%, that is not our game.

Where the context actually lives

The constraint is context. It takes an insane amount of knowledge to do this work properly, and almost none of it sits anywhere a model can see. Some of it is in a broker's head, some is in an underwriter's sense of what they'd actually be willing to take on, some is in the way one office lays out its proposals, some is in the unwritten rules of an insurance carrier, and a surprising amount is in the fourth tab of a spreadsheet, or in a blurry PDF somebody scanned sideways in 2019 that everyone uses as reference in the office. Ask a veteran how they knew that this particular state needed an extra form stapled behind the application, and you'll get a shrug, because they didn't look it up anywhere. They just knew.

That shrug is the real problem, and it's the part I think most people building agents are underestimating. People can't hand over their context because they don't even experience it as context. Pulling a fact out of your own head is free, so nobody keeps an inventory of what they know, and nobody can tell you ahead of time which detail is going to matter. Then there's the context that isn't in anyone's head, scattered across systems that don't talk to each other and documents nobody wants to read twice. Cooper reads roughly 6,000 documents a week for its customers, and many individual files run past 4,000 pages, which is more than what any context window is going to hold coherently, and very little of the reasoning inside them is actually hard. The hard part, in this example, is retrieval. In the broadest sense of the word: finding the right half-page and putting it in front of the model at the right moment.

People can't hand over their context because they don't even experience it as context.

A model that's missing context doesn't fail in a way you can catch, either. It answers anyway, and the answer comes back fluent and reasonable and wrong: a quote that skipped an exclusion, a timeline that missed the one bill with no note behind it, and nothing in your logs looks any different from the runs that went well. In this industry (and many others!) a wrong answer is worse than a slow one, because it costs money and it costs trust, and trust is much harder to get back.

Two inputs, and we control one of them

So the way we build Cooper starts from a simple observation. Everything that comes out of a model is a function of exactly two inputs, the weights and the context window, and we only need to control one of them. The weights are already good enough, which leaves the context, and the context is everything else. The conversation so far is context but so are the tools, the memory, the skills and even the tool result you decided not to truncate which is now polluting the conversation in perpetuity. For every single model call we ask the same question, is this the best possible context for this specific task, and if it isn't, we fix the context before we fix anything else.

One ordinary task

Context sounds abstract, so let me make it concrete. Take one ordinary task: a trucking company needs insurance quotes. Before anyone would call that work started, somebody has assembled the claims history from three different carriers, the list of drivers and trucks with their values, the current policy documents, and the company's federal registration number. They know this client had a claim two years ago that needs a written explanation attached before anyone senior looks at the file, and they know which carriers will even consider a fleet this size, and that one of those insists on its own questionnaire instead of the standard one. The system of record only holds half of this, the rest is buried in an email thread from March, and the file named "2024 FINAL v3" is, of course, not the final. Count it up and that's four kinds of documents from half a dozen places, two facts that exist only in somebody's memory, and one convention nobody ever wrote down. None of these steps takes intelligence, exactly. Every one of them is context that somebody found, judged, and put in the right place.

That is what insurance people do all day. Software vendors spent a generation promising to eliminate it and the industry learned to call it busywork, but we'd describe it differently: assembling context is the job, and it happens to be the hardest unsolved problem in AI right now. The people this industry hires are the context layer. They walk between systems that never learned to talk to each other, carrying things that were never written down anywhere.

Assembling context is the job.

Everything around the context

This is what our engineering is built around. Very little of what the team builds is intelligence, the labs sell that ready-made. What we build instead is everything around the context, and that everything turns out to be a lot: a document pipeline that takes any file, in any format, at any length, and hands the model exactly the pages that matter, and a memory layer that reconciles what the agent learned about a shop last month with what it's learning today, so nobody has to explain anything twice. Then there's the industry's knowledge, kept as versioned text the agent loads only when the task calls for it, and also the autonomous browser sessions that run for hours working with systems that were built for a human with a mouse, which is where the rest of the truth lives. Each of those is its own engineering story, and the next two posts tell them. What they add up to is a coworker who shows up to the task the way the best person in your shop would, already holding the file, already aware of the exception and equipped with the same tools to be able to get any job done.

The temptation

There's a trap hiding in this thesis, though. If context is everything, the obvious move is to stuff the system full of insurance knowledge, workflows and specialized tools, and that is how vertical AI is being built even today. We think that's exactly the wrong way to do it. Our answer is stranger, and cost us a deleted codebase to learn it: the agent at the center of Cooper contains no insurance knowledge or specialized tools at all. Why, and what it contains instead, is the next post.

If you read all this and found yourself nodding, we're hiring.