The LLM Breaking Point: Past ~80 Simultaneous Rules, Models Stop Following Them, Whatever the Format

If you're writing a system prompt for an AI bot with dozens of rules (tone, bans, formatting, mandatory phrases), there's a hard line past which the model starts ignoring requirements wholesale, and no amount of pretty formatting saves you. The researchers ran the same rules in four styles (markdown, plain text, continuous prose, a table), and the difference between formats turned out to be barely noticeable.

The headline finding: with 10-40 rules the model follows almost everything, but at 80 rules the probability of perfectly following ALL of them drops to zero, and that happens for every one of the five models tested, in every format. The cause isn't how the rules are laid out; it's that there are simply too many to juggle at once. If each rule is followed 98% of the time but there are 80 of them, the odds of nailing all of them at once collapse for purely mathematical reasons. Format is about HOW you present the rules, not HOW MANY the model can keep in its head.

The practical takeaway is simple: don't sweat the "right format" for your prompt; cut the number of simultaneous rules and split them into critical (few) and secondary (checked separately). Bonus finding: as a document approaches the model's context limit, the model is more likely to refuse to answer than to make up facts, which is a reliable, honest signal you can lean on.

The Finding at a Glance

RULE THRESHOLD IN A PROMPT:
10–40 rules   → the model follows almost all of them
80 rules      → perfect compliance drops to zero (everywhere, in every format)
120–160 rules → total failure

CONTEXT LENGTH THRESHOLD:
up to ~64–128k tokens        → fact retrieval accuracy at its peak
past the model's limit       → the model does NOT make up facts, it refuses to answer more often (0% → 80-90% refusals)

Example in Practice

Task: You're setting up an AI assistant for a clothing store on Amazon that answers shoppers in chat. You want to bake in everything at once: tone, bans, formatting, mandatory phrases. The list has grown to 90 items.

Prompt (the right approach: split into tiers):

You are a customer assistant for an online clothing store. Here are the CRITICAL rules; follow them at all times:

1. Never use the word "guarantee" (legally sensitive)
2. Address customers politely and formally, no slang
3. Don't use exclamation marks
4. Keep answers to 3 sentences max
5. End every answer with the phrase "If you need anything else, I'm here to help"

I'll send additional rules for this conversation (no more than 15 at a time) in a separate message.

Result: the model reliably holds 5-6 critical rules. If all 90 requirements had been dumped into one system prompt at once, some rules (whether in a list, a table or prose) would inevitably get lost by the time you hit 80.

Why This Happens

The model doesn't track instructions with a separate "done/not done" counter; it holds them all in its head at once as part of the context while generating text. The more rules there are, the higher the chance that at least one gets dropped while writing the answer. It's a combinatorial effect, not a problem of unclear wording.

There's one thing the model is good at: honestly recognizing when a task is beyond it. That's why, near the context limit, it refuses to answer more often instead of lying. That's a strength you can use as a quality signal.

Levers you can pull: - Number of rules → keep 10-20 critical ones in a single prompt, send the rest as separate messages - Placement (system prompt vs user message) → the effect is inconsistent across models, test it for your task - Format (markdown/table/text) → don't waste time on the "perfect format", the difference barely affects the outcome - Document length → don't expect 100% answer accuracy near the model's context limit, chop the document into parts

Prompt Template

SYSTEM PROMPT (no more than 10-15 critical rules):
{rule 1}
{rule 2}
{rule 3}

USER MESSAGE (extra rules for the specific task, 15-20 max):
{rule A}
{rule B}

If you have more rules than that, split them across several sequential requests and check the result after each one.

For working with long documents:

Here is the document: {text}

If the answer to the question isn't in the text, say so directly: "not found in the document". Don't guess and don't draw conclusions by analogy.
State which section of the document the answer comes from.

🚀 Quick start: paste this into the chat:

I have a list of rules for an AI bot's system prompt. Help me split them into critical (no more than 15) and secondary, so the model reliably follows everything:

{your rules}

The LLM will ask which rules matter most for the task, because without prioritization all rules look equally important, and with a big pile of them some will inevitably get ignored.

Limitations

⚠️ There's no universal format: neither markdown, nor tables, nor plain text gives a reliable edge. The winner changes every time depending on the model.

⚠️ Rule placement is model-specific: the system prompt helps some models and hurts others. There's no single rule; you have to test on your own model.

⚠️ This is a diagnosis, not a ready-made technique: the study shows WHERE the system breaks, but doesn't hand you a formula for success. Compensating for rule overload is on you.

⚠️ Tables cost more: they eat a third more tokens than plain text, and the accuracy gain doesn't always justify it.

How They Tested It

The researchers built a fully synthetic "Book of Veyra": 8,780 nonexistent entities (planetary systems, guilds, creatures) generated without a single LLM, so they could be sure that if a model knew anything about them, it got it from the prompt and not from training memory. The first experiment ran 960 queries per model: from 10 to 160 simultaneous rules, in four formats, in two prompt positions. The second experiment ran 5,520 queries per model on a context ladder from 2 thousand to 512 thousand tokens, checking fact recall accuracy, agreement with false statements, and invention of facts that didn't exist.

The biggest surprise: the models never made up facts (0 out of 5,760 checks) and almost never fell for false statements. But refusals to answer shot up (from 0% to 80-90%) right as each model approached its own context limit. That turned out to be the main "symptom of overload", not fabrication.

Resources

Netanel Eliav, Machine Human Intelligence Lab (MHIL). "Prompt Design at Scale", arXiv preprint, July 2026. Code and the VeyraBench corpus: github.com/iNetanel/veyrabench