35,866 results · Most relevant
The system is set up so that it always requires a human in the loop to make a decision, with AI surfacing insights; within Wisedocs' system there is always a human in the loop, and that is really important.
In customer conversations there has always been a very obvious problem to solve with technology; solve that first and insights start surfacing afterwards ('Oh, I didn't know that about my business. Let's solve that afterwards'). As easier challenges in adjudicating, processing, and extracting claim information are solved, more insightful aspects emerge that help organizations make portfolio-level decisions. It's also important to think about the problem being solved and only choose AI if it's the right solution.
You only get cross-claim and portfolio-level capabilities if you can solve the data extraction problem within one claim and roll it up into your broader insurance portfolio; claims-derived data is needed to power effective AI applications on the underwriting side, the fraud side, and the claim side.
Even when using AI to structure data and extract insights, make sure each step of the process is well calibrated — if upstream data is incorrect and you use it downstream, you haven't gained anything. As you go through the claims process, calibrate your judges and build good evals, and make sure you have experts who can verify the information by working across teams.
Intent systems ensure the right capabilities are given to the agent at the right time so they don't spend time on things they shouldn't, help navigate toward the goal state on a paved path, and result in fewer tokens spent on wrong-pathway actions; an agent that says it can't do the task is an acceptable outcome.
Without intent or some capacity to relay the user's or business's intent, you cannot achieve agent autonomy. Just because an action is right in its immediate context does not mean it is the right thing within the broader mission. Two chat sessions with different goals (shopping vs debugging a production bug) have very different profiles in terms of what permissions they should have and when the human should be brought back into the loop. To decide whether an agent should make a payment, you need the broader context: why the payment is being made, what happened before, and whether the same payment was just made five seconds ago (a double payment).
None stated.
The speaker is a strong believer that we should have control over what our agents do. At some point agents will be doing so much work that human-in-the-loop approval of everything cannot scale — this has already been shown not to scale. Users need a supervising agent that runs their policy and decides how things are done, and it should be independent of the agent doing all the work. To plug and play supervising agents with working agents, a protocol is needed to separate them. Without an independent supervising protocol, decisions about what the agent can and can't do — the guardrails — are decided by the agent's vendors, and the speaker does not want to give control to them to decide what they can do, with all decisions based in the vendor's system. The speaker wants to pull agent.
Treating the authorization model as a set of tools reduces not just security issues but flat-out error rates of your agent — when an agent has fewer things it can do, it makes better decisions.
In robotics, a robot raising its arm checks whether it is safe and allowed, and looks at its external environment for changes; a robotics-style authorization model lets you add more sensors into the decision — nearby objects, temperature, whether the rest of the robot is moving — pair the user's intent with the ecosystem (where they're doing it from, time of day), and yields shorter time-to-live authorization decisions with much more context than just user intent.
Ian's broad view is to have broad-based deterministic policy that says this is what must never happen, effectively, or these are the things that always require a human to be involved. Once that is in place, there is a big gap between all the policy a human or organization can write and what the policy should actually be in the specifics of a specific task. The real challenge is how to layer over that gap, because humans can't write it all. One version of layering policy is a user-to-agent or agent-to-agent interaction that has transactional intent between the two, alongside the business's intent.
Laurie Voss recommends stacking as many evals as possible so errors can't slip through all layers — the Swiss cheese model from security. Every eval has blind spots in different places: code evals catch formatting but miss meaning, LLM judges catch reasoning gaps but miss subtle hallucinations, humans catch subtle stuff but can't read every trace.
Laurie Voss describes a gotcha in the TypeScript version: use manuallyInstrument, which hands you back a copy of the instrumenter, and use that copy — because the Claude Agent SDK is an ES module and ES module exports are read-only, so the instrumentation can't swap out your instrumenter the way it can in Python. If you don't use the copy, it won't break — it just won't log anything. Everywhere in the repo, the Claude Agent SDK is imported from the instrumentation file, never straight from the package.
A guardrail is an eval that should block the release (e.g., agent making up a stock price). North Stars are things you're aiming for that are nice to have but don't gate shipping.
String-matching code evals miss many valid answers; for those you need LLM-as-judge evals, which use a second LLM to grade the output of the first LLM against a rubric. LLM judges understand meaning, not just strings — e.g., is this accurate, does it stick to source documents, is the tone right for a customer. The speaker finds ML-borrowed jargon (traces, evals, rubric) obscures meaning — rubric just means rules.
Laurie Voss states that every eval prompt that works well has five different parts. The first is giving the judge a role and context — a common pattern is 'you are an expert, blah, blah, blah.' Telling the judge it's an expert actually works — that's why everybody puts it in there. Telling an LLM it's an expert seems to make a difference in side-by-side comparisons — you need to tell it it's really smart and it gets confident and tries. But what really matters is the context, e.g., 'This is a financial report. We are expecting a report that analyzes financial data and tells us real things.'
Step six of the workshop is testing your tests — can we trust the judge, and how do we know the judge is right? The trick to remember is that your judge is a classifier in the classic ML sense: it looks at a report and predicts a label as actionable or not actionable. Like any classifier, you measure the judge by comparing its predictions with the truth, and here the truth is what a human expert would say. Attendees get to judge the judge — to mark the judge's homework.
The first kind of eval is code evals: fast, free, and a little bit brittle, very similar to unit tests. They are ordinary functions where you basically assert a string, though techniques exist to make them more flexible. They run in milliseconds and cost nothing to run.
Laurie Voss argues that choosing the right eval beats tuning it. Choosing correctness was entirely the wrong eval because it didn't tell us anything, it just told us a bunch of stuff was wrong. Tool selection told us something, and faithfulness told us quite a lot — knowing which question you're actually asking is the core of getting evals right.
When analyzing failures, look through all traces and write down in human language what you see happening before inventing categories — a term borrowed from ML called open coding. Guessing categories in advance produces categories that are too narrow, too broad, or miss what actually went wrong.
Laurie Voss advises giving yourself the same specific criteria that you gave the judge when labeling. He recounts disobeying one of his own rules — his rule said 'must include risks' and he marked a report fine even though it didn't include risks — and as a result he and the judge disagreed; he feels the judge was actually more correct than he was because it was being stricter. He also warns that the enemy when labeling is fatigue: if you give yourself a hundred traces to judge, by trace 50 you'll be bored and get lazier. It is better to have 50 really well-labeled examples than a hundred where you were just clicking through saying 'eh, this looks fine'.
Choose sources → to get a library of your own and a daily brief.