GoalAct Framework in Agentic AI

• GoalAct is a modular framework for agentic AI systems that integrates global goal planning with hierarchical, skill-based execution.
• It employs an adaptive feedback loop to replan based on real-time observations, yielding higher success rates on benchmarks like LegalAgentBench.
• The architecture reduces planning complexity by mapping high-level plan steps to specialized skills, ensuring robust and scalable operation.

GoalAct is a modular framework for agentic AI systems that integrates continuously updated global goal planning with hierarchical, skill-based execution. Developed to address fundamental limitations in LLM-based agent workflows—particularly in real-world tool-using and multi-step decision settings—GoalAct enforces global coherence, adaptability, and robust execution by explicitly coupling plan generation with a flexible, well-defined action interface. Empirical benchmarks demonstrate substantially improved success rates and effective scalability, and the architecture has influenced both evaluation and engineering methodologies for agentic systems (Chen et al., 23 Apr 2025).

1. Architectural Foundations and Pipeline Design

GoalAct decomposes intelligent agent operation into dual, tightly coupled modules:

• Global Planning: Maintains a single, evolving plan $G$ comprising a sequence of high-level steps, each mapped to an explicit skill (e.g., Searching, Coding, Writing). After each execution cycle, the plan is re-generated based on current history and recent observations to align long-term progression with the actual environment state.
• Hierarchical Execution: Executes each plan step via a minimal, specialized “skill” interface. Rather than monolithic or ad hoc code invocation, the agent dispatches semantic plan units to targeted skill handlers, each with rigid input/output contracts.

This division counteracts two dominant failure patterns in prior agentic pipelines: (a) local reasoning cycles induced by myopic planning, and (b) fragility from combinatorial monolithic action selection. Figure 1 in (Chen et al., 23 Apr 2025) visualizes this architecture: global planning and skill execution operate as a continuous feedback loop.

Key equations:

$G=(P_1,A_1)\,,(P_2,A_2)\,,\dots,(P_n,A_n)$

$$S_t=\bigl(P_1,A_1,O_1,\dots,P_{t-1},A_{t-1},O_{t-1}\bigr)$$

$G_t \;=\;\pi\bigl(Q\,\mid\,T\,\mid\,S_t\bigr)$

where $Q$ is the initial query, $T$ the available tools, $S_t$ the full stepwise history, and $\pi$ the LLM-based plan update policy.

2. Global Planner: Feedback and Replanning Mechanisms

At each time step $t$, GoalAct’s planner synthesizes a new global plan based on cumulative execution history. Each history tuple includes the plan step, corresponding assigned skill, and the actual resulting observation, creating a granular, dynamically refreshed context for plan recomputation.

Specifically, after each action:

• The tuple $(P_t, A_t, O_t)$ is appended to the running history.
• The planner, via prompt-based LLM orchestration, generates an updated plan $G=(P_1,A_1)\,,(P_2,A_2)\,,\dots,(P_n,A_n)$0 reflecting the latest state.
• This pipeline guarantees that the plan is not static but adaptively tracks, and corrects for, any deviations, tool failures, or unanticipated environmental outcomes encountered during execution.

The policy $G=(P_1,A_1)\,,(P_2,A_2)\,,\dots,(P_n,A_n)$1 is fully prompt-driven, with the ability to condition on the observed outputs and available tools, thus ensuring that long-term sequence constraints and subgoal dependencies remain grounded in realized, non-hypothetical states (Chen et al., 23 Apr 2025).

3. Hierarchical Skill Execution Model

GoalAct restricts execution to a minimal, composable set of action types—termed “skills”—each with a rigorously defined invocation interface. Core examples include:

• Searching: Structured retrieval actions (input: query; output: relevant documents/entries; disallows scripting/branching within call).
• Coding: Python code execution (input: code; output: stdout/results/error; supports arbitrary loops and data processing).
• Writing: Natural language generation (input: text intent; output: pure-language draft).

The executor module maps each $G=(P_1,A_1)\,,(P_2,A_2)\,,\dots,(P_n,A_n)$2 plan step to its skill handler, invoking the corresponding implementation routine. This separation enforces both skill specialization and robust boundary checking, significantly reducing repeated error classes compared to monolithic approaches (Chen et al., 23 Apr 2025).

Pseudocode:

$G=(P_1,A_1)\,,(P_2,A_2)\,,\dots,(P_n,A_n)$8

Additional skills (e.g., Reasoning, Creative-Write) can be injected with minimal extension to the executor.

4. Planning Complexity Reduction and Adaptability

GoalAct reduces the combinatorial planning problem by only enumerating over the space of high-level skill assignments and plan step decompositions, in contrast to prior one-stage or scripting-based frameworks:

• Complexity: By abstracting individual tool calls into skill-level units, the planning search space is logarithmically reduced compared to stepwise, tool-parameter-centric models.
• Adaptability: The skill set itself is modular, and continuous plan recomputation adapts dynamically to shifts in toolchain performance, new error classes, or unforeseen observations.

Empirical results on LegalAgentBench illustrate the scalability of this approach: as the number of reasoning “hops” or complexity of long-form writing increases, GoalAct’s success rate improves more sharply relative to monolithic and local-loop baselines (Chen et al., 23 Apr 2025).

Model	Method	1-hop	3-hop	5-hop	ALL
GPT-4o-mini	ReAct	.9333	.4000	.2583	.6161
	CodeAct	.9058	.4167	.1683	.6275
	GoalAct	.9556	.6250	.4517	.7720

5. Evaluation Methodology and Empirical Results

GoalAct was benchmarked on LegalAgentBench, comprising 300 legal tasks spanning 1–5 hop logical reasoning and long-form drafting scenarios. Each task instance challenged the agent to invoke several types of tools in coherent, interpretable sequences.

Experimental findings:

• Success Rate: GoalAct achieved a 12.22% absolute gain in average success rate over the best prior method across all models and task types.
• Ablation Analysis: Omitting global planning, Searching, Coding, or Writing skills led to measurable declines in overall success (e.g., from 0.8710 to 0.7896 for no global planning).

Metric used:

$G=(P_1,A_1)\,,(P_2,A_2)\,,\dots,(P_n,A_n)$3

where $G=(P_1,A_1)\,,(P_2,A_2)\,,\dots,(P_n,A_n)$4 is the output observation and $G=(P_1,A_1)\,,(P_2,A_2)\,,\dots,(P_n,A_n)$5 is the set of required keys for task $G=(P_1,A_1)\,,(P_2,A_2)\,,\dots,(P_n,A_n)$6.

Hyperparameters included a fixed maximum iteration count ($G=(P_1,A_1)\,,(P_2,A_2)\,,\dots,(P_n,A_n)$7) and deterministic LLM temperature (0) (Chen et al., 23 Apr 2025).

6. Extensibility, Limitations, and Research Implications

GoalAct is highly extensible along two dimensions:

• Skill Set Augmentation: New domain-specific skills or tool wrappers can be injected into the execution pipeline with minimal changes to the planning layer.
• Planner Adaptation: The LLM prompt can be steered to constrain admissible skill options or emphasize intermediate subgoals as dictated by new domains.

Observed limitations:

• The feedback loop assumes skill-level observations are sufficiently informative; noisy or poorly structured outputs can degrade plan quality.
• The initial implementation utilizes a small core skill set; domains requiring multi-agent coordination or tightly coupled toolsets may necessitate deeper executor specialization.

These properties position GoalAct as both a practical agentic AI reference framework and a reusable substrate for further research into robust, skill-composable, and feedback-driven agents.

7. Influence on Evaluation and Engineering Methodologies

GoalAct’s architectural principles have guided subsequent developments in agent evaluation frameworks (e.g., Agent GPA (Jia et al., 9 Oct 2025)) and software engineering methodologies that stress the explicit mapping between goals, plans, and actions. Agent GPA, for example, formalizes agent assessment into metrics for goal fulfillment, plan quality, execution efficiency, and plan adherence, directly operationalizing the type of explicit planning and execution separation advocated by GoalAct.

Furthermore, in the context of crosscutting requirements—security, observability, cost management—pattern languages for aspect-oriented modularization have adopted the GoalAct decomposition into skills and execution traces as canonical structuring tools for reliable production agentic AI (Yu, 28 Feb 2026). This modularity is instrumental for traceability, budgeted autonomy, and compliance with evolving regulatory environments (Alenezi, 11 Feb 2026), reinforcing GoalAct’s centrality in contemporary agentic system design.