Also... how many security vulnerabilities have those agents introduced?
post
As someone who works in tech, currently testing AI integration into healthcare EHR- the current state of AI is simply not safe for anything outside transcription- and even that is error prone without strict re-reading (not scanning!) for error correction.
The errors can be subtle but life threatening. I highly recommended against integrating it - but the most lazy providers were already using AI illegally for their notes so this was seen as a middle road.
Medical care and provider training in the USA is not ok right now, and getting worse. AI and misinformation is accelerating the decline.
TL;DR: Three Hard Truths About AI Agents After building 12+ production systems, here's what I've learned: -Error rates compound exponentially in multi-step workflows. 95% reliability per step = 36% success over 20 steps. Production needs 99.9%+. Context windows create quadratic token costs. -Long conversations become prohibitively expensive at scale. -The real challenge isn't AI capabilities, it's designing tools and feedback systems that agents can actually use effectively.
The TL;DR of the TL;DR is compounding expensive, error-prone results.
Interesting. I have never seen the economic side of it being discussed outside of nvidia stock prices.
I keep having the same question: would it benefit to have a separate agent whose job was to error-check the first agent?
Performing procedural tasks using a statistical model of our language will never be reliable. There’s a reason why we use logical and proscriptive syntax when we want deterministic outcomes.
I expect what we will see are tools where the human manages high level implementation, and the agents are used to implement specific functionality that can be easily tested and verified. I can see something along the lines of a scene graph where you focus on the flow of the code, and farm off details of implementation of each step to a tool. As the article notes, these tools can already get over 90% degree accuracy in these scenarios.
I agree that this could be helpful for finally getting to that natural language programming paradigm that people have been hoping for. But there’s going to have to be something capable of logically implementing the low level code and that has to be more than just a statistical model of how people write code, as trained on a big collection of random repositories. (I’m open to being proved wrong about that!)
The 90% accuracy could just arise from the fact that the tests are against trivial or commonly solved tasks, so that the exact solutions to them exist in the training set. Anything novel will exist outside the training set and outside of the model.
I think it's going to be humans that implement actually interesting code while LLMs handle common and tedious stuff. That's the approach I've been using at work. When I need to crap out a UI based on some JSON payload, or make an HTTP endpoint, I let the LLM do it. When I have some actual business logic that's domain specific, I write that myself. This allows me to focus on writing code that's actually interesting, while the LLM does all the tedious work.
But doesn't the LLM sometimes churn out tedious garbage that you have to fix, thus not actually saving time?
That's where the rate of success becomes important. LLMs mostly produce decent code when applied to common cases like the examples I gave above. My experience is that vast majority of the time it's as good as what you'd write, occasionally needing minor tweaks. However, there's nothing forcing you to use the code they produce either. If the LLM stumbles, you can always fall back to writing the code by hand which leaves you no worse off than you would've been otherwise. It's all about learning how the tool works and when to use it.
You have to check it every single time, though, erasing any time savings. You're saving effort, maybe, but not time.
You're absolutely saving time, checking that the code works is far less time consuming than writing it. Especially for stuff like UIs or service endpoints. I literally work with this stuff on daily basis, and I would never go back. There's also another aspect to it which is that I personally find it makes my workflow more enjoyable. It lets me focus on things I actually want to work on, while automating a lot of boilerplate that I had to write by hand previously. Even if it wasn't saving me much time, there's a quality of life improvement here.
Yes, I've seen this as well. First of all, 16 devs is a tiny sample, a far bigger study would be needed to get any meaningful results here. Second, it really depends on how experienced people are at using these tools. It took me a while to identify patterns that actually work repeatably and develop intuition for cases where the model is most likely to produce good results.
Here's the uncomfortable truth that every AI agent company is dancing around: error compounding makes autonomous multi-step workflows mathematically impossible at production scale.
Obvious problem is obvious.
top 7 comments