Lakshmi Narasimhan
ESSAY

I Went Looking for Real-World AI Agent Examples. They're Rare.

I’ll be honest up front: I’m still learning this stuff. I’m not writing this from a mountaintop. I’m writing it from the foothills, with muddy boots, having just figured out something that I suspect a lot of people pretend they already knew.

Here’s the thing that finally clicked for me. An agent is a loop. A model looks at the situation, decides one next step, calls a tool to do it, looks at what happened, and goes around again until it’s done. That’s it. I felt a little cheated when I understood it — the word “agent” had been doing so much heavy lifting on so many landing pages that I’d assumed there was a fortress behind it. There isn’t. There’s a while-loop.

So I went and read about the frameworks. All of them — LangGraph, CrewAI, LlamaIndex, the OpenAI Agents SDK, Pydantic AI, smolagents, the Claude Agent SDK, the vendor SDKs from Google and Amazon and Microsoft. And every single one walks you through the same starter example: a weather bot. Or “chat with your PDF.” Or my personal favorite, the demo where five agents — a Researcher, a Writer, a Critic, an Editor, and presumably a Manager to schedule their standups — collaborate to produce a blog post slightly worse than one agent would’ve written.

And I kept thinking: okay, but where are the real ones?

Not the demos. Not the quickstart. Something non-trivial. Something that acts on the world, where a wrong move costs money or breaks production. I genuinely couldn’t picture one. So instead of pretending, I went looking.

(The method, since it’s too on-the-nose not to mention: I sent a small swarm of research agents out across the web to comb engineering blogs and case studies for me, in parallel, while I made coffee. Hunting for proof that real agents exist turned out to be the most real agent use I’d touched all week. Make of that what you will.)

Here’s what I actually found.

The good news: real ones exist

A few of them are unambiguously real, and they’re worth describing, because they taught me more about what an agent is for than any framework doc did.

Sentry’s Autofix is the one that changed my mind. When something breaks in a codebase Sentry monitors, an agent built on the Claude Agent SDK takes their root-cause analysis, plans a fix, writes the code, and opens a pull request you can actually merge — a full run in about six minutes. This isn’t a chatbot that suggests you “consider checking your null values.” It writes the patch. And it runs against a platform doing over a million root-cause analyses a year. One of their engineers shipped it in weeks and wrote a piece literally titled how Sentry’s AI Autofix changed my mind about AI agents. I felt seen.

Amazon has an internal agent that troubleshoots network failures — diagnoses live VPC connectivity problems and resolves around 80% of network root causes on its own. Built on their Strands SDK. That’s an on-call SRE’s nightmare-shift, handed to a loop. As someone who’s done that shift, that number did something to me.

Coinbase built a toolkit that gives an agent a crypto wallet. The agent can hold funds, sign transactions, and pay for things autonomously. Read that again. We’ve spent this whole article saying the scary part of agents is irreversible action with real stakes — and here’s one wired directly to money on a blockchain, where “oops” is permanent. Terrifying. Also clearly real.

Bilt runs a million agents — one per user — on Letta, each holding that user’s transaction and engagement history in persistent memory to drive merchant recommendations. The whole pitch of Letta is memory, and here’s someone betting a recommendation system on it at a scale I can’t fully picture.

And a scattering more, each genuinely non-trivial: Exa’s web-research agent and LinkedIn’s text-to-SQL bot (both on LangGraph, both acting against live production systems); a medical-triage agent on Pydantic AI validated across 329 clinician-checked scenarios; a construction-tender agent on LlamaIndex that digests 100-page public bids and spits out risk reports; Uber automating code migrations across its monorepo.

So. Real agents exist. I can stop being a skeptic about that.

The uncomfortable news: there aren’t many, and the vendors are grading their own homework

Here’s the part that kept nagging me after the research came back.

For each framework, I could find maybe one to three genuinely non-trivial examples. Not dozens. Single digits. And almost every one of them was published by the company that sells the framework. Sentry’s story is on Sentry’s blog (fair enough — Sentry isn’t Anthropic), but most of them live in the framework vendor’s own marketing: LangChain’s case-study page, Letta’s case studies, AWS’s own deep-dive, Google’s own developer blog. Independent “here’s our war story and here’s what broke” write-ups from teams with no skin in the game? Vanishingly rare.

And some frameworks I genuinely couldn’t find a real one for:

  • smolagents has 26,000 GitHub stars and I love its design — but its flagship example is Hugging Face’s own research replication. I found no named company betting anything real on it.
  • CrewAI is everywhere in demos and has a wall of enterprise logos (PepsiCo, J&J, the DoD), but behind almost every logo is zero operational detail. The one solid story — a five-agent sales pipeline at DocuSign — is, again, on CrewAI’s own blog.
  • Microsoft’s Agent Framework just hit 1.0 claiming “real-world validation with customers and partners” and then named exactly zero of them. Its most impressive artifact, Magentic-One, is explicitly a research system that doesn’t ship inside a product.

I want to be careful here, because I’m still learning and I don’t want to overclaim the cynicism: “I couldn’t find it” is not “it doesn’t exist.” A lot of the realest agent work is surely locked inside companies that will never blog about it. But the public record, right now, is thin. Much thinner than the hype implied. The ratio of “agentic platform” marketing to “here is a real agent doing a real job” is grim.

Two things I think I’m learning

I’m holding these loosely, because foothills. But:

The best real agents are vendors using their own tools. Amazon’s network agent, Google’s enterprise agents on ADK, Strands originating inside Amazon Q Developer — the most concrete, number-backed cases are companies dogfooding the framework they built. That’s either reassuring (they believe in it enough to run it) or a little hollow (of course the toolmaker has the best tool demo). Probably both.

Every real one acts. None of them chat. This is the pattern that actually reorganized my thinking. Line up the genuinely non-trivial agents — writes a mergeable PR, signs a transaction, resolves a network outage, holds a million users’ memory, files a risk report on a 100-page tender. Not one of them is a conversation. The toys all talk. The real ones do. The demos cluster around chat because chat is safe and reversible and impresses in a screenshot. The real ones cluster around irreversible action because that’s where an agent is actually worth the risk of building.

Which, looping all the way back, is exactly why the weather bot felt so empty. A weather bot doesn’t do anything. It’s the loop with the stakes amputated.

So where does that leave a beginner

I don’t have a grand conclusion. I have a working hypothesis, which is the most an honest learner should claim: the framework you pick matters far less than whether you have a real job that needs an agent that acts. If you don’t, no framework will save you — you’ll build a five-agent demo and quietly stop opening the repo. If you do, the loop is twenty lines, and you should start with whichever framework hides the least so you can actually see what’s happening (smolagents, the OpenAI Agents SDK, and Pydantic AI were the ones that got out of my way the most).

And honestly? The fact that real examples are still this rare didn’t discourage me. It read like a timestamp. We’re early. The scarcity isn’t proof the idea is empty — it’s proof most people are still building weather bots while a handful of teams quietly wire a loop up to something that matters.

I’d rather be in the second group — which is why I’m slowly building one of my own. I’m still learning how.

The ledger (the realest example I found per framework, and where it’s published)

Honest tag: most of these are vendor-published. Independent confirmation is scarce — which is part of the story.