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.

• Claude Agent SDK — Sentry Autofix: writes mergeable PRs against 1M+ RCAs/yr → blog.sentry.io, claude.com/customers/sentry
• AWS Strands — Amazon internal network-troubleshooting agent (~80% of network root causes); origin of Amazon Q Developer → strandsagents.com
• Letta — Bilt: ~1M per-user memory agents for recommendations → letta.com/case-studies/bilt
• OpenAI Agents SDK — Coinbase AgentKit: agents with on-chain wallets, real transactions → github.com/coinbase/agentkit
• LangGraph — Exa web-research agent; LinkedIn text-to-SQL bot; Uber code migrations → langchain.com/blog/exa, top-5 in production
• Pydantic AI — STCC medical-triage agentic RAG (329 validated scenarios) → pydantic.dev
• LlamaIndex — SoftIQ construction-tender agent (100-page bids → risk reports) → llamaindex.ai case study
• Google ADK — Google’s own Agentspace/contact-center agents (6T+ tokens/mo); Renault EV-charger siting; Box contract extraction → developers.googleblog.com
• CrewAI — DocuSign 5-agent sales Flow (vendor blog) → blog.crewai.com
• smolagents — no named production company found; flagship is HF’s own Open Deep Research → github.com/huggingface/smolagents
• Microsoft Agent Framework / AutoGen — mostly research (Magentic-One); 1.0 names zero customers → microsoft.com/research

I bought five books on building AI agents in a single afternoon, the way you panic-buy bottled water before a storm. Manning had a sale. I had a credit card and a vague sense that everyone around me had quietly become an “agent engineer” while I was busy doing my actual job.

So I did the responsible thing. I spun up a small army of subagents to read four of them for me, cover to cover, in parallel, and report back. Which, if you’re keeping score, means I built a multi-agent system to summarize books about how to build multi-agent systems. The irony was not lost on me. It was, in fact, the first thing I learned.

Here’s the second.

The loop is thirty lines

Strip away the diagrams and the framework comparisons, and every single one of these books — Build an AI Agent, Build a Multi-Agent System, AI Agents in Action, AI Agents and Applications — converges on the same humble definition.

An agent is a language model, plus some tools, plus a loop that runs until the job is done.

That’s it. One book states it as plainly as that. Another dresses it up as a four-letter cycle. There’s a Reddit thread floating around that implements the whole thing in about thirty lines of code, set to a drum-and-bass track, and honestly it explains the concept better than half the chapters I read.

There is no secret sauce. There is no priesthood. You were promised a cathedral and what you got is a while loop with good manners.

Which raised an obvious question, sitting there with four hundred thousand words of agent literature on my screen: if the core idea fits on a napkin, what’s in all these books?

The part nobody puts on the cover

The answer is the same in every one, and it’s the most useful thing I took away.

The loop is the easy ten percent. The other ninety — the part that doesn’t fit in a demo — is evaluation, memory, guardrails, cost control, defending against prompt injection, and the deeply unglamorous skill of knowing when to hand the problem back to a human.

Three of the four books I read point at the same Anthropic paper, “Building Effective Agents,” like it’s scripture. And buried in chapter one of each — past the exciting cover, past the part where they sell you on the future — every author tells you the same quiet thing.

Don’t reach for an agent.

Start with a plain model call. Then a chain. Then a workflow. Earn the agent only when the task genuinely needs one, because an agent costs roughly ten times a normal call. Per task. Now imagine that thing running unattended, all night, while you sleep.

I went looking for the loudest voices on the other side of this — the practitioners on Reddit who build agents for a living and have the scar tissue to prove it. I expected an argument. The top thread is literally titled “Stop building AI agents.” Another is a guy who got paid to rip the AI back out of a tool he’d shipped. A third is the 2 a.m. classic: the agent hit a question it didn’t understand, confidently made up an answer, and emailed it to a customer.

The books and the burnouts weren’t arguing. They’d arrived at the same conclusion from opposite ends of the room. The model was never the bottleneck. Running the thing was.

What I’m actually taking away

A small tell that stuck with me: agent-to-agent coordination shows up in the subtitles of these books far more confidently than it shows up in the chapters. The field is writing about how agents talk to each other a little faster than it’s shipping it. That’s not a knock — it’s a map. It tells you where the hype is and where the ground is still wet.

So here’s my take, for whatever a guy who outsourced his reading to robots is worth.

The framework you pick doesn’t matter much; that code rots in eighteen months. What compounds is the boring stuff the demos skip — evaluation, context discipline, and the judgment to not build the agent at all. Everyone is rushing to learn how to make an agent. Almost nobody is learning how to make one you’d actually trust.

The capability got democratized this year. The judgment didn’t.

That gap — between the agent that runs and the agent you’d let near production while you’re asleep — is the whole job now. It’s also, conveniently, the only part worth getting good at.