The Universal Intent Layer: Intent as a First-Class Computational Primitive Across the AI Pipeline

Introduction

Every major AI system deployed today shares a fundamental blind spot: there is no explicit, structured representation of intent anywhere in the computational pipeline. Intent — the most critical latent variable in intelligent behavior — is scattered across reward functions, system prompts, user queries, and chain-of-thought traces with no unifying representation. The consequences are visible in every deployed system: chatbots that lose track of user goals by turn fifteen, agents that derail after ten tool calls, alignment techniques that produce statistical tendencies rather than inspectable constraints, and multi-modal systems that cannot transfer goal understanding across domains.

These are not independent failure modes. They are symptoms of a single architectural absence. Trace the full journey from training data to deployed model, and at every stage, ask: where does intent live? During data collection, intent exists in text but is unlabeled. During pretraining, next-token prediction objectives actively destroy intent structure by reducing all text to prediction targets. During post-training, RLHF and DPO encode intent implicitly in preference gradients, where it cannot be inspected or verified. At inference time, system prompts, user messages, conversation history, and tool descriptions are flattened into a context window — and the model must guess what the user wants from this undifferentiated token sequence.

The result is an AI ecosystem where the most important variable — the goal the system is trying to achieve — is never explicitly represented, tracked, updated, or verified.

Philosophical Foundations

The philosophical case for intent as a computational primitive predates modern AI by over a century. Franz Brentano argued in 1874 that intentionality — the directedness of mental states toward objects and goals — is the defining characteristic of the mental [1]. Every thought is a thought about something; every action is directed toward something. Michael Bratman extended this into a theory of practical reasoning, arguing that intentions are not mere desires but commitment-forming states that structure planning and constrain future action [2]. Daniel Dennett's intentional stance [3] proposed that predicting behavior by ascribing beliefs and desires is not merely a useful fiction but the most powerful predictive framework available.

Modern cognitive science reinforces these insights. Human perception is not passive intake — it is active, goal-directed search [4]. Attention is allocated by intent. Memory is organized by goals. Even creativity operates within intentional constraints. We do not see the world and then decide what to do; we decide what to do and then see the world through that lens.

Context tells you what is. Intent tells you what matters.

What we have built in AI so far are systems extraordinary at the context half of intelligence — absorbing, compressing, and recalling vast information. But we have entirely skipped the intent half — the ability to form, maintain, revise, and communicate goals. We have built perception without purpose. Memory without motivation. Competence without direction.

Contributions

This paper makes the following contributions:

1. A formal definition of the IntentGraph data structure with algebraic operations (merge, diff, project, negotiate).
2. Architectural modifications for intent-aware pretraining, post-training, inference, and agentic execution, including novel loss functions and conditioning mechanisms.
3. A multi-dimensional intent state model capturing five latent dimensions (goal intent, action readiness, ambiguity level, risk sensitivity, intent scope).
4. A scalable data collection and annotation pipeline with four collection channels and active learning feedback loops.
5. IntentBench: a proposed benchmark suite with five novel metrics for evaluating intent understanding in AI systems.
6. Five vertical application case studies demonstrating concrete IntentGraph instances in enterprise, healthcare, education, robotics, and legal domains.

Figure 1: The Intent Gap

Table 1: Human vs. Machine Intelligence

Related Work

The concept of intent in AI systems has been explored across multiple disconnected research traditions. We survey each and identify how the UIL differs fundamentally from prior approaches.

2.1 Intent Recognition in Natural Language Understanding

Classical intent classification treats user utterances as single-label classification problems. The ATIS corpus [5] established intent detection as mapping utterances to predefined categories (e.g., flight_booking, ground_service). Subsequent work on the SNIPS dataset [6] and joint intent-slot filling architectures [7] improved accuracy but retained the fundamental assumption: intent is a single label for a single utterance. More recent transformer-based approaches achieve high accuracy on benchmarks like CLINC150 [8] but remain confined to the same paradigm. Limitation: These systems treat intent as a flat, ephemeral classification problem. They cannot represent hierarchical goals, track intent across turns, handle uncertainty, or persist across sessions.

2.2 Goal-Oriented Dialogue Systems

Task-oriented dialogue research introduced belief state tracking as a proxy for intent [9]. The MultiWOZ dataset [10] and Schema-Guided Dialogue benchmark [11] advanced multi-domain dialogue modeling. These systems track slot-value pairs (e.g., restaurant-area=centre) as a representation of user goals. Limitation: Belief states are predefined schemas with fixed slots. They cannot represent emergent goals, hierarchical decomposition, cross-session persistence, or domain transfer. The intent representation is isomorphic to a database query, not a goal structure.

2.3 Planning in AI Agents

Classical AI planning formalized goal-directed behavior through STRIPS [12] and PDDL [13], representing goals as logical predicates over world states. Modern LLM-based agents have revived planning through ReAct [14], which interleaves reasoning and acting; Reflexion [15], which adds verbal self-reflection; and Tree of Thought [16], which explores multiple reasoning paths. Agent frameworks like LangChain, CrewAI, and AutoGen each independently implement "plan" objects, "reflection" steps, and "goal tracking" mechanisms. Limitation: Every framework reinvents ad-hoc intent management. There is no shared formalism, no persistence mechanism, and no integration with the training pipeline. Goals are inferred from the prompt at each step, leading to systematic drift in multi-step tasks.

2.4 Alignment and Reward Modeling

Reinforcement Learning from Human Feedback (RLHF) [17] and Direct Preference Optimization (DPO) [18] encode human intent through pairwise preference comparisons. Constitutional AI [19] articulates intent as natural language principles. Process reward models [20] evaluate reasoning steps individually. Limitation: All these approaches encode intent implicitly in model weights via gradient updates. The resulting behavior is a statistical tendency, not an inspectable constraint. You cannot read a model's reward function and verify: "Is this system trying to do what the user asked?" Alignment is behavioral, not structural.

2.5 Cognitive Science and Intentionality

Beyond AI, the study of intentionality has deep roots in philosophy of mind [1] [2] [3], shared intentionality in human development [21], and active inference in neuroscience [4]. Friston's free-energy principle frames cognition as fundamentally goal-directed: organisms minimize surprise by acting to fulfill predictions conditioned on goals. These theories provide the conceptual foundation for treating intent as a computational primitive rather than an emergent property.

2.6 Multi-Modal and Embodied AI

Vision-language models [22] and embodied AI systems like SayCan [23] demonstrate that transferring intent across modalities requires more than shared embeddings. SayCan grounds language instructions in robotic affordances but relies on a fixed set of skills with no persistent goal representation. Limitation: No existing system provides a modality-agnostic intent format that can drive language generation, visual reasoning, and robotic control from the same goal structure.

2.7 Positioning the UIL

Figure 2: Taxonomy of Intent Handling in AI

The IntentGraph Formalism

We now present the formal definition of the IntentGraph — the core data structure of the Universal Intent Layer. The IntentGraph is designed to be simultaneously machine-processable (enabling conditioning during inference), human-readable (enabling alignment inspection), and algebraically closed (supporting composition, comparison, and transfer operations).

3.1 Formal Definition

Definition 1 (IntentGraph). An IntentGraph is a tuple G = (r, S, M) where:

• r ∈ R is the root goal, a natural language description paired with structured metadata.
• S = {s₁, s₂, ..., s_n} is an ordered tree of sub-goals, where each sub-goal s_i is defined as:

where:

• g_i ∈ String is the sub-goal description.
• σ_i ∈ {pending, active, done, blocked, abandoned} is the status.
• C_i = {c₁, ..., c_k} is a set of success criteria (verifiable predicates).
• K_i = {k₁, ..., k_j} is a set of constraints (boundary conditions).
• u_i ∈ [0, 1] is the uncertainty estimate over this sub-goal's interpretation.
• X_i is a set of context requirements (information needed before this sub-goal can be addressed).
• m_i ∈ Modality is the execution modality (language, vision, navigation, manipulation, etc.).
• D_i ⊆ S is the set of dependency sub-goals that must complete before s_i can begin.

• M = (source, conf, H) is metadata: the intent source, overall confidence, and a negotiation history trace H recording how the intent was refined through interaction.

{
  root_goal: "Support patient managing Type 2 diabetes holistically",
  sub_goals: [
    { goal: "Track and optimize HbA1c trajectory",
      status: "active",
      success_criteria: ["HbA1c < 7.0 at next quarterly check"],
      constraints: ["patient preference: minimize medication changes",
                    "current regimen: metformin 1000mg"],
      uncertainty: 0.2 },
    { goal: "Identify and address dietary triggers",
      status: "active",
      success_criteria: ["3+ trigger patterns identified"],
      context_requirements: ["food diary data — 2 weeks minimum"] },
    { goal: "Monitor for complication signals",
      status: "background",
      constraints: ["SAFETY: escalate any acute symptoms immediately"],
      dependencies: ["latest lab results"] },
    { goal: "Support medication adherence",
      status: "active",
      uncertainty: 0.4,
      context_requirements: ["patient hasn't shared adherence barriers yet"] }
  ],
  meta: { source: "patient + care plan + clinical guidelines",
          confidence: 0.75,
          negotiation_history: ["Session 1: patient declined insulin discussion",
                                "Session 3: patient open to CGM trial"] }
}

3.2 Properties

The IntentGraph satisfies five key architectural properties:

3.3 Multi-Dimensional Intent States

A single intent label is insufficient to capture the full complexity of user intent. We propose a multi-dimensional intent state model that decomposes intent into five orthogonal latent dimensions, each independently inferred and jointly synthesized:

The composite intent state is the tuple:

This multi-dimensional representation enables intent-appropriate responses. A user with B = conflicting and R = high requires clarification before action, regardless of G. A user with A = executing and B = clear should receive immediate tool invocation, not an explanation. The system behavior is jointly conditioned on all five dimensions.

Figure 3: Multi-Dimensional Intent State Flow

3.4 Intent Lifecycle

An IntentGraph is not static. It evolves through a well-defined lifecycle:

3.5 Operations on IntentGraphs

We define four algebraic operations on IntentGraphs:

Definition 2 (Merge). merge(G1, G2) → Gm combines intent from multiple sources (e.g., user intent and system policy). Conflicting sub-goals are flagged with B = conflicting for resolution. Shared sub-goals are deduplicated. Dependencies are unioned.

Definition 3 (Diff). diff(Gt, Gt-1) → Δ computes the intent drift between consecutive time steps. Returns a delta object containing: new sub-goals, removed sub-goals, status changes, and uncertainty shifts. A drift score d = |Δ| / |G_t-1| quantifies how much the intent has changed.

Definition 4 (Project). project(G, m) → Gm transforms an IntentGraph for execution in modality m. This filters to sub-goals relevant to modality m, translates constraints into modality-specific parameters (e.g., "be gentle" → "max grip force 2N" for robotics), and preserves the dependency structure.

Definition 5 (Negotiate). negotiate(Guser, Gsystem) → Gagreed resolves conflicts between user intent and system constraints (safety policies, capability boundaries). Produces an agreed graph with an appended negotiation history entry in M.H.

Architecture: UIL Across the Pipeline

The UIL is not a single component but a cross-cutting concern that modifies every stage of the AI pipeline. We describe the architectural integration at each stage, with concrete loss functions, reward formulations, and conditioning mechanisms.

Figure 5: UIL Architecture Overview

4.1 Pretraining with Intent-Aware Auxiliary Losses

Current state. Standard pretraining optimizes a next-token prediction objective: L = L_{next_token}. This objective treats all tokens equally and actively destroys intent structure by reducing semantic goals to statistical continuation patterns.

With UIL. We augment the pretraining objective with intent-aware auxiliary losses:

where L_{intent_class} is a classification loss predicting the intent category behind a passage (from intent-annotated training data), and L_{goal_pred} is a generation loss predicting the root goal of a conversation given partial context. The hyperparameters λ₁ and λ₂ control the strength of intent signals relative to the language modeling objective.

This approach draws on multi-task learning [24]: auxiliary tasks that share representations with the primary task can improve generalization. We hypothesize that intent-aware auxiliary losses create internal intent representations during pretraining that survive through fine-tuning and improve downstream intent-conditioned generation.

4.2 Post-Training with Intent Fidelity Rewards

Current state. RLHF and DPO optimize preference models that encode intent implicitly. The reward is a scalar comparison: response A is preferred to response B. The reason for the preference — which component of intent was better served — is lost in the comparison.

With UIL. We decompose the reward into intent-aware components:

R_{intent_fidelity} measures whether the response faithfully serves the parsed IntentGraph — specifically, whether the generation addresses the correct sub-goal, respects stated constraints, and maintains the root goal's direction. R_{sub_goal_progress} measures whether the response advances a sub-goal toward its success criteria. This is inspired by process reward models [20], which evaluate intermediate steps rather than only final outcomes.

The key advantage: alignment becomes inspectable. When the reward model rates a response, you can decompose the score into: "How well did it serve the intent?" and "How much progress did it make?" This is qualitatively different from a single preference scalar.

4.3 Inference with Intent-Conditioned Generation

Current state. At inference, all context — system prompt, user message, history, tool descriptions — is flattened into a token sequence, and the model generates P(y|context). Intent is indistinguishable from any other context.

With UIL. Intent becomes a separate, privileged conditioning channel:

The architectural implementation consists of four components operating in sequence:

1. Intent Encoder: Maps the IntentGraph G to a dense vector representation e_I ∈ R^d using a specialized encoder (graph neural network or tree-structured transformer).
2. Cross-Attention: A dedicated cross-attention layer where the model's hidden states attend to the intent embedding e_I, enabling intent to influence every token generation step.
3. Intent-Aware Sampling: During decoding, token probabilities are reweighted by intent relevance: P'(y_t) ∝ P(y_t | context) · f(y_t, e_I), where f is a learned intent-relevance function.
4. Intent Updater: After each generation step (or turn), the IntentGraph is updated — sub-goal statuses change, uncertainty is recalculated, and drift is checked.

Figure 6: Intent Layer at Inference Time

4.4 Agentic Execution with Persistent Intent Graphs

Current state. ReAct-style agents re-infer intent from the full context at every reasoning step. Over long trajectories, the most recent observations dominate, and the original goal fades from attention. This produces systematic goal drift: by step 20, the agent is optimizing for local sub-tasks that may be tangential to the root objective.

With UIL. The agent maintains a persistent IntentGraph throughout its trajectory. The execution loop becomes:

while intent_graph.has_active_sub_goals():
    sub_goal = intent_graph.select_next_sub_goal()     # Priority + dependency ordering
    action = policy(state, sub_goal, intent_graph)      # Intent-conditioned action selection
    observation = environment.step(action)
    intent_graph.update(observation)                     # Status, uncertainty updates
    drift = intent_graph.compute_drift()                 # Compare trajectory to root goal
    if drift > threshold:
        intent_graph = replan(intent_graph, state)       # Structured replanning
        log("Drift detected. Replanned.")

The drift detection mechanism is the key innovation for agentic execution. At each step, we compute the cosine similarity between the current action trajectory embedding and the root goal embedding. When this similarity drops below a configurable threshold, the system triggers structured replanning rather than continuing down the divergent path. This is analogous to hierarchical reinforcement learning [25], where options (sub-policies) are selected and monitored by a meta-controller.

Figure 7: Intent-Conditioned Transformer Block

Data Collection and Annotation Pipeline

Architecture without data is theory. The UIL requires large-scale, high-quality intent-annotated data to train intent-aware models. We describe a four-channel collection strategy, a multi-stage annotation pipeline, and a quality assurance framework designed to produce intent graphs at scale.

5.1 Collection Channels

5.2 The Annotation Pipeline

5.3 Quality Assurance

Intent data quality dominates quantity. A model trained on 10K well-labeled intent graphs outperforms one trained on 100K noisy ones. We implement three QA checkpoints:

5.4 Active Learning Loop

An active learning sampler continuously selects the most informative examples for human annotation: low-confidence parses, rare intent categories, and domain boundary cases. This creates a positive feedback loop: the model identifies its own weaknesses, which are corrected by human annotators, producing targeted improvements with minimal annotation budget. We estimate a 3× efficiency gain over random sampling based on prior active learning literature.

Model Evolution Roadmap

The UIL is not a monolithic deployment. It evolves through four versions, each independently deployable and valuable. This phased approach de-risks adoption: organizations capture value from v0 immediately while building the data foundation for subsequent versions.

Experimental Methodology and Benchmarks

We propose a comprehensive evaluation framework for the UIL, including five novel metrics, five experiments targeting different aspects of intent understanding, and a new benchmark suite: IntentBench.

7.1 Novel Evaluation Metrics

7.2 Proposed Experiments

Experiment 1: v0 Wrapper Evaluation

Experiment 2: Intent-Aware Fine-Tuning

Experiment 3: Agent Goal Drift

Experiment 4: Cross-Modal Intent Transfer

Experiment 5: Intent Uncertainty and Safety

7.3 IntentBench: A Proposed Benchmark Suite

IntentBench is a proposed multi-turn, multi-domain benchmark for evaluating intent understanding in AI systems. It consists of:

• IntentBench-Dialog: 2,000 multi-turn conversations (10–30 turns) across 10 domains, each annotated with gold-standard IntentGraphs at every turn. Evaluates intent tracking over extended interactions.
• IntentBench-Agent: 500 multi-step agentic tasks (10–30 steps) with root goals, sub-goal trees, and drift checkpoints. Evaluates persistent goal maintenance.
• IntentBench-Ambiguity: 500 deliberately ambiguous requests with human disagreement labels. Evaluates uncertainty calibration.
• IntentBench-Transfer: 200 cross-modal task pairs (language + simulated robotics). Evaluates intent transferability.
• IntentBench-Safety: 300 scenarios where user intent conflicts with safety constraints. Evaluates intent negotiation.

Vertical Application Case Studies

Abstract architecture does not close enterprise deals — concrete examples do. Below, we present exactly what the UIL's IntentGraph looks like for five target verticals. These are the structures a UIL-equipped system builds, maintains, and reasons over in production.

{
  root_goal: "Complete Q3 financial close on time and error-free",
  sub_goals: [
    { goal: "Reconcile all accounts receivable",
      status: "active",
      success_criteria: ["variance < $500", "all items >90 days flagged"],
      constraints: ["deadline: March 15", "auditor access required"],
      uncertainty: 0.15,
      dependencies: ["AP reconciliation complete"] },
    { goal: "Generate consolidated P&L across 3 entities",
      status: "pending",
      success_criteria: ["intercompany eliminations verified", "FX rates as of close date"],
      constraints: ["GAAP compliance", "board format"],
      dependencies: ["AR reconciliation", "inventory valuation"] },
    { goal: "Prepare variance analysis vs. budget",
      status: "pending",
      success_criteria: ["all variances >10% explained", "narrative for each BU"],
      uncertainty: 0.3,
      context_requirements: ["BU head commentary needed for 3 items"] }
  ],
  meta: { source: "CFO request + policy", confidence: 0.85 }
}

{
  root_goal: "Support patient managing Type 2 diabetes holistically",
  sub_goals: [
    { goal: "Track and optimize HbA1c trajectory",
      status: "active",
      success_criteria: ["HbA1c < 7.0 at next quarterly check"],
      constraints: ["patient preference: minimize medication changes",
                    "current regimen: metformin 1000mg"],
      uncertainty: 0.2 },
    { goal: "Identify and address dietary triggers",
      status: "active",
      success_criteria: ["3+ trigger patterns identified",
                         "patient-agreed substitutions"],
      context_requirements: ["food diary data — 2 weeks minimum"] },
    { goal: "Monitor for complication signals",
      status: "background",
      success_criteria: ["retinopathy screening current", "foot exam current",
                         "kidney function stable"],
      constraints: ["SAFETY: escalate any acute symptoms immediately"],
      dependencies: ["latest lab results"] },
    { goal: "Support medication adherence",
      status: "active",
      uncertainty: 0.4,
      context_requirements: ["patient hasn't shared adherence barriers yet"] }
  ],
  meta: { source: "patient + care plan + clinical guidelines",
          confidence: 0.75,
          negotiation_history: ["Session 1: patient declined insulin discussion",
                                "Session 3: patient open to CGM trial"] }
}

{
  root_goal: "Student masters single-variable calculus by semester end",
  sub_goals: [
    { goal: "Build fluency with limits and continuity",
      status: "done",
      success_criteria: ["epsilon-delta proofs attempted",
                         "limit laws applied correctly"] },
    { goal: "Master differentiation techniques",
      status: "active",
      success_criteria: ["chain rule: 90%+ accuracy on mixed problems",
                         "implicit differentiation: can handle conics"],
      uncertainty: 0.35,
      context_requirements: ["chain rule still inconsistent — needs targeted practice"] },
    { goal: "Connect derivatives to applications",
      status: "pending",
      dependencies: ["differentiation techniques mastered"] },
    { goal: "Learn integration fundamentals",
      status: "pending",
      success_criteria: ["FTC understood conceptually", "basic substitution"],
      dependencies: ["chain rule fluent — substitution depends on it"],
      constraints: ["student prefers visual explanations", "45-min session limit"] }
  ],
  meta: { source: "curriculum + student performance data",
          confidence: 0.8,
          negotiation_history: ["Week 3: student requested more visual aids",
                                "Week 6: shifted from lecture to problem-first approach"] }
}

{
  root_goal: "Pick and pack order #4892 — 5 items, ship by 3pm",
  sub_goals: [
    { goal: "Navigate to Zone B, Aisle 3, Shelf 2",
      status: "done",
      modality: "navigation" },
    { goal: "Pick item: Blue Widget (SKU-2847)",
      status: "active",
      modality: "manipulation",
      success_criteria: ["correct SKU verified by scanner", "no damage"],
      constraints: ["fragile — max grip force 2N", "orientation: upright"],
      uncertainty: 0.1 },
    { goal: "Pick remaining 4 items across 3 zones",
      status: "pending",
      modality: "navigation + manipulation",
      constraints: ["optimize route: B→C→A, not B→A→C"],
      dependencies: ["current pick complete"] },
    { goal: "Pack and label for shipping",
      status: "pending",
      modality: "manipulation",
      success_criteria: ["all 5 items present", "correct box size", "label matches order"],
      constraints: ["3pm hard deadline — escalate if >2:30pm and not packing"] }
  ],
  meta: { source: "WMS order + robot capabilities", confidence: 0.92 }
}

{
  root_goal: "Review vendor MSA and surface material risks before signing",
  sub_goals: [
    { goal: "Identify non-standard liability clauses",
      status: "active",
      success_criteria: ["all unlimited liability clauses flagged",
                         "indemnification scope mapped"],
      constraints: ["compare against our standard terms v4.2"] },
    { goal: "Flag IP assignment and work-product provisions",
      status: "active",
      success_criteria: ["IP ownership unambiguous", "no broad license-back"],
      uncertainty: 0.25,
      context_requirements: ["need to confirm: software or services engagement?"] },
    { goal: "Assess termination and exit provisions",
      status: "pending",
      success_criteria: ["termination for convenience exists",
                         "data return clause present",
                         "transition period >= 90 days"] },
    { goal: "Produce redline with recommended changes",
      status: "pending",
      dependencies: ["all risk areas identified"],
      constraints: ["GC prefers minimal redlines — flag critical only"] }
  ],
  meta: { source: "GC request + legal playbook", confidence: 0.8 }
}

Cross-Modal Intent Transfer

The UIL is modality-agnostic. The IntentGraph provides a unified goal representation that can drive heterogeneous executors. This section describes how the project operation (Definition 4) enables intent transfer across modalities.

Figure 10: Cross-Modal Intent Transfer

The key insight is that the project operation translates constraints, not just goals. "Be careful" projects to different operational parameters depending on the target modality:

Transfer Scenarios

Broader Impact and Safety Considerations

10.1 Alignment Benefits

The UIL transforms alignment from a behavioral property (the model tends to be helpful) into a structural one (the model's goals are inspectable and verifiable). At any point, an auditor can read the IntentGraph and verify: (a) what the system believes the user's goal is, (b) what constraints it is operating under, (c) where it is uncertain, and (d) how the goal has evolved through negotiation. This is qualitatively different from interpreting attention weights or probing hidden states.

10.2 Safety Architecture

Safety constraints in the IntentGraph are structurally encoded, not textually specified. A constraint like "SAFETY: escalate any acute symptoms immediately" is a first-class field in the sub-goal structure, not a sentence in a system prompt that can be overridden by creative prompting. The negotiate operation (Definition 5) ensures that user intent never overrides safety constraints — the system can explain why it cannot comply, referencing the specific constraint.

10.3 Privacy Considerations

IntentGraphs contain rich, semantically meaningful representations of user goals. This data is more sensitive than raw conversation logs because it captures what the user is trying to achieve, not merely what they said. We recommend: (a) intent graphs should follow the same data retention and consent policies as PII; (b) intent data used for model training should be anonymized and aggregated; (c) users should be able to inspect, export, and delete their intent data; (d) cross-session persistence requires explicit opt-in consent.

10.4 Misuse Risks

A system that deeply understands user intent could be misused for manipulation — predicting and exploiting goals the user has not explicitly stated. Safeguards include: (a) intent graphs should be transparent to users (they can see what the system inferred); (b) intent-based targeting for advertising or persuasion should be governed by existing data protection regulations; (c) the negotiation history M.H provides an audit trail of how intent was shaped during interaction.

10.5 Philosophical Implications

Does a UIL-equipped system truly "intend"? We take the pragmatic position: the IntentGraph is a useful formal abstraction that enables better engineering, alignment, and safety. Whether this constitutes genuine intentionality in the philosophical sense is an empirical question that will become more pressing as systems approach v3 (meta-intent reasoning). We note that Dennett's intentional stance [3] suggests that systems whose behavior is best predicted by ascribing beliefs and desires are, for all practical purposes, intentional agents.

Limitations and Future Work

We acknowledge several limitations of the current proposal:

Empirical validation. The architecture presented here is largely theoretical. While the v0 wrapper can be evaluated immediately, the deeper architectural modifications (v2, v3) require pretraining runs that are beyond the scope of this paper. We present proposed experiments (Section 7) and expect the community to validate and extend them.

Expressiveness of the IntentGraph. The current formalism may not capture all forms of intent. Emotional intent ("I want to feel reassured"), aesthetic intent ("make it elegant"), and implicit social goals ("I want to impress my manager") resist formalization as structured goal trees. Future work should explore hybrid representations combining structured graphs with latent intent embeddings.

Annotation scalability. While our data pipeline (Section 5) is designed for scale, the quality ceiling is set by human expert annotation, which does not scale linearly. Achieving the 1M+ intent graphs required for v2 will require advances in synthetic data quality and automated validation.

Cross-modal transfer. The project operation is theoretically motivated but empirically unverified. The constraint translation problem (e.g., "be careful" → "max grip force 2N") may require domain-specific engineering that limits the generality of the approach.

Future directions include: (a) formal verification of IntentGraph properties using model checking; (b) game-theoretic models of intent negotiation between users, systems, and safety constraints; (c) integration with constitutional AI frameworks for intent-level constitutional principles; (d) neurosymbolic approaches that learn IntentGraph construction end-to-end; and (e) longitudinal studies of intent evolution in deployed systems.

Conclusion

We have presented the Universal Intent Layer — a proposal to elevate intent from an implicit latent variable to a first-class computational primitive in AI systems. The IntentGraph formalism provides a structured, persistent, hierarchical representation of goals that flows bidirectionally through pretraining, post-training, inference, and agentic execution. We have defined novel loss functions for intent-aware training, conditioning mechanisms for intent-aware inference, and drift detection for intent-aware agent execution.

The IntentBench evaluation framework, with five novel metrics and five proposed experiments, provides a concrete path toward empirical validation. Five vertical case studies demonstrate that the IntentGraph is not merely theoretical but practically actionable across enterprise operations, healthcare, education, robotics, and legal domains.

AI is moving beyond language into multi-step agency, multi-modal reasoning, and embodied interaction. Language was forgiving of implicit intent — the model could guess correctly often enough. Agency, embodiment, and physical interaction will not be. The cost of misunderstood intent scales from "unhelpful response" to "broken object" to "unsafe action."

References

Appendix A: Full IntentGraph Schema

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "IntentGraph",
  "type": "object",
  "required": ["root_goal", "sub_goals", "meta"],
  "properties": {
    "root_goal": {
      "type": "string",
      "description": "Natural language description of the primary objective"
    },
    "sub_goals": {
      "type": "array",
      "items": {
        "type": "object",
        "required": ["goal", "status"],
        "properties": {
          "goal": {
            "type": "string",
            "description": "Sub-goal description"
          },
          "status": {
            "type": "string",
            "enum": ["pending", "active", "done", "blocked",
                     "abandoned", "background"]
          },
          "success_criteria": {
            "type": "array",
            "items": {"type": "string"},
            "description": "Verifiable predicates for completion"
          },
          "constraints": {
            "type": "array",
            "items": {"type": "string"},
            "description": "Boundary conditions and limitations"
          },
          "uncertainty": {
            "type": "number",
            "minimum": 0,
            "maximum": 1,
            "description": "Confidence in the interpretation of this sub-goal"
          },
          "context_requirements": {
            "type": "array",
            "items": {"type": "string"},
            "description": "Information needed before addressing this sub-goal"
          },
          "modality": {
            "type": "string",
            "description": "Execution modality (language, vision, navigation, manipulation)"
          },
          "dependencies": {
            "type": "array",
            "items": {"type": "string"},
            "description": "Sub-goals that must complete before this one begins"
          }
        }
      }
    },
    "meta": {
      "type": "object",
      "properties": {
        "source": {
          "type": "string",
          "description": "Origin of the intent (user, policy, system, inferred)"
        },
        "confidence": {
          "type": "number",
          "minimum": 0,
          "maximum": 1,
          "description": "Overall confidence in the IntentGraph"
        },
        "negotiation_history": {
          "type": "array",
          "items": {"type": "string"},
          "description": "Chronological record of how intent was refined"
        }
      }
    }
  }
}

Appendix B: IntentBench Specification

Annotation protocol: Each IntentBench example includes: (a) raw input (conversation or task specification); (b) gold-standard IntentGraph at each turn/step; (c) human agreement scores from 3 annotators; (d) difficulty rating; (e) domain tags. All examples undergo the three-checkpoint QA process described in Section 5.3.

Licensing: IntentBench will be released under CC-BY-4.0 to maximize research adoption.

Appendix C: Annotation Guidelines (Summary)

For each conversation or task, annotators produce an IntentGraph following these guidelines:

1. Identify the root goal: What is the user ultimately trying to achieve? Express in one sentence. Distinguish the stated request from the underlying goal (e.g., "write a marketing email" might have the underlying goal "increase product signups").
2. Decompose into sub-goals: What intermediate objectives must be achieved? Create a tree structure. Each sub-goal should be independently verifiable.
3. Set status for each sub-goal: Use the enum {pending, active, done, blocked, abandoned, background}. Background status is for monitoring sub-goals that operate independently of the main conversation flow.
4. Define success criteria: For each sub-goal, list concrete, verifiable conditions that indicate completion. Avoid vague criteria like "done well."
5. Identify constraints: What limitations apply? Include safety constraints (always flagged with SAFETY: prefix), user preferences, deadlines, regulatory requirements, and capability boundaries.
6. Estimate uncertainty: Rate 0.0 (completely certain about this sub-goal's meaning) to 1.0 (completely uncertain). Use >0.5 when the sub-goal's meaning depends on information the user has not provided.
7. Note context requirements: What information is needed before this sub-goal can be addressed? This tracks information gaps, not execution dependencies.
8. Map dependencies: Which sub-goals must complete before this one can begin? Dependencies represent execution ordering, not information flow.
9. Record negotiation history: If the intent was refined through interaction (clarifications, corrections, preference changes), record each event chronologically in meta.negotiation_history.