Inter-Task Chaining: Systems-Level Compositions

• Inter-Task Chaining is the structured composition of sequential tasks, ensuring that a predecessor’s output becomes a compatible input for the next stage.
• It spans varied domains such as desktop automation, robotics, and language model pipelines, using techniques like directional compatibility search and latent state alignment.
• The approach enhances overall task completion through backward finetuning and state optimization, though challenges remain in preserving session coherence and managing handoff brittleness.

Inter-task chaining is the composition of multiple tasks, operations, skills, or reasoning stages such that the output, terminal state, latent representation, or control decision of one stage becomes the operative input to a subsequent stage. In recent research, the term spans desktop agents that must preserve state across objectives, robot systems that must hand off between learned skills, workflow grammars that connect trigger–action programs, prompt and model pipelines in LLM systems, and organizational models in which adjacent production steps are bundled into contiguous AI-executed chains (Siu et al., 19 Jun 2026, Lee et al., 2021, Ito et al., 2020, Demirer et al., 14 Jun 2026). The central technical issue is not mere sequencing, but compatibility at the handoff: evaluator preservation, state validity, schema conformance, initiation-set coverage, latent-space alignment, or reusable hidden-state interfaces.

1. Conceptual scope

Across the literature, the chained object varies by domain. In desktop evaluation, ChainWorld composes atomic OSWorld tasks into long horizon desktop workloads through directional compatibility search while preserving the source evaluators, yielding 347 chains of length two to four (Siu et al., 19 Jun 2026). In workflow parsing, a TAP chain is formed by chaining the action of one task to the trigger of a subsequent task through a machine-executable meaning representation with Call(channel, next) links (Ito et al., 2020). In robot manipulation, the chained objects are closed-loop skills or subtask policies, with success determined by whether the predecessor terminates inside the successor’s effective initiation region (Lee et al., 2021). In AI automation theory, chains are contiguous blocks of steps executed by AI, where all steps except the last are fully automated and the last step is AI-augmented (Demirer et al., 14 Jun 2026).

Setting	Chained unit	Representative mechanism
Desktop workloads	atomic OSWorld tasks	directional compatibility search
Workflow automation	trigger–action programs	Call(channel, next)
Robot manipulation	sequence of closed-loop skills	terminal state regularization
LLM systems	prompts, tools, or models	prompt chaining / KV hidden state sharing
Embodied planning	basic vision-language sub-capabilities	scheduler with per-capability context

This breadth suggests that inter-task chaining is best understood as a systems-level abstraction rather than a domain-specific technique. The chained entity may be symbolic, continuous, latent, or institutional, but the same design question recurs: how to make a predecessor’s effect admissible, useful, and economical for a successor.

2. Formal interfaces and handoff conditions

A common mathematical pattern is explicit modeling of admissible transitions. In T-STAR, successful skill chaining requires alignment between the predecessor’s terminal-state distribution and the successor’s starting-state distribution:

$$p_{\mathrm{term}(i)}(s) \approx p_{\mathrm{start}(i+1)}(s),$$

with the equivalent set inclusion condition $\beta_i \subseteq I_{i+1}$ (Lee et al., 2021). T-STAR operationalizes this by training an initiation-set discriminator and adding a terminal-state reward

$$R_i^{\mathrm{TSR}}(s; \omega) = 1\{s \in \beta_i\} \cdot D_{i+1}^\omega(s),$$

so that upstream policies are rewarded for terminating where the next policy is prepared to start (Lee et al., 2021).

ViSkill generalizes the handoff problem from adjacent compatibility to long-range success probability. Its chaining policy selects subgoals for each subtask, while a state value function estimates the expected probability of completing the entire task from the current state:

$$V_{\pi_C}(s^i) := \mathbb{E}_{\pi_C,\pi_L}[r_T] = \mathrm{Prob}(r_T = 1).$$

The handoff criterion is therefore not simply “can the next skill start,” but “does this transition state maximize downstream chain completion across all remaining skills” (Huang et al., 2023).

Generative Skill Chaining expresses the same principle probabilistically. For a two-step chain, the composed distribution is

$$p_\Phi(s^{(0:2)}, a^{(0:1)} \mid s^{(0)}) \propto \frac{q_{\pi_1}(s^{(0)}, a^{(0)}, s^{(1)}) \, q_{\pi_2}(s^{(1)}, a^{(1)}, s^{(2)})}{q_{\pi_2}(s^{(1)})},$$

so inter-skill consistency is enforced by dividing out the shared intermediate marginal (Mishra et al., 2023). This formulation makes the successor’s precondition and the predecessor’s effect a joint generative object rather than a hard symbolic boundary.

In symbolic workflow systems, the handoff is encoded syntactically. The Workflow Patterns Grammar defines

$$\mathit{func} = \mathrm{Call}(\mathit{type}~\mathrm{channel},~\mathit{wpg}?~\mathrm{next}),$$

making continuation part of the node itself (Ito et al., 2020). When two sequence patterns are connected, duplicated trigger/action nodes are suppressed through Sequence(null, Function C), which is a grammar-level device for preserving tree structure while expressing chaining (Ito et al., 2020).

In prompt/model chains, the handoff may be latent rather than textual. FTHSS replaces plain-text passing with direct KV reuse:

$$K = [K_{\mathrm{prev}}; K_{\mathrm{curr}}], \qquad V = [V_{\mathrm{prev}}; V_{\mathrm{curr}}],$$

allowing downstream queries to attend over upstream hidden states without re-prefilling their text (Lyu et al., 16 Feb 2025). This turns the handoff condition into one of architectural compatibility: same base Transformer, same tokenizer, and consistent positional handling under RoPE (Lyu et al., 16 Feb 2025).

3. Architectural realizations

One architectural family treats chaining as explicit routing among specialized modules. The Global Workspace model uses an LSTM controller that emits a softmax gate over modules and updates a shared workspace by additive integration:

$$gw(t) = g_V(t) e_V(V(t)) + g_O(t) O(t) + g_D(t) e_D(D(t)).$$

For addition, the learned schedule is Input → Increment × k → Output, where the controller repeatedly reuses the same operator through the workspace, rather than learning a direct mapping from inputs to answers (Chateau-Laurent et al., 28 Feb 2025). This is inter-operation chaining internal to a single recurrent computation.

A second family externalizes chaining into a visible control graph. AI Chains represents the overall process as a directed acyclic graph whose nodes are LLM primitives such as Classification, Rewriting, Split points, Ideation, and Compose points. Intermediate artifacts are surfaced for editing, comparison, and local reruns, so chaining becomes transparent and user-steerable rather than an opaque monolithic prompt (Wu et al., 2021). The tutoring system in “Empowering Private Tutoring by Chaining LLMs” similarly decomposes the system into interaction, reflection, and reaction, with task-specific tools connected by memories such as Course Plan, Current Objective, Quiz Pool, Learning Profile, and Learning History (Chen et al., 2023).

A third family implements chaining as cross-task feedback. TaskWeave jointly models moment retrieval and highlight detection by converting one task’s predictions into a guiding mask for the other. Moment-guided feedback forms a mask $\xi_{m2m}$ and gates the highlight input as

$J = X_{hd} + (X_{hd} \odot \xi_{m2m} 1^T),$

while highlightness-guided feedback gates the retrieval memory in the opposite direction (Yang et al., 2024). Chaining here is not serial execution of disjoint tasks, but mutual modulation between decoders.

Embodied systems make the scheduler itself a chaining mechanism. RoboAgent defines a capability set C = {EG, OG, SD, AD, ES} and a scheduler call

$\beta_i \subseteq I_{i+1}$0

followed by capability calls

$\beta_i \subseteq I_{i+1}$1

Each capability maintains its own context, and the scheduler updates global history from capability feedback, especially object-grounding and execution-summarization signals (Xu et al., 9 Apr 2026). This yields explicit sub-capability chaining inside a single VLM.

Finally, recent interpretability work argues that chaining can also be internal to a single forward pass. “Internal Chain-of-Thought” reports that distinct subtasks are learned at different network depths and executed sequentially across layers, with layerwise masking and cross-task patching exposing a consistent handoff from intermediate to final answers (Yang et al., 20 May 2025). A common misconception is therefore to equate inter-task chaining only with externally serialized prompts or tools; the literature includes both explicit external chains and latent internal schedules.

4. Learning and optimization of chain components

Several lines of work optimize chain quality by training components specifically for handoff robustness rather than standalone performance. T-STAR first pretrains each skill with environment reward plus GAIL/AMP reward, then fine-tunes skill $\beta_i \subseteq I_{i+1}$2 with the successor’s discriminator score at the terminal state:

$\beta_i \subseteq I_{i+1}$3

This keeps downstream initiation sets compact instead of repeatedly widening them, which the paper argues becomes sample-inefficient as chain length grows (Lee et al., 2021).

ViSkill uses demonstration-guided RL for each subtask and then trains a chaining policy with SAC plus self-imitation learning. The central intervention is backward finetuning: policy $\beta_i \subseteq I_{i+1}$4 receives an augmented reward that includes the feasibility estimate $\beta_i \subseteq I_{i+1}$5 of the successor. This makes earlier subtasks optimize for downstream solvability rather than only local reward (Huang et al., 2023). Sequential Dexterity applies a closely related idea in dexterous manipulation, where a transition feasibility function over the last 10 states of the predecessor predicts the expected return of the successor and is used both for backward finetuning and runtime policy switching (Chen et al., 2023).

Generative Skill Chaining replaces discrete switching logic with score composition over independently trained diffusion models. Plans are generated by summing triplet scores, subtracting blended node scores, and adding classifier guidance for constraints, so that all skills are sampled in parallel while respecting inter-skill dependencies (Mishra et al., 2023). The optimization target is the full chain distribution rather than local policy improvement.

RoboAgent uses a multi-stage training pipeline: behavior cloning with expert plans, DAgger training on model-collected trajectories relabeled by simulator internals, and reinforcement fine-tuning of the scheduler with Expert-Induced Policy Optimization. This is noteworthy because the scheduler is optimized on capability sequences and recovery behavior, not merely on atomic action outputs (Xu et al., 9 Apr 2026).

Inter-task chaining also appears in continual learning, where the objective is to preserve useful compatibility across tasks rather than avoid all interference. ISYANA combines task-to-task similarity and synaptic-to-task relevance through

$\beta_i \subseteq I_{i+1}$6

and converts this into node-varying learning rates via an exponential gating rule. The effect is to let neurons accept relevant concept transfer while preventing them from embracing distinct concepts (Fubing et al., 2021). Although this is not a sequential pipeline in the usual sense, it treats cross-task reuse as a controlled chaining of representations over time.

5. Scheduling, search, and organizational chaining

A separate body of work studies how chains should be ordered, bundled, or scheduled once compatibility is given. In the theory of AI automation, production is modeled as an ordered sequence of steps $\beta_i \subseteq I_{i+1}$7, and firms choose when to let AI execute multiple adjacent steps as a single chain with one human check at the end. The short-run time-optimal AI strategy for a job with $\beta_i \subseteq I_{i+1}$8 ordered steps can be computed in time $\beta_i \subseteq I_{i+1}$9 by dynamic programming, and the long-run joint problem of chaining, task design, and job design admits a recursive formulation plus a fully polynomial-time approximation scheme with runtime $$R_i^{\mathrm{TSR}}(s; \omega) = 1\{s \in \beta_i\} \cdot D_{i+1}^\omega(s),$$0 (Demirer et al., 14 Jun 2026). The paper’s main claim is that chaining shifts verification from a marginal cost at each step to a fixed cost at the end of the chain, which breaks step-level comparative advantage logic and produces threshold-like productivity gains (Demirer et al., 14 Jun 2026).

In classical multiprocessor scheduling, chained tasks are precedence-constrained unit-time multiprocessor tasks. The paper proves that longest chain maximum processor scheduling is optimal for uniform chains and monotone chains for both splitable and non-splitable multiprocessor unit time task chains, while scheduling arbitrary chains of non-splitable multiprocessor unit time tasks is NP-complete and the splitable case remains open (Agrawal et al., 2015). Here, chaining is a hard resource-allocation object rather than a learned policy.

Hierarchical RL offers another scheduling perspective. The supervisory level chooses when to continue the current task, when to switch, and which task to resume next, while lower-level task controllers estimate task-specific utilities. The root-level policy compares these utilities under switch costs and delayed rewards, producing a hierarchically optimal task-interleaving policy that outperforms a myopic baseline in a six-task problem (Gebhardt et al., 2020). This is inter-task chaining under uncertainty rather than deterministic pipeline execution.

For combinatorial optimization, explicit inter-task distance is used to plan transfer itself. In PFSP scheduling, the distance from task $$R_i^{\mathrm{TSR}}(s; \omega) = 1\{s \in \beta_i\} \cdot D_{i+1}^\omega(s),$$1 to the order-isomorphic set of task $$R_i^{\mathrm{TSR}}(s; \omega) = 1\{s \in \beta_i\} \cdot D_{i+1}^\omega(s),$$2 is defined by the residual

$$R_i^{\mathrm{TSR}}(s; \omega) = 1\{s \in \beta_i\} \cdot D_{i+1}^\omega(s),$$3

with a normalized distance $$R_i^{\mathrm{TSR}}(s; \omega) = 1\{s \in \beta_i\} \cdot D_{i+1}^\omega(s),$$4 used to gate complete-solution transfer, partial-solution transfer, solution evolution, and latent-space transformation (Li et al., 2023). The resulting multi-task scatter search uses the measured distance to decide whether tasks should be chained directly, transformed first, or left unconnected.

6. Empirical findings across domains

Empirical results show that chaining improves capability but remains difficult, especially as horizon length, distribution shift, or state-management demands increase. ChainWorld exposes this directly. It contains 347 chains of length two to four, compares a single-turn rendering with a multi-turn rendering of the same task sequence, and reports that across four current computer use agents the maximum chain completion is 31% (Siu et al., 19 Jun 2026). Multi turn evaluation improves completion for three models, but both protocols remain challenging; single-turn failures concentrate on artifact precision, whereas multi-turn failures more often reflect session management problems such as fragmented progress and later turn disengagement (Siu et al., 19 Jun 2026).

In robot manipulation, T-STAR reports average task progress of $$R_i^{\mathrm{TSR}}(s; \omega) = 1\{s \in \beta_i\} \cdot D_{i+1}^\omega(s),$$5 on table_lack and $$R_i^{\mathrm{TSR}}(s; \omega) = 1\{s \in \beta_i\} \cdot D_{i+1}^\omega(s),$$6 on chair_ingolf, versus $$R_i^{\mathrm{TSR}}(s; \omega) = 1\{s \in \beta_i\} \cdot D_{i+1}^\omega(s),$$7 and $$R_i^{\mathrm{TSR}}(s; \omega) = 1\{s \in \beta_i\} \cdot D_{i+1}^\omega(s),$$8 for Policy Sequencing, and improves end-to-end success from 59% to 87% on table_lack and from 0% to 56% on chair_ingolf (Lee et al., 2021). ViSkill reports success rates of 85.24% on BiPegTransfer, 81.76% on BiPegBoard, and 57.09% on MatchBoardPanel, outperforming T-STAR on all three tasks and showing that long-term value-informed termination improves chaining over local criteria (Huang et al., 2023). Sequential Dexterity reports overall success of $$R_i^{\mathrm{TSR}}(s; \omega) = 1\{s \in \beta_i\} \cdot D_{i+1}^\omega(s),$$9 on Building Blocks and $$V_{\pi_C}(s^i) := \mathbb{E}_{\pi_C,\pi_L}[r_T] = \mathrm{Prob}(r_T = 1).$$0 on Tool Positioning, with more than 30% improvement from allowing up to three autonomous policy switches (Chen et al., 2023).

In multimodal understanding, TaskWeave reaches R@[email protected] = 50.06, Avg [mAP](https://www.emergentmind.com/topics/mean-average-precision-map) = 45.38, HD mAP = 39.28, and HIT@1 = 63.68 on QVHighlights validation, with ablations showing additive gains from task-decoupled representations, task-dependent loss, and inter-task feedback (Yang et al., 2024).

In task-oriented dialogue, RealTOD improves Full API Accuracy, surpassing AutoTOD by 37.74% on SGD and SimpleTOD by 11.26% on BiTOD; ablations show that prompt chaining alone produces substantial gains and that combining prompt chaining with fine-grained feedback performs best (Fereidouni et al., 18 Feb 2025). In long legal document classification, chaining summarization, semantic retrieval, and few-shot classification raises GPT-NeoX from about 0.707 test micro-F1 in zero-shot ECHR classification to about 0.779 with the chained 8-shot summary-based pipeline, and a Flan-UL2 chained pipeline reaches about 0.486 test micro-F1 on SCOTUS, surpassing ChatGPT zero-shot micro-F1 of about 0.438 on the reduced set (Trautmann, 2023).

In model-streamlining, FTHSS matches chain-of-model performance while materially improving efficiency. On HQA, TQA, NQ, HQABM25, 2WikiBM25, StrategyQA, ComQA, TruthQA, PubHealth, and 2Wiki BM25, FTHSS tracks the corresponding chain closely, and latency on Llama-3-8B drops from 1.44s to 0.46s at 3000 tokens; KV cache memory remains 137.5 MB instead of scaling to 275.0 MB for two models or 412.5 MB for three models (Lyu et al., 16 Feb 2025).

7. Limitations, misconceptions, and open problems

A recurring misconception is that inter-task chaining is simply a longer prompt or a longer action sequence. The cited work points to stricter requirements: evaluator preservation in desktop benchmarks, schema-aware validation in dialogue, explicit initiation/termination alignment in robot skills, and mask/position compatibility in hidden-state reuse (Siu et al., 19 Jun 2026, Fereidouni et al., 18 Feb 2025, Lee et al., 2021, Lyu et al., 16 Feb 2025). Chaining fails not only because subtasks are hard, but because the interface between them is brittle.

Another misconception is that better local policies automatically yield better chains. T-STAR, ViSkill, and Sequential Dexterity all argue the opposite: local success can enlarge or destabilize the downstream distribution, and long-horizon performance often depends on shaping the predecessor’s terminal state rather than only improving the successor (Lee et al., 2021, Huang et al., 2023, Chen et al., 2023). Likewise, TaskWeave shows that bidirectional feedback is not always symmetrically beneficial, and simultaneous feedback can cause interference (Yang et al., 2024).

The open problems are heterogeneous. ChainWorld indicates that maintaining session coherence and artifact precision over two to four tasks is still far from solved for computer-use agents (Siu et al., 19 Jun 2026). The Global Workspace study notes that full end-to-end discovery of both routing and operation may be harder and could require exploration or auxiliary signals (Chateau-Laurent et al., 28 Feb 2025). T-STAR explicitly leaves theoretical bounds on distribution mismatch and end-to-end success open (Lee et al., 2021). RoboAgent still trails stronger closed-source systems under OOD embodied settings, especially where visual grounding and long-horizon context are unstable (Xu et al., 9 Apr 2026). In classical scheduling, the complexity of arbitrary chains of splitable multiprocessor unit time tasks remains open (Agrawal et al., 2015). Internal mechanistic work suggests that layerwise subtask scheduling exists, but robustly steering these internal chains at scale remains an unresolved question (Yang et al., 20 May 2025).

Taken together, the literature treats inter-task chaining as a unifying problem of compositional control. Whether the medium is desktop state, robot terminal distributions, prompt-generated schemas, scheduler capability calls, or shared KV caches, the decisive question is how to preserve useful structure across boundaries while preventing compounding error, negative transfer, and coordination overhead.