The User Model Gap in Agentic Workflows

TL;DR

• Agentic workflows invest in task planning, tool orchestration, and memory, but ignore user modeling, which means every agent handoff loses context about who is being served
• In a multi-agent enterprise workflow, user-specific context tends to be lost or generalized into defaults by the third agent boundary
• A persistent self-model shared across agents preserves user context across boundaries and lets agents act more precisely

The user model gap in agentic workflows is the absence of persistent user context across agent boundaries, causing each handoff to lose information about who is being served. Tracing user context through a multi-agent enterprise workflow shows user-specific context lost or generalized by the third agent, resulting in technically correct outputs that miss the user’s actual needs. This post covers why prompt passing fails to solve context loss, how a persistent self-model layer preserves user context, and why shared user models make agents coordinate better than shared task plans.

Context Degrades at Every Boundary

Consider how user context moves through a 5-agent enterprise workflow: intake agent, research agent, analysis agent, drafting agent, review agent. This is the kind of pipeline that enterprise AI teams are building right now.

The intake agent understood the user well. It had the original prompt, the conversation history, the user’s explicit instructions. By the time the research agent received its task, it had the what but not the who, and it searched for sources broadly instead of prioritizing sources the user trusts. It gathered information at the wrong depth because it did not know the user’s expertise level.

By the third agent, the analysis agent, much of the user-specific context can be lost or generalized into defaults. The analysis may use a framework the user explicitly rejected in a previous session. The drafting agent may produce formal, hedged prose for a user who prefers direct, concise language. The review agent has no way to know any of this is wrong.

Each agent completed its task. The workflow “succeeded.” The output did not serve the user.

This is the fundamental problem: agent handoffs preserve the task graph but destroy the user graph. Every boundary between agents is a context cliff.

Why Prompt Passing Does Not Solve This

The obvious objection: just pass the user context forward in the prompt. Include user preferences in the system message for each agent. Thread the user information through the workflow.

This fails for three reasons.

Context window pressure. Each agent in a multi-step workflow already has a dense prompt: task instructions, tool schemas, intermediate results, safety constraints. Adding a comprehensive user profile competes for context window space. In practice, teams truncate the user context first because the task context feels more immediately necessary.

Context staleness. The user context you pass at the start of a workflow may be outdated by the time the fourth agent acts on it. If the user interacted with a different workflow between agent 2 and agent 4, their preferences or goals may have shifted. Static context injection cannot account for a living, evolving user.

Context interpretation. Different agents need different aspects of the user model. The research agent needs to know what sources the user trusts and at what depth. The drafting agent needs communication style preferences. Passing a monolithic user context blob to every agent wastes tokens and dilutes signal. Each agent needs a tailored view of the user.

A persistent, queryable self-model solves all three. It is not in the context window. It is an API call. It is always current. It reflects the latest observations. It is tailored: each agent queries only the beliefs it needs.

1// At each agent boundary: query the self-model← Persistent user layer
2async function agentStep(agentId: string, task: AgentTask) {
3  const selfModel = await clarity.getSelfModel(task.userId);
4
5  // Each agent queries only the beliefs it needs← Tailored context
6  const userContext = await clarity.query(task.userId, {
7    domain: agentId, // 'research' | 'analysis' | 'drafting'
8    maxBeliefs: 10,
9    minConfidence: 0.7
10  });
11
12  const result = await agent.execute(task, { userContext });
13
14  // Observation feeds back into the self-model← Model evolves
15  await clarity.observe(task.userId, {
16    agent: agentId,
17    action: task.type,
18    outcome: result.userSatisfaction
19  });
20
21  return result;
22}

The Coordination Multiplier

The user model gap is not just about individual agent quality. It is about coordination.

In multi-agent systems, agents need to agree on what “good” looks like for this output. Without a shared user model, each agent optimizes locally. The research agent maximizes coverage, the analysis agent maximizes rigor, the drafting agent maximizes polish. These local optima conflict. Coverage fights with conciseness. Rigor fights with accessibility. Polish fights with directness.

A shared self-model provides a global optimization target: this user’s definition of “good.” The research agent knows coverage matters less than source credibility for this user. The analysis agent knows rigor means practical implications, not academic thoroughness. The drafting agent knows polish means clarity, not formality.

When agents share a user model, they coordinate without explicit coordination protocols. The user model is the alignment signal that makes the whole system coherent.

This is why self-model injection can reduce unnecessary agent actions. Agents stop overproducing at each step to compensate for uncertainty about what the next agent (or the user) actually needs. When you know who you are serving, you can be precise instead of comprehensive.

The Enterprise Stakes

For enterprise teams, the user model gap is not an abstraction. It is a support ticket problem, a rework problem, and a trust problem.

Every time a multi-agent workflow produces output that technically answers the question but misses the user’s actual need, someone has to redo the work manually. Every time an agent uses the wrong tone, cites the wrong kind of source, or operates at the wrong level of detail, trust in the system erodes.

Enterprise agentic deployments that ignore the user model gap will hit a ceiling. The workflows will be sophisticated. The outputs will be adequate. But “adequate” is not what justifies the enterprise price tag. Users expect the system to know them, and every handoff that forgets who they are makes the system feel generic.

What to Do Next

Task graphs make agents autonomous. User graphs make agents aligned. Give your agents the user layer they are missing.

References

1. “RAG is Not Agent Memory,”
2. context window management strategies
3. scarce resource with a finite “attention budget”
4. context engineering
5. Context Rot study

Related

• How to Ship Personalization Without a Data Science Team
• Self-Models vs Fine-Tuning: When Each Makes Sense
• RAG Pipelines Need a User Layer