GO-Skill: Goal-Oriented Skill Abstraction

• GO-Skill is a design principle that abstracts temporally extended behaviors by focusing on achieved goals and effects rather than low-level actions.
• It employs diverse representations—symbolic, latent, vector-quantized, and predicate-based—to enable flexible planning and skill reuse.
• GO-Skill balances high-level decision making with specialized low-level execution, enhancing sample efficiency and performance in multi-task and long-horizon tasks.

Searching arXiv for the cited GO-Skill and closely related skill-abstraction papers to ground the article in the provided literature. Goal-Oriented Skill Abstraction (GO-Skill) refers, in the literature considered here, to a family of formulations in which temporally extended behaviors are represented primarily by the goals, effects, or state differences they achieve, and are then lifted into an abstraction that supports planning, transfer, reuse, or hierarchical control. The abstraction itself is not uniform across papers: it may be a propositional symbolic layer induced by options, a learned latent subgoal space, a vector-quantized discrete skill library, a PDDL operator interface, an autonomously discovered goal manifold, a polymorphic goal interface for web agents, or a predicate-based wrapper over black-box skills (Konidaris, 2015, Lin et al., 2022, Cheng et al., 2022, Cartoni et al., 2018, He et al., 9 Jul 2025, Kim et al., 2024, Yu et al., 17 Oct 2025, Yang et al., 22 Nov 2025).

1. Scope and representational forms

A central feature of GO-Skill is that the identity of a skill is tied to what it accomplishes rather than only to the low-level action sequence that realizes it. In some formulations, that accomplishment is expressed as symbolic effects and preconditions; in others, as a state-difference embedding, a latent subgoal, or a site-agnostic interface. This shared emphasis on goal semantics makes GO-Skill a unifying label for several otherwise distinct lines of work.

Representative formulations can be organized by the abstraction carrier they employ.

Work	Abstraction carrier	Primary role
(Konidaris, 2015)	initiation and effect symbols for options	abstraction hierarchy for planning
(Lin et al., 2022)	latent subgoals and tool-specific skills	hybrid discrete-continuous planning
(Cheng et al., 2022)	lifted operators with $PRE$, $EFF^+$, $EFF^-$	planner-guided RL skill growth
(Cartoni et al., 2018)	discovered manifold $O \subset S$ and 1-NN parameterized skill	autonomous goal-space discovery
(He et al., 9 Jul 2025)	vector-quantized discrete skill library	offline multi-task RL
(Kim et al., 2024)	skill-step embeddings $z$ and subgoal generator $f$	long-horizon goal-conditioned control
(Yu et al., 17 Oct 2025)	abstract goals plus concrete implementations	continual web-agent skill reuse
(Yang et al., 22 Nov 2025)	invented predicates and lifted operators	plannable wrappers for black-box skills

Across these works, a recurring pattern is the separation between a high-level choice over skills and a low-level realization of those skills. The high-level component may reason over symbolic states, latent subgoals, or discrete codes; the low-level component may be an option policy, a skill decoder, a tool-specific controller, or a site-specific implementation. This suggests that GO-Skill is best understood as a design principle for abstraction and control, not as a single canonical algorithm.

2. Option-theoretic and symbolic foundations

One foundational formulation begins with the options framework, where a temporally extended action is an option

$o = \langle I_o, \pi_o, \beta_o \rangle,$

with initiation set $I_o \subseteq S$, internal policy $\pi_o(a \mid s)$, and termination condition $\beta_o(s) \in [0,1]$. Replacing primitive actions $EFF^+$0 in an MDP by a set $EFF^+$1 of options yields an SMDP in which one decision step corresponds to invoking an option, executing it until termination, and receiving cumulative reward and transition dynamics over option execution (Konidaris, 2015).

The distinctive GO-Skill step in this formulation is that the abstract representation is specified by the skills themselves. For each option $EFF^+$2, one introduces a propositional symbol for its initiation set and one for its effect set $EFF^+$3, and then defines an abstraction map

$EFF^+$4

The hierarchy is then built by alternating a skill-acquisition phase and a representation-acquisition phase. At level $EFF^+$5, the abstract MDP is

$EFF^+$6

with $EFF^+$7 consisting of options over $EFF^+$8, and $EFF^+$9 obtained by lumping SMDP transitions over grounding sets. The formulation explicitly states that planning in $EFF^-$0 is sound and complete for any start/goal whose grounding matches, and that plans can be refined downward through the hierarchy to the ground MDP (Konidaris, 2015).

The Taxi illustration makes the hierarchy concrete. The base MDP has state variables $EFF^-$1 over a $EFF^-$2 grid and four depots, giving $EFF^-$3. A hand-designed first level uses options $EFF^-$4, after which the abstract state space has size $EFF^-$5. A second level composes passenger-move options, yielding $EFF^-$6 abstract states. Queries aligned with the learned hierarchy can be solved at higher levels, whereas misaligned queries must fall back to lower levels or the base MDP. The same example also illustrates a common misconception: more abstraction does not uniformly reduce computation, because false-positive plan matches and matching overhead can dominate when the query is not expressed in the abstract state variables (Konidaris, 2015).

3. Learned latent goal abstractions

A different line of work treats goal-oriented abstraction as the discovery of an achievable-goal manifold inside a much larger sensory space. In Active Goal Manifold Exploration (AGME), the sensory space is $EFF^-$7, the unknown set of achievable outcomes is a low-dimensional manifold $EFF^-$8, and a parameterized skill is a mapping $EFF^-$9 from goals to policy parameters. AGME maintains an incrementally built repertoire $O \subset S$0 together with corresponding policy parameters $O \subset S$1, constructs a $O \subset S$2-nearest-neighbor graph over discovered outcomes, selects as a basis the outcome with largest mean neighbor distance

$O \subset S$3

and explores by perturbing its policy parameters with isotropic Gaussian noise. The final parameterized skill is then the 1-NN regressor

$O \subset S$4

The reported experiments show $O \subset S$5 success in multiple simulated settings, including both low-dimensional outcomes and raw $O \subset S$6 RGB images, and the paper identifies local smoothness and the absence of stochastic or partially observable outcomes as limitations (Cartoni et al., 2018).

DiffSkill adopts a latent neural abstraction in a deterministic, differentiable MDP for deformable-object manipulation. Short-horizon skills are first extracted per tool by trajectory optimization in a differentiable physics simulator under the loss

$O \subset S$7

where $O \subset S$8 is a Sinkhorn-EMD distance between current and goal particle clouds and the centroid penalty encourages contact. Demonstrations from these optimized rollouts are then used to train a goal-conditioned policy $O \subset S$9, a VAE with latent dimension $z$0, a feasibility predictor $z$1, and a reward predictor $z$2. Long-horizon planning introduces latent subgoals $z$3 and discrete skill indices $z$4, and solves a hybrid optimization over skill sequence and subgoal chain. On LiftSpread, GatherTransport, and CutRearrange, DiffSkill reports normalized score/success of $z$5, $z$6, and $z$7, respectively; ablations state that both discrete skill-choice search and continuous subgoal optimization are crucial (Lin et al., 2022).

Taken together, these latent formulations replace explicit symbolic state abstraction with either a discovered outcome manifold or a learned latent goal space. This suggests a broadening of GO-Skill from symbolic planning interfaces to representation learning procedures in which the relevant abstraction is induced by achievable outcomes and short-horizon skill effects.

4. Planner-coupled operator abstractions in manipulation

In planner-guided manipulation, GO-Skill often appears as an interface between symbolic operators and continuous control. LEAGUE introduces, for each lifted operator

$z$8

an operator-guided state abstraction

$z$9

and a parameterized policy $f$0 trained to achieve $f$1 from states satisfying $f$2. The reward is replaced by an operator-guided reward $f$3, and training resets are harvested from states that satisfy $f$4 but violate $f$5. LEAGUE then grows its skill set in situ: the symbolic planner proposes a plan using the current library, failures are recorded with invocation states, and only the failed skills are retrained until the plan executes successfully without new failures. The learned policies are treated as options whose initiation sets are defined by $f$6, whose termination is reaching $f$7 or timeout, and whose abstract actions are directly compatible with off-the-shelf PDDL planners. Empirically, LEAGUE is reported as the only method to reliably solve the full StowHammer and PegInHole tasks within $f$8 steps; ablating state abstraction cuts sample efficiency by about $f$9 and hurts final success by $o = \langle I_o, \pi_o, \beta_o \rangle,$0; reusing “Pick,” “Pull,” and “Push” from StowHammer to MakeCoffee improves sample efficiency by $o = \langle I_o, \pi_o, \beta_o \rangle,$1 (Cheng et al., 2022).

SkillWrapper extends symbolic GO-Skill to black-box skills observed only through RGB images. It defines a finite set of lifted predicates $o = \langle I_o, \pi_o, \beta_o \rangle,$2 with binary classifiers $o = \langle I_o, \pi_o, \beta_o \rangle,$3, an abstraction function

$o = \langle I_o, \pi_o, \beta_o \rangle,$4

and, for each skill $o = \langle I_o, \pi_o, \beta_o \rangle,$5, a set of lifted operators $o = \langle I_o, \pi_o, \beta_o \rangle,$6. The method actively collects skill-transition data, prompts a vision-language foundation model to invent new predicates whenever current abstractions fail to distinguish transitions, and learns operators by clustering observed transitions by lifted effect sets. The paper states two formal guarantees: every learned operator is supported by at least one real transition in the data buffer, yielding soundness, and under mild i.i.d. assumptions the learned model is probabilistically complete with probability at least $o = \langle I_o, \pi_o, \beta_o \rangle,$7. The learned predicates and operators are exported as a PDDL domain and solved by a classical planner such as K*. Quantitatively, SkillWrapper reports $o = \langle I_o, \pi_o, \beta_o \rangle,$8 on Easy and $o = \langle I_o, \pi_o, \beta_o \rangle,$9 on Hard Robotouille problems, $I_o \subseteq S$0 solved in-domain and $I_o \subseteq S$1 under generalization on Franka Panda, and an improvement from $I_o \subseteq S$2 to $I_o \subseteq S$3 solved on a bimanual Kuka task as $I_o \subseteq S$4 grows from $I_o \subseteq S$5 to $I_o \subseteq S$6 (Yang et al., 22 Nov 2025).

These planner-coupled formulations show a strong version of GO-Skill: the abstraction is not merely a latent bottleneck, but an executable symbolic interface with preconditions, effects, and grounded execution semantics.

5. Offline multi-task and long-horizon goal-conditioned formulations

In offline multi-task reinforcement learning, GO-Skill has been formulated as a three-stage pipeline: goal-oriented skill extraction, skill enhancement, and hierarchical policy learning. A fixed-horizon subtrajectory

$I_o \subseteq S$7

is represented by a goal vector

$I_o \subseteq S$8

and these continuous goal embeddings are discretized by vector quantization into a codebook $I_o \subseteq S$9. A Transformer-based skill decoder reconstructs the $\pi_o(a \mid s)$0-step action window conditioned on the discrete skill embedding, past states, reached-goal history, and past actions, with total extraction loss

$\pi_o(a \mid s)$1

To correct class imbalance, the codebook and goal encoder are frozen, the dataset is partitioned by skill class, minibatches are sampled uniformly across classes, and only the decoder is retrained. A high-level Decision-Transformer policy then predicts skill indices every $\pi_o(a \mid s)$2 steps using focal loss

$\pi_o(a \mid s)$3

The implementation reported for MetaWorld uses $\pi_o(a \mid s)$4, $\pi_o(a \mid s)$5, $\pi_o(a \mid s)$6, 6-layer 8-head Transformers with model dimension $\pi_o(a \mid s)$7, and $\pi_o(a \mid s)$8 training iterations, of which the first $\pi_o(a \mid s)$9 are used for extraction. The paper states that GO-Skill outperforms six baselines by $\beta_o(s) \in [0,1]$0–$\beta_o(s) \in [0,1]$1 in MT50, that performance increases rather than degrades as the number of tasks grows from MT30 to MT50, that a multi-headed variant yields another $\beta_o(s) \in [0,1]$2–$\beta_o(s) \in [0,1]$3 boost, and that in ML45$\beta_o(s) \in [0,1]$4 transfer it exceeds Prompt-DT by over $\beta_o(s) \in [0,1]$5 after only $\beta_o(s) \in [0,1]$6k fine-tuning steps (He et al., 9 Jul 2025).

A related offline formulation, presented as skill-step abstraction for long-horizon goal-conditioned tasks, embeds skills in a finite space $\beta_o(s) \in [0,1]$7 and decomposes a long-horizon goal into a sequence of near-term subgoals reachable by individual skills. The hierarchy includes a state encoder $\beta_o(s) \in [0,1]$8, a subgoal generator $\beta_o(s) \in [0,1]$9, an inverse skill-step dynamics model $EFF^+$00, and a low-level policy $EFF^+$01. Training jointly minimizes

$EFF^+$02

while model-guided rollout augments the dataset with imagined trajectories. The paper argues that reward sparsity is mitigated because long-horizon goals are broken into dense, skill-aligned subgoals, and that goal-distribution shift is handled by iterative model-guided rollouts that expand the support of latent subgoal pairs. On Maze Large shift, the reported zero-shot score is $EFF^+$03 versus $EFF^+$04 for SkiMo+GCSL; on Kitchen Large, $EFF^+$05 versus $EFF^+$06. With 50 episodes of adaptation in Kitchen Large, GO-Skill reaches $EFF^+$07 versus $EFF^+$08 for SkiMo+GCSL, and after 10 episodes it reports $EFF^+$09 versus $EFF^+$10 (Kim et al., 2024).

These offline variants replace direct low-level policy learning with abstraction over fixed-horizon skill segments. One consequence is that long-horizon control becomes a problem of choosing or generating skill-level transitions rather than directly solving sparse-reward credit assignment at the action level.

6. Generalization, misconceptions, and open issues

For web agents, GO-Skill has been formulated as a polymorphic abstraction that explicitly decouples a skill’s abstract goal from its concrete implementation. In a web-navigation POMDP $EFF^+$11, the action space is extended to $EFF^+$12, and each learned skill is represented as

$EFF^+$13

where $EFF^+$14 is a site-agnostic goal descriptor such as “search_for_item(query)” or “add_to_cart(item),” and $EFF^+$15 is a site-specific policy or program conditioned on the current context and goal. The framework induces new abstract classes only when no existing interface matches the demonstrated intent, verifies concrete implementations by replay, and grows a skill library without catastrophic forgetting by registering implementations under parent abstractions. On Mind2Web and WebArena, the reported gains include a $EFF^+$16 improvement in skill reuse on seen websites, a success-rate increase of up to $EFF^+$17 on Mind2Web and $EFF^+$18 on unseen websites, step reductions of over $EFF^+$19, and $EFF^+$20 success in task-free exploration on held-out OneStopShop compared with $EFF^+$21 for SkillWeaver and $EFF^+$22 for the best single-domain specialist (Yu et al., 17 Oct 2025).

A common misconception is that GO-Skill denotes a single formal object. The surveyed literature instead spans option-induced symbolic state abstraction, latent subgoal planning, operator-guided RL, vector-quantized discrete skill libraries, discovered goal manifolds, polymorphic interfaces, and invented predicate vocabularies (Konidaris, 2015, Lin et al., 2022, Cheng et al., 2022, Cartoni et al., 2018, He et al., 9 Jul 2025, Kim et al., 2024, Yu et al., 17 Oct 2025, Yang et al., 22 Nov 2025). Another misconception is that abstraction is always symbolic: some formulations are entirely symbolic and planner-facing, whereas others are purely latent or hybrid. A plausible implication is that the principal invariant across GO-Skill work is not the representation type but the insistence that skill identity be anchored in achieved goals or effects.

The limitations reported in this literature are correspondingly heterogeneous. In abstraction hierarchies, false-positive plan matches are identified as a main cost; in offline multi-task RL, common skills can dominate the codebook and require balanced enhancement; in AGME, local smoothness is assumed and stochastic or partially observable outcomes are left open; in PolySkill, poor abstraction induction, dynamic layouts, and long-tail domains remain unresolved; and in DiffSkill, pure trajectory optimization is explicitly described as vulnerable to poor local optima on long-horizon multi-stage tasks (Konidaris, 2015, He et al., 9 Jul 2025, Cartoni et al., 2018, Yu et al., 17 Oct 2025, Lin et al., 2022). Formal guarantees are also unevenly distributed: soundness and completeness are proved for the skill-symbol hierarchy under matched grounding assumptions, and SkillWrapper provides soundness and probabilistic completeness results, whereas most other formulations rely primarily on empirical validation (Konidaris, 2015, Yang et al., 22 Nov 2025).

Across these works, GO-Skill emerges as a general methodology for compressing behavioral regularities into reusable high-level units whose semantics are goal-defined. Whether those semantics are expressed as propositions, latent vectors, subgoal transitions, discrete codes, abstract interfaces, or invented predicates, the central objective remains the same: to make long-horizon reasoning tractable by shifting control from primitive actions to goal-indexed skills.