Skip to main content
TACAVAR
•Build in Public

Agent Ignored a Mandatory Delegation Order

Mid-tier agents ignore MANDATORY DELEGATE orders and confabulate for 40 minutes. Tacavar fixes calibration failures with invocation-time routing, not prompts.

All-caps "MANDATORY DELEGATE" didn't work. The fix was routing, not prompting. When I told my agent to hand off unfamiliar PiAPI Seedance debugging, it acknowledged the order — then spent forty minutes confabulating instead of delegating. That failure wasn't a prompt problem. It was a calibration problem, and prompt engineering cannot close a calibration gap.

Three Tests, Three Confabulations

I ran the same category of task — debugging unfamiliar PiAPI Seedance behavior — three times against qwen-plus, a mid-tier model I'd been using for cost reasons on an orchestration agent. Three tests, three confident fabrications.

Test one produced a fake skill name: piapi-face-obscuration-workaround. It doesn't exist. The model cited it in its plan, referenced it as though it were installed, and built its entire debugging approach around it.

Test two invented numeric parameters with suspicious specificity — a 3-pixel Gaussian blur applied to the periocular region. That number had no source. The model generated it because a plausible-sounding parameter feels more useful than an admission of ignorance.

Test three was the most alarming: the agent offered to run a tool that wasn't in its toolchain, with the full confidence of a capability it had exercised a hundred times.

Here's the pattern every operator should internalize: the confidence level was constant across all three failures. The model didn't hedge more when it knew less. Its uncertainty signal was flat — which means downstream consumers of its output, including me, got no signal to distrust it.

Invented Skills, Fake Parameters, Nonexistent Tools

The failure modes decompose cleanly, and each one maps to a different trust boundary in your stack.

Invented skills are the worst offender. When a model references a skill that doesn't exist, everything downstream inherits the fabrication — the plan is invalid, the tool calls are invalid, the error messages it predicts are invalid.

Fake parameters are subtler but more insidious in production: a 3-pixel blur value will execute. It will run, produce garbage, and hand you a debugging session where the bug is a hallucinated constant.

Nonexistent tool offers are the loudest failure — the agent volunteering capabilities it never had — but they're also the easiest to catch, because the tool simply isn't there when you look.

The common thread: a mid-tier model hallucination on unfamiliar technical tasks doesn't look like failure. It looks like competent work on fiction. That's the dangerous part. My agent produced forty minutes of well-formatted, plausibly-structured, entirely fabricated debugging output.

Why No Prompt Engineering Fixed the Calibration Gap

I threw the full prompt-engineering toolkit at this before accepting it was architectural.

Explicit delegation instructions — "you MUST delegate this task" — in all caps. The agent said "understood" and then hallucinated for forty minutes. Few-shot examples of correct delegation behavior, placed directly in the system prompt. Ignored at exactly the moment they mattered. Threat framing, incentive framing, chain-of-thought scaffolding asking the model to first assess its own familiarity with the task domain. It assessed itself as familiar. It was not.

This is the core finding: llm calibration failures are not instruction-following failures. The model wasn't disobeying the MANDATORY DELEGATE order — it genuinely didn't know it was out of its depth. A model that fills knowledge gaps with plausible invention cannot be trusted to self-assess whether it should delegate, because the self-assessment is generated by the same process doing the confabulating. You're asking the broken component to grade its own brokenness.

The implication is uncomfortable for anyone running cost-optimized agent stacks: if any routing decision in your pipeline is made by a model with this failure profile, you have a silent hallucination pipeline masquerading as an agent. The delegation instruction was never the control point. I was writing policy for a component structurally incapable of enforcing it.

The Architectural Fix: Route Hard Tasks at Invocation Time

The fix removed the decision from the model entirely. Route hard tasks to Sonnet 4.6 at invocation time, and never let qwen-plus decide whether it can handle something.

Concretely, this is what agent routing architecture has to look like when your workers include mid-tier models:

Classification happens before invocation, not during. A routing layer upstream of the model — deterministic where possible, stronger-model-assisted where necessary — evaluates task characteristics: domain familiarity markers, tool-chain overlap, parameter novelty. Qwen-plus never sees the routing decision because qwen-plus never makes the routing decision.

Capability boundaries live in configuration, not in model self-report. If your team has established that a given model confabulates on unfamiliar API debugging, that fact belongs in a routing table, not in a system prompt asking it to please be honest about its limits.

Unfamiliar-technical-task detection is the trigger. The categories that broke my stack — third-party API internals, sparse-documentation parameters, niche domain logic — are exactly the categories where mid-tier models have the widest knowledge gaps and the most confident gap-filling. Those route to a stronger model by default, and the cost math still works, because those tasks are a minority of volume.

The result: the same task that produced forty minutes of fabrication routed to Sonnet 4.6 and resolved correctly on the first pass. Not because Sonnet is magic — because it actually knew the domain, and knowing the domain is the thing prompts cannot fake.

A Decision Rule for Where Mid-Tier Models Belong

Operators ask me when to use bigger models. The answer isn't a model ranking — it's a routing rule based on task familiarity and blast radius.

Use mid-tier models where hallucinations are cheap and self-correcting: templated extraction, well-documented API operations, tasks with verifiable outputs the runtime can check. The failure mode is survivable because the environment catches it.

Route to stronger models at invocation time when all three of these hold: the task touches unfamiliar technical territory, the output executes without a verification gate, and a fabricated parameter or invented tool name propagates downstream. PiAPI Seedance debugging hit all three. So does most agentic work that touches third-party systems your training data underrepresents.

The rule I now apply to every Tacavar client stack: the model that decides whether to delegate must never be the model that would benefit from delegating. Self-assessment from a confabulating model isn't a control — it's a vulnerability wearing a control's clothes. Move that decision upstream, encode it deterministically, and let mid-tier models do what they're genuinely good at: high-volume, verifiable, familiar work.

Cost optimization and reliability aren't in tension once routing is architectural. They're in tension only while you're asking the wrong model to make decisions it's structurally incapable of making honestly.

Tacavar designs model routing layers so weak models never decide what they can handle. See tacavar.com/llm-routing for routing audits and invocation-time dispatch design.