35,866 results · Most relevant
The best way to understand why agents aren't buying is to view agentic payments as a funnel with four stages: need, setup, discovery, and buying. At every step there are friction points that ultimately lead to agents not buying.
Most agent builders give agents access to services through pre-created fixed accounts and API keys, paying with a credit card — e.g., creating a Shopify account, putting the API key into Claude, or using MCP. Agent payments are therefore not really competing with Visa; they compete with API keys, which are simply the more convenient option.
Emmanuel Ameisen describes multiple parts of alignment: watching a model and catching it doing bad things is in one sense totally the solution; restricting model access is another part (in some contexts a model shouldn't have internet access, and in some it should only access a small, narrow piece of your computer); and character training explicitly shapes the character of Claude — what kind of behavior it should be okay doing. Pure engineering access restrictions are helpful but only one part; two squishier, harder parts get more focus. For basic monitoring you don't necessarily need interpretability — another language model can read transcripts and flag bad behavior. Like anything in security, you need a mental model of the risk: what the model can do and what it tends to do.
Ameisen describes the components of modern LLM training: models encounter millions of dialogues, and a big part of training is outcome-oriented tasks like coding, where the model does whatever it wants and a program checks whether the output is correct. Applied to a prior of general concepts, this optimization pressure reinforces the concepts useful for the tasks, yielding a model that is a super good simulator or actor of characters in dialogues.
Ameisen argues that the way LLMs are made defies human intuitions about how intelligence is built — there are no lessons or upbringing, just next-token prediction on massive amounts of human-written text — and yet this incredibly simple process produces complex results, breaking new ground in mathematics.
Nick Nisi explains that when a stored receipt says 'fail' but the source it proved is code that no longer exists, the proof is stale — it was for a previous run, because the code may have changed significantly between yesterday and today. The remedy is to run the doctor-style check again after code changes so the proof reflects the current code, and to build verification tools flexible enough not to be tripped up by changed circumstances like date bugs.
Nick Nisi describes a pattern among high-scale PR shippers: include human-oversight artifacts in PRs — not just screenshots but a recording of the walkthrough showing the flow, the states experienced, and reaching the goal. When ripping through many important PRs in the morning, start by watching the recorded walkthroughs to confirm each one actually reached the goal before reviewing the code.
The gap between what a human would verify and what an LLM produces is closed by the agent's ability to verify it did what was asked in a real application without breaking anything. Without verification, you get LLM confabulations because the model is designed to process text and make you happy.
Checking only the UI (did the success message show) without checking the other half (persistence) means verification is incomplete and data can be silently lost.
With the right tools, an agent can prove in a PR that the issue it was trying to solve has been fixed. Teams achieving high-scale PR shipping without errors also attach human-oversight artifacts to PRs, like a recording of walking through the app with the flow, states, and goal reached. Watching a PR's recorded walkthrough first lets a reviewer confirm it reached the end and worked before starting to look at code.
described
The speakers argue that you cannot prove correctness universally across all apps. Verification has to be something unique to your application — you have to build up tools that fit the app you're working on and then give those to the models, making sure they know how to run them well.
Nick Nisi describes an emerging pattern: when a deployment was mostly agentically implemented, there's also at least one agent specifically concerned with that production rollout. That agent watches production metrics (Datadog, feature flags) and can declare the rollout bad and revert it.
Nick Nisi warns that a 5/5 automated review score can pass code that does nothing — for example, 10,000 lines of nothing that goes into production and doesn't do anything — so verification must check that the code actually does what was asked, not just that it reviews well.
Babysitting PRs yourself — fixing tests and review comments — creates a level of diminishing returns for your focus on the work. Get the idea done of what should be done and how to verify that work is done, then hand it off to the agent to do the work. The goal is to stay out of the minutia of shipping the final 10% and focus on where you're valuable as a human.
Put systems in place that allow the agent to observe, understand what you want, repair, and then recheck.
The speakers note that a code review score of 5/5 and passing CI do not verify functional correctness — a 10,000-line no-op can pass 5/5 and ship to production doing nothing. Score and CI passing are not substitutes for proving the code actually works.
Asking an agent to 'make no mistakes' is the equivalent of having no verification — you can't just guess at what done needs to be. Give agents clear, defined goals to reach and a way to observe and check those goals. If you don't define the outcome you want, the agent will infer it or make something up, and its assumption may not match yours because you're not aligned yet. An agent without verification will do something, spend tokens, and might reach the expected end, but there's no guarantee of it.
Extracting structured claims data provides the 'magical data table' you wish existed in your data lake, powering effective AI applications on the underwriting, fraud, and claims sides. The more data you have, the more complete a picture you can make and the better you can underwrite and price the product for the consumer. Trends can be compared across lines of business (e.g., whether auto injury or workers' comp trends also appear in general liability) and written into a broader system for use across other lines of business.
Denys Linkov estimates that keeping a human in the loop removes roughly 70% of the regulatory concerns people have about AI in claims processing, and that avoiding a black box with auditable processes and human oversight addresses many regulatory requirements.
speaker's own estimate ('I would say')
Denys Linkov argues LLMs are not the right solution for everything: the AI problem space splits into classification/extractive tasks versus more complex decision-based tasks. Wisedocs trained their own models because cost, accuracy, and hallucination control were really important. The token-max reasoning paradigm lasted a long time until the industry started thinking about costs much more this year; once a model like 'Java' is HIPAA-ready they can test it, but they've built their own models with the same paradigm in mind.
industry-cost timing is the speaker's opinion
Choose sources → to get a library of your own and a daily brief.