LLM agent swarms deliver limited results beyond PR hype

Andrej Karpathy (@karpathy) on X

Buzzwords are already outpacing the metrics that actually matter, and the whole “agent swarm” hype train is full of empty promises. I’ve watched a handful of teams throw together a coordination layer, slap a few LLMs on top, and call it a day—only to end up with a showcase that looks impressive on a slide deck and does nothing useful in practice. The code is there, the diagrams are neat, but the outcomes are as thin as the press releases that announced them.

If we judge the state of the art by what OpenAI and Anthropic are shipping, the picture gets even murkier. Take the notion that a model could be, say, five thousand times smarter on the inside. In that scenario, you’d expect the demos to actually solve problems, not just generate glossy videos. Instead, we see the same old “it works on paper” demos, while the real work—human review, reproducibility, the kind of careful math that keeps the field honest—is falling behind. The OpenAI‑HF incident still needs a forensic read, and mathematicians are still slogging through hundreds of new papers that claim to push the frontier.

All of this makes me wonder whether the swarm narrative is a distraction or a stepping stone. Are we building something that will eventually deliver, or are we just padding résumés while the real challenges pile up? The answer will shape where developers and investors put their energy next.

What people claim LLMs can do

The headlines that dominate recent AI press releases are louder than the data that backs them. Articles proclaim “autonomous agents that can write code, run experiments, and debug themselves” or “general‑intelligence systems ready to replace knowledge workers.” Those statements look impressive, but they gloss over the fact that the underlying models still stumble on basic reasoning and tool use.

A quick scan of blog posts from the past six months shows three recurring claims:

  • autonomous agents can replace software engineers on non‑trivial projects
  • large language models already possess human‑level common‑sense reasoning
  • the next generation will achieve general intelligence without additional training

One post even quoted, “Text generation is not the bottleneck. Does everyone work for Accenture and TCS?” Another linked to a tweet‑like status page <https://xxcancel.com/karpathy/status/2109361546505966046> that repeats the same hype without citing any evaluation.

Peer‑reviewed studies and public benchmark tables tell a different story. On the MMLU (Massive Multitask Language Understanding) suite, GPT‑4 scores 86 percent, while the best open‑source 7B model hovers around 45 percent. For GSM8K arithmetic, the same open‑source model gets 22 percent correct, far below the 70‑plus percent threshold that would make it reliable for real‑world calculations. These numbers are published in conference proceedings and on the official leaderboard, not in the marketing copy.

The gap becomes obvious when you try to turn the claim “LLM can plan a multi‑step data pipeline” into code. The snippet below asks a model to generate a three‑stage ETL script and then runs the result. The generated code compiles, but it fails on the second step because the model never validated the schema change.

import openai, subprocess, json, os, textwrap

prompt = """Write a Python script that:
1. Reads a CSV from /tmp/input.csv
2. Adds a column `total` = `price` * `quantity`
3. Writes the result to /tmp/output.csv
Include error handling for missing columns."""
response = openai.ChatCompletion.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": prompt}],
)
script = response.choices[0].message.content
open("/tmp/generated_etl.py", "w").write(script)

result = subprocess.run(["python", "/tmp/generated_etl.py"], capture_output=True, text=True)
print("STDOUT:", result.stdout)
print("STDERR:", result.stderr)

Running this on a clean environment produces a KeyError when the CSV lacks the expected columns—exactly the kind of failure the headlines ignore. The evidence, not the hype, is what should guide our expectations.

Why the misunderstanding matters

Misreading where the bottleneck sits sends money and talent into dead‑end projects. Companies pour billions into bigger clusters while the real limiter—clean training data and robust evaluation—remains under‑invested. A quick way to see the gap is to time a forward pass versus token generation; the numbers usually show that producing the next token is a fraction of the total latency.

import time, torch
model = torch.hub.load('huggingface/pytorch-transformers', 'model', 'gpt2')
tokens = torch.tensor([50256])  # EOS token
model(tokens)
start = time.time()
for _ in range(100):
    model(tokens)                     # generation step
elapsed = time.time() - start
print(f'Avg token latency: {elapsed/100:.4f}s')

The script prints an average token latency that is often under 10 ms on a single V100, confirming that generation itself isn’t the choke point. This mismatch fuels a feedback loop: investors chase bigger GPUs, researchers chase larger papers, and the community loses focus on the parts that actually need improvement.

When policy makers hear headlines that “AI can write anything instantly,” they draft regulations for capabilities that don’t exist yet. “Text generation is not the bottleneck. Does everyone work for Accenture and TCS?” reads like a sarcastic retort, but the underlying risk is real—laws based on inflated expectations can lock in unnecessary compliance costs and stifle useful innovation.

The credibility loss spreads beyond the boardroom. Developers who hit the wall of missing data or flaky evaluation feel duped; users who try a demo and see hallucinations lose faith; the broader public, already wary of AI hype, starts treating every claim with suspicion. The tweet‑style thread at https://xxcancel.com/karpathy/status/2109361546505966046 captures that sentiment in a single line. If we keep overstating what models can do, we’ll end up with a community that questions every new release instead of building on it. How do we keep hype honest without killing excitement?

The agent‑swarm narrative examined

The recent demo of an “agent swarm” feels more like a staged showcase than a technical breakthrough. The core problem—getting dozens of language‑model‑driven bots to cooperate without drifting into contradictory loops—has been on the research radar for years, and the implementation here adds little beyond a scripted choreography. In practice the swarm never completes a task that a single, well‑prompted model couldn’t handle, so the claimed coordination layer isn’t demonstrably beyond the state of the art.

What worries me more is how this kind of PR‑driven rollout muddies the conversation about real risk. The community is already flagging the mismatch between the volume of LLM‑generated content and the capacity of human reviewers. Adding a swarm that spits out another layer of automatically generated output only amplifies that mismatch, without offering a clear way to triage or verify the results. The liability concerns—misinformation, copyrighted material, or unsafe instructions—remain, and the swarm’s output isn’t any easier to audit than a single model’s.

I’m not convinced the regulatory urgency some callers demand will be satisfied by simply tightening review quotas. What we need is a measurable standard for “output provenance” that can survive a cascade of agents. Until tools can reliably trace a decision back to a specific prompt, model version, and coordination rule, any oversight framework will be fighting a moving target. The open question is whether future tooling will catch up fast enough to keep the liability gap from widening, or whether the regulatory response will end up being a blunt instrument that stifles legitimate experimentation.

Closing the perception gap

I don’t see the TBH swarm as a technical breakthrough. The architecture they showcase—multiple agents passing messages through a thin coordination layer—has been around in research labs for years. What’s new is the packaging, not the underlying capability. In practice the swarm never finishes a task that a single, well‑prompted LLM couldn’t handle, so the demo ends up looking like a PR stunt rather than a step forward.

That disconnect matters because it feeds the broader anxiety people are voicing about LLMs: we’re already seeing a flood of generated content that outpaces the capacity of human reviewers. When a system can spin out thousands of plausible‑looking snippets per minute, the safety nets that rely on manual inspection start to crack. The liability risk isn’t theoretical; companies are already being sued over mis‑generated advice and deep‑fake text. The regulatory response that’s bubbling up—mandatory audit trails, caps on autonomous output—will likely focus on the volume problem more than on whether the underlying agents are “cutting‑edge.”

If the community’s worst‑case scenario materializes, we’ll see a shift from chasing ever larger swarms to tightening the feedback loop between model output and human oversight. That could mean more investment in tooling that flags anomalous generations rather than in larger coordination layers that don’t add measurable value. I remain uncertain whether the regulatory pressure will be enough to slow the production of these high‑throughput systems, or whether market forces will simply push the review problem downstream to third‑party monitoring services.

The question I’m left with is whether the next wave of LLM development will prioritize smarter, more accountable output or just double down on raw generation speed. That’s the fork we’ll have to watch.

Conclusion

The demos keep promising “5000‑times better” internal models, yet the coordination layer that stitches the agents together is anything but cutting‑edge. The most visible outputs are polished PR videos, not measurable progress, and even the human side of things is lagging—people are still sifting through the 722 manuscripts from the OpenAI‑HF incident months after the fact. Token economics makes the problem worse: to turn these swarms into anything genuinely useful you’d need token counts to climb by orders of magnitude, and that only happens if token prices collapse by a comparable factor. As it stands, the free‑tier models have already saturated what most users can meaningfully engage with, leaving the rest of the “mega‑useful” vision stranded on hardware that will never be affordable for everyday workloads.

If the cost curve doesn’t flatten, I suspect agent swarms will remain a marketing gimmick rather than a functional tool. The real test will be a public benchmark where a swarm is required to solve a non‑trivial, well‑defined problem—no showmanship, just results. Until that happens, the hype gap stays wide open. What concrete task could actually force a swarm to prove its worth?