Why LLM agents keep failing (and it’s not the prompt)

A new paper on SSRN proposes ORCA, a cognitive runtime for LLM agents that structures reasoning as reusable components instead of embedding logic in prompts, addressing common failure patterns in agent systems. The author argues that most LLM agent failures stem from forcing systems to figure everything out from scratch, and outlines five practical rules for AI stability, including avoiding over-prompting, using Q4_K_M or higher quantization, grounding via APIs, filtering for stability, and researching model ceilings.

Most LLM agent failures I’ve seen share the same pattern: They don’t break because of the model. They don’t break because of the prompt. They break because we force the system to “figure everything out” from scratch on every interaction. In traditional software, we don’t rebuild logic every time we run a function. We define structure, reuse components, and control execution. With LLM agents, we’re doing the opposite. This led me to explore a different approach: - What if reasoning wasn’t embedded in prompts, → but structured and executed as reusable components? That’s the idea behind ORCA — a cognitive runtime for LLM agents. I’ve put the full concept in a paper in zenodo and now also on SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract id=6600840 https://papers.ssrn.com/sol3/papers.cfm?abstract id=6600840 Curious if others are hitting the same limits with prompt-based systems. The Real-World Rules for AI Stability I’ve tested countless models, and while the tech is amazing, it’s far from easy. Most people fail because they treat prompts like magic spells. Once you understand these 5 rules, the “brain fog” disappears: 1. Stop Over-Prompting The “Less is More” Rule Long, complex prompts often cause “attention drift.” The AI starts overthinking the instructions and forgets the goal. Instead of one giant prompt, use a clear structure and give the model one task at a time. 2. Never Drop Below Q4 Quantization Using Q2 or Q3 models is the fastest way to get hallucinations. These “thin” models lack the weights to hold complex logic. Use Q4 K M or higher—it’s the “sweet spot” where the AI stays grounded and reliable. 3. Provide “Grounding” via API e.g., Brave Search An AI without a data source is just a “hallucination machine.” Connect it to a search API with a strict token limit. Real-time data keeps the agent honest and prevents it from making things up when it doesn’t know the answer. 4. Filter for Stability, Not Hype Don’t chase every new “benchmark king” on Hugging Face. Check the download counts and user feedback. A stable, older model is always better for an agent than a flashy new one that crashes under pressure. 5. Research the Model’s “Ceiling” Every model has a limit. Find out what it can’t do before you start. For example, never give an AI unsupervised access to your system files—always set boundaries and keep a “human in the loop” to verify its actions. Great list — and I agree with every point as practical advice. But I think it’s worth zooming out, because all five rules are essentially compensations for a missing layer . - “Stop Over-Prompting” — Exactly. But why do we over-prompt? Because we’re encoding logic, control flow, and context management inside the prompt itself. In ORCA, reasoning is decomposed into skills — small, declarative, reusable units. The prompt stays minimal because the structure carries the intent, not the text. - “Never Drop Below Q4” — True for unstructured generation. But when you externalize reasoning into a cognitive runtime, the model’s job shrinks: it executes one well-scoped step at a time, not an entire chain of thought. That changes the quantization equation — structured execution is more forgiving on model capacity. - “Provide Grounding via API” — 100%. In ORCA this is formalized through bindings — typed connectors between skills and real services APIs, search, databases . Grounding isn’t an afterthought; it’s a first-class architectural element. - “Filter for Stability” — Agreed, but with structured skills you gain something bigger: model portability . Your agent logic lives in capabilities, not in a model-specific prompt. Swap the model without rebuilding the agent. - “Research the Model’s Ceiling” — This is where capability contracts come in. Each ORCA skill declares its inputs, outputs, and boundaries before execution. The ceiling is explicit and enforceable, not discovered through trial and error. Your rules are solid engineering discipline. What I’m exploring with ORCA is whether we can encode that discipline into the runtime itself — so it’s not advice developers need to remember, but structure the system enforces. The repo just reached 350 clones Hope more people give it a try, I have fix some friction for the quickstart that may help giving it a try The paper behind ORCA is now live on SSRN: https://papers.ssrn.com/sol3/papers.cfm?abstract id=6600840 https://papers.ssrn.com/sol3/papers.cfm?abstract id=6600840 Main idea: Stop recomputing reasoning with prompts. Start reusing cognition. Working on a simple demo next. I agree with the core point. Prompting alone is too weak as the control layer once agents start acting over time. The interesting failures often appear after several turns: memory drift, role confusion, tool overconfidence, and agents adapting to feedback in ways the original prompt never anticipated.