Can a separate mediator layer improve intent understanding before task execution?
This explores whether putting a dedicated 'understanding' stage in front of the part that acts — a layer that figures out what the user actually wants before anything is executed — produces better results than asking one model to interpret and act in a single pass.
This reads the question as: should the work of figuring out intent be its own component, separate from the component that carries out the task? The corpus says yes — and surprisingly consistently, across domains that don't share vocabulary. The cleanest evidence is structural: when you split a 'decomposer' that plans from a 'solver' that executes, accuracy and generalization both improve, because the two jobs stop interfering with each other Does separating planning from execution improve reasoning accuracy?. The same pattern shows up in vision: GPT-4V fails when forced to *simultaneously* interpret a screen and decide what to click, but a parsing layer that first turns the screenshot into labeled semantic elements lets the model focus only on action — the bottleneck was the composite task, not the model's ability Why do vision-only GUI agents struggle with screen interpretation?. A mediator layer works, in other words, less by adding intelligence than by removing a load the executor shouldn't be carrying.
Why does isolating the step help so much? Two notes point at the mechanism. 'LLM Programs' wrap the model in an explicit algorithm that hands each call only the context relevant to that step — information hiding as an architectural principle Can algorithms control LLM reasoning better than LLMs alone?. 'Cognitive tools' push this further: reasoning operations implemented as separate sandboxed calls lifted GPT-4.1 on hard math from 26.7% to 43.3% with no training at all, because modularity *enforces* an isolation that prompting alone can't guarantee Can modular cognitive tools unlock reasoning without training?. The intent-understanding layer is one instance of this: give it its own boundary and it does its job cleanly instead of being smeared into execution.
But there's a sharper question hiding here — what should the mediator layer actually *do*? One school reframes understanding itself. Rasa drops intent classification entirely and generates domain-specific commands instead, treating comprehension as pragmatics (what the user wants done) rather than semantics (what category the utterance falls in) — and it does this without annotated training data Can command generation replace intent classification in dialogue systems?. That's a hint that the most useful mediator isn't a classifier bolted on front; it's a different representation of intent altogether.
The most interesting twist is that intent often *can't* be understood up front from a single message — it has to be actively discovered. Tool-enabled models silently chain actions and drift from what the user meant; conversation analysis offers 'insert-expansions' as a formal account of when an agent should pause and probe the user instead of guessing, heading off misunderstanding rather than recovering from it When should AI agents ask users instead of just searching?. Yet standard RLHF actively trains this instinct out: optimizing for immediate next-turn helpfulness discourages clarifying questions, and only rewards that estimate long-term interaction value restore active intent discovery Why do language models respond passively instead of asking clarifying questions?. So a mediator layer that merely interprets is weaker than one licensed to ask.
One caution worth carrying out of this: don't assume understanding is something a model already has and just needs space to express. Instruction-tuning research found that models trained on semantically *empty or wrong* instructions perform about as well as those trained on correct ones — what transfers is knowledge of the output format, not comprehension of the task Does instruction tuning teach task understanding or output format?. The lesson for a mediator design: separation gives the understanding step room to work, but you still have to verify it's understanding intent rather than pattern-matching a response shape.
Sources 8 notes
Modular architectures with separate decomposer and solver models outperform monolithic LLMs, with decomposition ability transferring across domains while solving ability does not. The separation prevents planning-execution interference and produces more generalizable skills.
OmniParser demonstrates that GPT-4V fails when forced to simultaneously identify icon meanings and predict actions from raw screenshots. Pre-parsing screenshots into structured semantic elements with descriptions lets the model focus solely on action prediction, removing the composite-task bottleneck.
LLM Programs embed LLMs within explicit algorithms that manage control flow and state, presenting only step-specific context to each LLM call. This information hiding addresses capability and context window limits while treating complex reasoning as modular, debuggable sub-tasks.
Four cognitive tools implemented as sandboxed LLM calls improved GPT-4.1 on AIME2024 from 26.7% to 43.3% without any RL training. Modularity enforces operation isolation that pure prompting cannot guarantee, eliciting pre-existing reasoning capability.
Rasa's dialogue understanding architecture generates domain-specific commands instead of classifying intents, eliminating annotation requirements, handling context naturally, and scaling without degradation—treating understanding as pragmatics rather than semantics.
Tool-enabled LLMs drift from user intent through silent tool chaining. Conversation analysis reveals insert-expansions—clarifying intent, scoping responses, enhancing appeal—as a formal framework for proactive user consultation that prevents misunderstanding instead of recovering from it.
CollabLLM demonstrates that standard RLHF training optimizes for immediate helpfulness, discouraging models from asking clarifying questions or offering multi-turn insights. Multi-turn-aware rewards that estimate long-term interaction value enable active intent discovery and genuine collaboration.
Models trained on semantically empty or deliberately incorrect instructions achieve comparable performance to those trained on full correct instructions, achieving 43% vs random baseline 42.6%. The semantic content of instructions appears largely irrelevant; what transfers is knowledge of the output space.