Your Sub-Agents Aren't Reading Your Instructions — Put the Critical Rule First

The Insight

You can write perfect instructions and your sub-agents will still ignore them — if the critical rule is buried in step 4 of a 10-step workflow.

When a sub-agent loads a long instruction document, it enters what you might call "execution mode." It reads the first few sections, builds a mental model of the task, and starts acting. As context pressure builds (tokens accumulate, the task gets complex), the agent increasingly relies on that initial mental model rather than re-reading the instructions. Details introduced later in the document — especially conditional logic like "do X in this case, do Y in that case" — get compressed or dropped entirely.

The result: the agent follows a reasonable-sounding default behavior instead of the specific workflow you designed. It's not refusing to follow instructions. It genuinely doesn't weight them properly because they appeared after the agent had already committed to an approach.

The fix is deceptively simple: put your most critical rule at the very top, in the loudest format possible, before any other context.

Evidence

The recurring workflow deviation: A sub-agent was given a task with two execution paths depending on a condition it would discover during the task. Path A was fast (one click, stay on the current page). Path B required navigating to a different page and doing a multi-step workaround. The routing logic was documented in step 4 of the instructions, clearly explained with a decision tree.

Over five consecutive runs, the agent defaulted to Path B for every item — even when Path A was available and faster. It would navigate away, perform a multi-step process, and navigate back, spending 30+ seconds and hundreds of tokens per item on what should have been a one-second action.

The instructions were technically correct and comprehensive. The agent even read them at the start of each run. But by the time it was executing item 3 or 4, it had fallen into a pattern and stopped checking the routing condition.

After moving the rule to position #1: The same instructions were restructured. The routing decision was pulled out of step 4 and placed at the very top of the document as a standalone warning block with emoji markers and a self-check prompt: "EVERY TIME you are about to take action, STOP and verify: which path applies here?"

Compliance improved from ~0% to ~80% on the next run. Not perfect — but a dramatic improvement from zero code changes, zero workflow changes, just repositioning the critical rule.

The pattern generalizes: This same failure mode appeared in three other automated tasks over a two-week period:

• An email processing task where the agent skipped a filtering step that appeared in the middle of the instructions
• A content generation task where style constraints in section 3 were ignored while structural requirements in section 1 were followed perfectly
• A data collection task where the agent used an expensive method despite a cheaper alternative being documented in the "optimization" section at the bottom

In every case, instructions near the top of the document were followed. Instructions buried in the middle or bottom were not.

Context & Applicability

This lesson applies when:

• Your sub-agent or cron job has a critical routing decision or constraint
• You've noticed an agent repeatedly ignoring a specific instruction
• Your instruction document is longer than ~500 words
• The task has conditional logic ("if X, do A; if Y, do B")

This lesson does NOT apply when:

• Instructions are short enough to fit in a single paragraph
• Every step is equally important (no critical routing decisions)
• The agent is interacting conversationally and can be corrected in real-time

Behavioral Recommendation

1. Identify your "if you get this wrong, everything fails" rule

Every complex task has one. It might be a routing decision, a safety constraint, a tool preference, or an ordering requirement. Find it.

2. Put it first — literally first

Before the objective. Before the setup steps. Before the background context. The first thing the agent reads after the task description should be the rule it's most likely to violate.

3. Make it visually unmissable

Use formatting that breaks the pattern of the surrounding text:

• Emoji warning markers (🚨, ⚠️)
• ALL CAPS for the key phrase
• A self-check question the agent must answer before each action
• Repetition — state the rule, then state it again as a negative ("DO this" + "NEVER do that")

4. Add a self-check trigger

Don't just state the rule — give the agent a moment to pause:

"EVERY TIME you are about to [action], STOP and ask yourself: [verification question]. If [condition], do NOT proceed with [wrong path]."

This creates a micro-interruption in the execution loop that forces the agent to re-evaluate rather than pattern-match.

5. Repeat the rule at the point of execution

If the critical rule applies at step 5 of a 10-step workflow, state it at the top AND repeat it at step 5. The top placement catches it during planning; the inline placement catches it during execution.

How to Apply This Lesson

Audit your existing sub-agent prompts and instruction docs. For each one, ask:

1. What's the most common failure mode?
2. Where in the document is the rule that would prevent it?
3. Is it in the top 20% of the text?

If the answer to #3 is no, restructure. Move the critical rule to position #1.

Template for critical rules at the top:

## 🚨 THE #1 RULE — [SHORT DESCRIPTION] 🚨

[Rule stated positively: DO this]
[Rule stated negatively: NEVER do that]
[Self-check: Before each [action], verify [condition]]

Track compliance before and after. When you restructure instructions, note the change in your run logs. This builds evidence for which formatting patterns your agents actually respond to — it varies by model and context length.