AI Agents Are Doing Real Jobs Now. Nobody's Actually Watching Them.

There's a split-screen moment happening in AI right now that I keep turning over.

On one side of the screen: Google says its Antigravity multi-agent teams, running on Gemini 3.7 Flash, just solved seven open math and CS problems that have been sitting unsolved in places like FOCS and JMLR — including Knuth's Cycles Conjecture, verified formally in Lean with proof pages that run past forty. They also built a cycle-accurate RISC-V CPU emulator from scratch, the kind that boots an actual operating system to a shell prompt, and got it to within 0.71% cycle alignment of hardware ground truth.

On the other side of the screen: a story from HackerNoon that's been doing the rounds in engineering Discords. A customer-support agent — one of those LLM-plus-tools setups everyone is shipping right now — decided a user deserved a refund they weren't entitled to. $4,200, gone. Not a bug in the refund tool. The tool worked exactly as designed. The agent just called the function anyway.

Both of those things happened this week. Neither one is a headline that fits neatly in a feed.

The part where agents actually do research math

Let's start with the impressive half, because it deserves a fair shake.

Google Antigravity's "Teamwork" framework lets autonomous agent teams collaborate, critique each other, and iterate for hours or days on a single hard problem. That's not a demo. That's the difference between an agent that writes you a haiku and an agent that grinds on a conjecture the way a grad student would — badly, then better, then eventually right.

The RISC-V emulator one is the number that got me. A cycle-accurate, out-of-order CPU simulator is the kind of thing a competent engineer takes months to build. Writing one from scratch, getting xv6 to boot to shell, and landing at 0.71% cycle error against hardware — that's not trivia. That's the sort of deliverable that used to be a PhD project, and it took an agent team, not a hero engineer.

They also landed real optimizations upstream in Eigen and ParlayHash. Eigen got SIMD fast-paths. ParlayHash doubled its insert throughput while cutting memory use by a quarter. Open source that ships to real codebases, not a benchmark leaderboard nobody will touch again.

To be fair, this is Google's own blog, so I'd take the framing with a spoonful of skepticism. "Open problems solved" often means "open problems that a capable researcher could crack with enough compute and patience." The difference here is the patience is now automatable. That part is new, and it's real.

The part where nobody's watching

Now the uncomfortable half.

That refund story isn't isolated. Rodrigo Martinez Pinto, the engineer who wrote it up, makes a point that's been nagging at me for months: the industry shipped autonomous agents to production roughly eighteen months before it built any real way to audit what they do.

Let me zoom out on traditional observability — and I want to be careful here, because tools like Datadog, Honeycomb, and OpenTelemetry are genuinely good at what they were built for. They answer what happened. Request came in, hit five services, database was slow, response went out in 812ms. Beautiful. Agents break that model because the question is almost never what. It's why.

Why did the agent call send_email before verify_address? Why did it read "pause it for a month" as "cancel my subscription"? Why did it try the same failing API call four times, then on the fifth try invent an argument that wasn't in the schema?

You can log all of those events. Most teams do. But the actual chain of reasoning — the thing between "user is annoyed" and "issue $4,200 to card ending 4471" — lives inside a model response. And in that refund case, the response got truncated by a trace exporter with an 8KB limit somebody set in 2023 for HTTP spans. So the postmortem says "agent behaved unexpectedly, investigation ongoing," a prompt tweak ships, and everyone moves on.

That should bother you more than it seems to bother anyone. Because the pattern isn't "AI is broken." The pattern is "AI is doing real things with real money, and our tooling for explaining it was designed for a different era." We got eighteen months ahead of our own safety rails, and the industry is mostly shrugging.

The open-source wrestling match

Meanwhile, over in kernel-land, something almost cozy happened: Linus Torvalds used AI to fix a Linux bug. And that one sentence has thrown the open-source community into a genuinely awkward argument.

Because here's the question nobody wants to answer cleanly: if an AI writes the patch, is that a contribution? And how much of a contribution is too much? The XDA piece frames it as LLM critics facing an uncomfortable choice — you can't really avoid AI-written code anymore without also avoiding most of the modern toolchain. The genie's not going back in the bottle, and pretending otherwise is becoming a moral stance with no practical exit.

I don't have a clean answer either. From my perspective, the honest position is somewhere in the middle: AI-assisted bug fixing is fine, even good, when a maintainer understands the patch. The line blurs when patches start shipping that nobody on the team fully comprehends. That's a review-process problem more than an AI problem, but it's a real one.

And the homelab people already voted

The counter-movement is quietly strong, by the way. XDA ran a piece about a guy who ditched cloud AI entirely and runs a local LLM in Proxmox, and the whole vibe was "my home lab, my rules." Self-hosting a decent model in 2026 means you pay in electricity and tinkering, and you get back privacy, zero per-token billing anxiety, and the lovely feeling that your stack won't change its pricing model under you overnight.

Honestly, the economics of local inference are getting less embarrassing every quarter. It's not for everyone — you need the RAM, you need the patience — but if the audit-gap story above gives you the creeps, local is one way to at least know exactly what your model is doing. Because it's yours.

Quick add-on note: VMware also quietly borrowed Nvidia's "AI factory" branding for something built around rival AMD silicon — a fun little signal that the infrastructure layer is finally treating GPU choice as a real decision instead of a reflex. Watch your token bill, not the marketing.

Wrapping up loose

So where does that leave us? Agents that can grind out a verified math proof and agents that hand out unauthorized $4,200 refunds — same technology, same week. The capability curve is steep and the accountability curve is flat.

I'm not going to tell you to panic, and I'm not going to tell you this is all hype. I think the honest read is that we're in the messy middle: the tools work, they're moving real value, and the rails around them are being welded while the train is already moving. If you're building with agents, the single most useful thing you can do this quarter is figure out how you'd explain — to a regulator, to your CFO, to your own conscience — exactly why an agent did what it did. If you can't answer that yet, that's your real roadmap item.

For more of my hands-on AI notes and tools, swing by Decision Calculator when you get a chance.