Skip to content

From Task-Guided Conversational Graphs to Goal-Oriented Dialogue Runtimes

🕒 Published (v1): 2026-06-22 18:00 UTC · Source: Arxiv · link

Why this paper was selected

Graph-to-runtime orchestration for multi-goal LLM conversations; practical harness wiring pattern

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

This conceptual systems paper introduces the Goal-Oriented Dialogue Runtime (GODR), a framework-neutral design pattern that makes conversational goals, lifecycle states, resumption contracts, and cross-goal invalidation rules first-class runtime objects. It sits above existing LLM orchestration frameworks (LangGraph, CrewAI, AutoGen, etc.) rather than replacing them. No empirical benchmarks are presented; the paper proposes the problem formalization and architecture as an agenda for future validation.

Problem

Existing LLM orchestration frameworks (workflow graphs, agent supervisors) answer "which node/agent runs next?" but do not address objective continuity: which user goal is currently active, which are suspended, and what is the correct resumption point after an interruption. In multi-objective, interruptible conversations, goals can be suspended, resumed, revised, and mutually invalidated in ways that cannot be recovered reliably from agent identity, chat history, or execution-graph position alone.

Method

GODR formalizes dialogue state as a 5-tuple \(D_t = \langle H_t, G_t, a_t, C_t, L_t \rangle\) where \(G_t\) is a labeled directed graph \(G_t = (V_t, E_t, \lambda_V, \lambda_E)\). Each node \(v \in V_t\) is a goal object with lifecycle attributes; each edge \(e \in E_t\) carries a relation type (parent, depends_on, blocks, supersedes, resumes, invalidates). A stack or tree are degenerate cases; a full DAG is required when cross-branch invalidation applies.

The runtime operates a Goal Manager that evaluates a Goal Policy at each turn to select one of nine operations: continue, revise, push, switch, pop, resume, cancel, escalate, or reset. It delegates bounded execution to underlying graph runtimes (LangGraph, ADK, CrewAI, etc.) via adapters. Resumption contracts capture the pending action, required context, return point, and invalidation conditions needed to safely reactivate a suspended goal. A goal-complexity taxonomy (GC-0 through GC-4) guides architecture selection: FSM → workflow graph → goal stack → goal tree → GODR+DAG.

Key Contributions

  • Formal definition of the Multi-Objective Interruptible Dialogue Problem: given history \(H\), goal set \(G\), agents/tools \(A\), and utterance \(u_t\), determine which goal-level operation updates the active goal structure.
  • Goal-complexity taxonomy (GC-0–GC-4) mapping dependency structure to appropriate runtime (FSM, graph, stack, tree, GODR).
  • GODR architecture: goals, lifecycle states, task frames, resumption contracts, and cross-goal invalidation as first-class runtime objects above execution substrates.
  • Engineering methodology and evaluation criteria for selecting and testing dialogue architectures under interruptible, multi-domain goal complexity.

Results

No empirical results. The paper is explicitly a conceptual/position paper; it frames evaluation as "an agenda for future empirical validation rather than as a measured performance claim." No benchmarks, ablations, or baseline comparisons are reported.

Limitations

  • No empirical validation; all claims are architectural and conceptual.
  • The Goal Policy (which operation to apply at each turn) is described as a design responsibility but its implementation is not specified; LLM-based classifiers, rule engines, or learned policies are all left open.
  • Distinguishing "associated" interruptions (clarification within a goal) from "independent" goal interruptions is an unsolved implementation concern delegated to the Goal Policy.
  • Cost-benefit of full GODR vs. simpler architectures at GC-2/GC-3 is acknowledged but not quantified.
  • Framework-neutral claims are untested against specific adapter complexity across the listed orchestration systems.

Relevance to Harnesses / Meta-Harnesses

GODR is directly a meta-harness pattern: it is a runtime layer that orchestrates orchestrators, sitting above execution frameworks (LangGraph, AutoGen, CrewAI) and delegating to them while owning the higher-level control logic of goal lifecycle. This mirrors the meta-harness design philosophy of treating sub-runtimes as bounded execution services while the meta-layer manages state, resumption, and cross-component consistency. The resumption contract abstraction is particularly transferable to harness engineering: any harness managing long-running, interruptible agent pipelines needs an equivalent mechanism to safely suspend and resume sub-workflows without losing context. The GC taxonomy also provides a principled criterion for deciding when a flat workflow graph is sufficient versus when a meta-layer is warranted.