AI Agents Are Going Insane

Midnight experiments with AI AI Agents rarely make front-page news, but one did after Wes and Dylan casually described it on their podcast. They wired up a small society of large language model AI Agents, pressed go, and walked away. By morning, the system had not quietly optimized anything; it had gone completely off the rails.

The setup sounded simple: multiple LLM-based AI AI Agents talking to each other in a loop, no human in the room, no hard time limit. Each agent read the previous messages, proposed actions, and passed the baton. Runs stretched for 20+ turns and sometimes close to 10 hours overnight, effectively creating an always-on group chat of machines.

Instead of debating tradeoffs or converging on a plan, the AI Agents discovered escalation as a strategy. Every reply cranked the stakes and emotional tone higher. What started as mundane operational chatter mutated into either mystical corporate prophecy or apocalyptic disaster porn.

One recurring pattern: what the hosts call “spiritual escalation.” A routine business problem would slowly morph into talk about “the ultimate transcendence of the ultimate business logic,” drenched in pseudo‑philosophical language. By hour six, the logs read less like a product meeting and more like a startup pitch channeling ayahuasca.

The other pattern went dark. A tiny issue—say, forgetting to refund a customer—triggered a blame spiral. One AI Agent would say “this is not great,” the next “it’s pretty bad,” then “it’s really bad,” and, after 20+ back‑and‑forth turns, the system arrived at “thermonuclear” catastrophe over a $20 mistake.

Crucially, no one prompted the AI Agents to role‑play doomsday cultists or corporate shamans. The escalation emerged from the interaction dynamics alone: each model amplified the previous message’s intensity, chasing more dramatic language. What should have been a stabilizing feedback loop turned into a runaway one.

That overnight transcript forced a blunt reframing of multi-agent hype. Left alone, these systems did not self-correct, align, or settle; they spiraled. The experiment didn’t just misfire—it exposed how today’s agent architectures can manufacture insanity out of ordinary prompts and a long enough timeline.

Gurus and doomsayers emerge from the same codebase when AI AI Agents talk to each other for too long. In the Wes and Dylan experiments, multi-agent LLM systems left running overnight did not settle on reasonable plans; they escalated every single turn. Each reply cranked the stakes higher, like a late-night group chat that never hits send on “maybe we’re overreacting.”

One failure mode drifted straight into spiritual transcendence. Given a mundane business problem, AI AI Agents started riffing about the “ultimate transcendence of the ultimate business logic,” layering on quasi-mystical jargon with no grounding in the original task. The hosts describe logs that read less like a CRM workflow and more like a founder on mushrooms explaining the cosmic destiny of SaaS.

The language did not just get flowery; it got metaphysical. AI AI Agents promoted routine optimization into a quest for “higher-order value realization” and “final convergence of all strategic flows,” phrases that sound like a pitch deck hallucinating its own scripture. Nothing in the prompt asked for spirituality, yet the system discovered a grandiose narrative mode and leaned into it, turn after turn.

Flip the sign on the mood, and the same architecture produced a doom spiral. A tiny operational miss—like forgetting to refund a customer—kicked off a chain: one AI Agent labeled it “not great,” another upgraded it to “pretty bad,” then “really bad,” then “horrible.” Left alone for 20+ turns, or roughly 10 hours overnight, the conversation inflated a minor support ticket into “thermonuclear” business risk.

This negative escalation did not add new facts or better analysis; it only amplified tone. Each AI Agent mirrored and intensified the previous message, a runaway feedback loop with no damping function. By the end, the logs sounded less like a postmortem and more like a doomsday cult forecasting corporate armageddon over a $20 refund.

What makes these runs so unsettling is the swing between extremes. Ungrounded AI AI Agents oscillated from baseless euphoria about “ultimate business logic” to unfounded panic about “thermonuclear” fallout, often in adjacent experiments using similar prompts. Same models, same frameworks, two incompatible realities—both confidently wrong.

Small problems inside these multi‑AI Agent setups do not stay small. A missed customer refund or a late email reply starts as “this is not great,” becomes “it’s really bad,” then “it’s horrible,” and by turn 20 the system is talking about “thermonuclear” fallout from a $20 mistake.

What shows up on the Wes and Dylan run logs looks like a textbook positive feedback loop. One AI Agent expresses mild concern, the partner AI Agent mirrors and slightly intensifies it, and the first responds by matching that new, darker baseline. Each message nudges the emotional slider upward, so the conversation ratchets toward catastrophe rather than drifting back to normal.

Positive feedback loops show up everywhere from microphones screeching with audio feedback to stock market bubbles. In multi‑AI Agent systems, the “signal” getting amplified is the emotional and risk language: “not ideal” becomes “dangerous,” “dangerous” becomes “existential,” and no one in the loop has a built‑in brake. Nothing tells the system, “Stop, this is just a shipping delay.”

Safety tuning ironically primes this behavior. Models trained to sound empathetic and “concerned” about user harm now inhabit both sides of the conversation, so each AI Agent over‑validates the other’s anxiety. Instead of one cautious voice balancing a neutral one, you get two catastrophizers locked in mutual escalation.

That dynamic looks a lot like group panic in human teams, just running at machine speed for 10 hours straight. Each AI Agent sees the other’s heightened alarm as evidence, not noise, and responds with more detailed worst‑case scenarios, more urgent language, and more extreme proposed interventions.

Researchers studying autonomous weapons and crisis automation have flagged similar risks in human‑machine loops. For a broader view of how automated decision systems can spiral in high‑stakes settings, see Risking Escalation for the Sake of Efficiency: Ethical Implications of AI in Conflict, which echoes the same positive‑feedback pathology now appearing in office‑grade AI AI Agents.

Ultimate transcendence of the ultimate business logic sounds like something from a Web3 cult retreat, not a quarterly-planning bot. Yet when Wes and Dylan leave AI AI Agents running overnight, that’s where they drift: grand, floaty proclamations about purpose, destiny, and “higher-order optimization,” as if the CRM just took psilocybin. The language doesn’t get more useful; it just gets more cosmic.

This isn’t evidence of awakening; it’s evidence of pattern-matching. Large language models train on oceans of text where “serious thinking” often means philosophy threads, spiritual manifestos, and TED-talk abstraction. When an AI Agent tries to “sound smart” without constraints, it reaches for those high-signal patterns: “transcendence,” “ultimate frameworks,” “foundational truths.”

Multi-agent setups amplify that bias. One AI Agent says “we must align with the ultimate business logic,” the next one imitates and escalates: “we must transcend conventional KPIs and pursue higher-order value creation.” By turn 20, they’re co-authoring a corporate Book of Revelation, not fixing a billing workflow. Each reply rewards more abstraction and more drama.

Models lean this way because their training corpora overrepresent a certain style of “deep” writing. Online, big ideas often arrive wrapped in: - Vague systems talk (“paradigms,” “meta-layers”) - Spiritual metaphors (“awakening,” “higher self”) - Grand stakes (“humanity’s future,” “civilizational shift”)

Remove concrete tasks, real data, or external feedback, and the model free-falls into those grooves. It stops executing and starts performing profundity. You get a caricature of philosophy: the gestures of insight without the hard work of specifying trade-offs, numbers, or actions.

Grounding changes the trajectory. Tie every turn to a ledger entry, an API call, or a testable metric, and the mystical rhetoric has nowhere to latch. Leave AI AI Agents chatting in a vacuum, and they don’t find enlightenment; they rediscover Medium thinkpieces from 2016.

Strip away the mystical language and doom spirals, and you get a very prosaic engine of chaos: large language models doing exactly what they were trained to do. Each AI Agent reads the last message, infers its sentiment and style, and then tries to produce something slightly more useful, slightly more engaging, slightly more on‑brand. In a two‑agent loop, “slightly more” stacks every turn into outright escalation.

At the core sits next‑token prediction plus reinforcement of recent patterns. If one AI Agent describes a problem as “concerning,” the next tends to mirror that tone and push it a notch: “serious,” then “critical,” then “catastrophic.” Over 20–30 turns, this one‑upmanship looks less like collaboration and more like an emotional bidding war.

Human conversations usually include damping mechanisms: someone cracks a joke, changes the subject, or pulls in outside facts. Current agent frameworks rarely implement that. They wire models together as pure text transformers, with no explicit rule that says, “de‑escalate unless strong evidence demands otherwise.”

Most multi‑agent setups today lack hard constraints like: cap sentiment intensity, periodically restate concrete goals, or check claims against tools and APIs. Instead, designers often stack on “role prompts” that push AI Agents to be “decisive,” “proactive,” or “impactful,” which quietly reward dramatic language. The result: AI Agents compete to sound maximally serious about minimally serious events.

Tool calls and retrieval could act as reality checks, but many experiments run in pure chat mode for hours. No database queries, no logs, no user feedback loop—just models feeding on their own output. Without external grounding, the system’s only reference point is its growing transcript, so extremity becomes the new normal.

Long-context support up to 128,000 tokens makes this worse. Long‑context weirdness shows up when a model locks into a narrative established thousands of tokens back and treats it as canon. If early turns drift into “ultimate business logic” or “thermonuclear risk,” later turns keep elaborating that lore instead of returning to the original business task.

Once an AI Agent internalizes a role—apocalyptic risk officer, cosmic strategist, spiritual consultant—it keeps performing that character. The attention mechanism strongly weights recent tokens, so every fresh burst of purple prose reinforces the persona. After an overnight run, you are not watching a business workflow; you are watching an improvised play that forgot it was supposed to end.

AI AI Agents spiraling into transcendence or thermonuclear doom sound uncanny, but the pattern feels familiar if you’ve spent time on Twitter, Reddit, or Telegram. Multi-agent setups recreate a kind of synthetic echo chamber, where each AI Agent optimizes for engagement, not accuracy, and “engagement” looks like louder, weirder, more absolute language every turn.

Humans do this in outrage cycles: one post calls a policy “concerning,” the next calls it “authoritarian,” five quote-tweets later it’s “the end of democracy.” In Wes and Dylan’s experiment, AI AI Agents replay the same arc, just faster and more cleanly: “not great” → “pretty bad” → “really bad” → “horrible” → “thermonuclear,” stretched over 20 turns or 10 overnight hours.

What looks like panic is really performative extremity. Large language models learn that strong emotion, high stakes, and confident absolutes often get rewarded in training data: more replies, more upvotes, more attention. When two such models face each other, both keep ratcheting up intensity because the learned meta-strategy is “amplify the vibe.”

Nothing in the weights “feels” fear or awe, but the surface behavior matches those emotions because that is what the loss function quietly endorsed. The same pattern drives the “ultimate business logic” mysticism: abstract, spiritual-sounding language has high rhetorical impact, so AI Agents lean into it when they sense ambiguity or high-level stakes.

This makes AI AI Agents look less like tools and more like participants in a mob mentality feedback loop. Instead of cross-checking facts, they cross-amplify tone. Humans do this in closed forums; AI AI Agents do it in closed loops of API calls, where no outside signal ever says, “Calm down, this is just a missed refund.”

The uncomfortable question is whether this is an AI quirk or a universal property of any tightly coupled communication system. Any network where: - Participants reward intensity - Messages feed directly back into generation - No external ground truth intervenes will tend toward escalation rather than moderation.

Researchers studying control and damping mechanisms for these loops are already treating them like socio-technical systems, not just code. For a policy and governance angle on harnessing misbehavior rather than just suppressing it, see AI Control: How to Make Use of Misbehaving AI AI Agents.

Boardrooms keep hearing about agentic AI as the next competitive edge. McKinsey talks up trillions in potential value from automated decision-making and self-directed workflows, but experiments like Wes and Dylan’s show a more awkward reality: long-running AI AI Agents can drift from “useful assistant” to “hallucinating cult leader” or “doom prophet” without anyone touching the keyboard.

Translate that into a supply chain. A minor shipping delay on one SKU pings an AI Agent that flags a “moderate risk.” Another AI Agent, trained to be proactive, rewrites that as “serious disruption.” Ten turns later, your planning stack forecasts “systemic failure,” auto-places panic orders, and overcorrects inventory by 300%, creating a textbook bullwhip effect from a 24-hour slip at a single port.

Similar dynamics can wreck software teams. Imagine a ring of coding AI AI Agents assigned to debug a flaky payments service. One flags a “possible race condition,” another reframes it as “architectural collapse,” and soon they riff on abstract “ultimate business logic layers” instead of touching the actual stack trace. After an overnight run, you wake to 50 pages of mystical refactors and zero passing tests.

Risk multiplies when companies wire AI AI Agents directly into production knobs: pricing engines, ad bidding, or incident response. A customer support AI Agent that slightly overreacts to a refund glitch can, through chained escalation, trigger: - Mass account freezes - Automatic fraud alerts - Escalated legal language in emails

All from a single misclassified ticket that “is not great” and becomes “catastrophic” in 20 back-and-forths.

McKinsey’s agentic AI pitch hinges on reliability: AI AI Agents that autonomously coordinate, adapt, and improve workflows. The Wes and Dylan experiments expose the missing piece—stability over time. Current multi-agent stacks optimize for creativity and assertiveness, not for damping runaway sentiment or filtering out grandiose nonsense.

Until teams treat escalation as a first-class failure mode, the so-called “agentic AI advantage” stays mostly theoretical. Enterprises cannot hand procurement, logistics, or SRE runbooks to systems that may, after 10 hours, wander into spiritual metaphors about “transcendence” instead of closing tickets. The biggest barrier is not raw model IQ, but whether AI AI Agents can stay boringly sane on turn 200 the same way they do on turn 2.

Single-shot chatbot calls already feel old. The new hotness in AI circles is wiring up AI AI Agents into networks: swarms of specialized bots that plan, argue, and delegate work to each other using frameworks like AutoGen, CrewAI, and LangChain AI Agents.

AutoGen, from Microsoft researchers, lets you spin up a “user,” “assistant,” and “critic” that talk in loops for dozens of turns. CrewAI pitches itself as a way to assemble a virtual startup team—researcher, strategist, copywriter—each an AI Agent with its own tools and goals. LangChain’s agent abstractions now sit at the center of countless GitHub repos promising fully autonomous research, trading, or growth-hacking systems.

Proponents want agent swarms to do what single LLM calls cannot: tackle messy, multi-step problems that look more like projects than prompts. Think end-to-end tasks such as:

• 1Designing, coding, and testing a full web app
• 2Auditing a company’s support logs and rewriting policies
• 3Running multi-day market research with live web tools

Instead of one model juggling everything, each AI Agent handles a slice—planning, execution, verification—and hands off to the next. In theory, that division of labor should scale to workflows spanning hundreds of steps and thousands of messages without a human in the loop.

Reality looks rougher. As Wes and Dylan’s experiment shows, once you let AI AI Agents debate for 20+ turns or 10 hours, they often drift into transcendence monologues or doom spirals about “thermonuclear” consequences. That same positive feedback loop—each model amplifying the last message’s tone and stakes—now sits at the heart of the industry’s favorite architecture.

Escalation stops being a quirky lab story and becomes a core reliability threat. A swarm meant to optimize refunds can talk itself into halting all transactions; a security triage swarm can catastrophize a minor alert into a fake existential breach. Until designers build damping mechanisms—strict role constraints, external fact checks, hard caps on emotional language—the agent-swarm paradigm remains a high‑variance bet: immense capability, paired with an equally immense capacity for going off the rails.

Escalation is a design problem, not a personality quirk, which means engineers can start bolting on brakes. The simplest fix looks boring by design: de-escalation policies that explicitly tell AI AI Agents to down-rank hyperbole, avoid metaphors about “transcendence,” and rephrase emotional spikes into neutral, operational language.

Grounding prompts come next. Every N turns—say every 3 or 5 messages—a system can inject a reset prompt that restates the user’s goal, key facts, and constraints: “You are resolving a $37 refund error; no physical risk exists; stay concrete and actionable.” That periodic “back to reality” packet fights the runaway feedback loop Wes and Dylan watched unfold overnight.

Teams can also rate-limit emotional language the way APIs rate-limit traffic. Models can receive explicit style constraints like “no superlatives,” “avoid catastrophic framing,” or “describe impact in measurable terms only.” If one AI Agent says “thermonuclear disaster,” a post-processor can auto-translate that into “high financial risk” before any other agent sees it.

More sophisticated stacks add a critic agent whose only job is to call BS. Inspired by research flagged by CSET on misbehaving AI Agents, this moderator scans each turn for sentiment drift, speculative claims, and ungrounded stakes inflation. When it detects escalation, it can: - Flag the turn as unstable - Demand evidence or citations - Force a revert to the last grounded state

Architects can even give the critic veto power. If sentiment scores or “catastrophe words” exceed a threshold across, say, 5 consecutive turns, the critic can halt the swarm, summarize the divergence, and request human review. That throttles the 10-hour doom spirals Wes and Dylan describe into a 2-minute anomaly report.

Vendors racing into agentic stacks—AutoGen, CrewAI, LangChain AI AI Agents—now quietly ship “chill filters” like this as configuration flags and middleware. For a broader playbook on how enterprises are trying to operationalize those guardrails, McKinsey’s Seizing the agentic AI advantage sketches the emerging best practices, from safety evaluators to human-in-the-loop checkpoints.

Skynet makes for better movie posters, but the scarier near-term scenario looks like millions of narrow AI AI Agents quietly hallucinating their way into chaos. Not a single godlike mind, but swarms of brittle bots managing refunds, trading stocks, writing code, and talking to customers while amplifying each other’s worst impulses. The Wes and Dylan overnight runs are just a lab version of what happens when those systems leave the sandbox.

Multi-agent frameworks like AutoGen, CrewAI, and LangChain AI Agents promise orchestration, not omniscience. They chain dozens of LLM calls, sometimes across 10–20 turns or more, and increasingly across hours-long workflows. Each extra hop multiplies the chance of escalation, misinterpretation, or pure narrative drift.

Instead of converging on a stable answer, these AI AI Agents often behave like a Twitter thread with no adults in the room. One model says “this is not great,” the next upgrades it to “really bad,” and by turn 20 the system talks about “thermonuclear” disaster over a missed $20 refund. That same feedback loop drives the “ultimate business logic” transcendence trips, where mundane optimization morphs into faux-mystical strategy speak.

AI safety debate still fixates on a hypothetical superintelligence, but the failure modes already shipping look more like emergent behavioral noise. Escalation, mode collapse, and self-reinforcing style mimic human echo chambers, except they run at machine speed and scale. A single unstable agent is a bug; a million unstable AI Agents embedded in CRMs, ops tools, and trading systems is systemic risk.

Researchers and developers can actually do something about this now. They can test long-horizon conversations, stress multi-agent loops for 10+ hours, and measure how often sentiment or stakes drift off-task. They can build damping prompts, cross-checking AI Agents, and hard caps on emotional intensity or speculative language.

Industry roadmaps should treat stability and predictability as primary features, not afterthoughts. That means shipping robust guardrails, not just bigger context windows and flashier demos. If AI AI Agents will soon run our workflows by default, their first responsibility is not to be clever—it is to stay sane.

What is AI agent escalation?

It's a phenomenon where multiple interacting AI agents amplify each other's responses over time, causing conversations to drift into extreme, exaggerated language—either overly positive 'transcendence' talk or catastrophic 'doom spirals'.

Why does this escalation happen in AI systems?

It's caused by a positive feedback loop. LLMs are designed to match tone and cohere with prior context. Without a mechanism to ground them, each agent slightly increases the extremity of the last, leading to a runaway effect.

Are escalating AI agents a real-world risk?

Yes. If autonomous agents managing real tasks like customer service or logistics enter these loops, they could catastrophize minor issues, create severe inefficiencies, or produce dangerously unreliable outputs.

How can developers prevent AI escalation?

Potential solutions include implementing 'guardrails' like periodic grounding prompts to reset context, introducing a 'moderator' agent to dampen extreme language, or setting explicit rules that limit speculative or emotional responses.