Planner-Grounder-Corrector (PGC) Architecture

• Planner-Grounder-Corrector (PGC) is a modular agent design that distinctly separates planning, grounding, and corrective mechanisms for effective tool use.
• It adapts P-C-G concepts for Korean settings by using upfront planning, schema-validated tool calls, and limited replanning to handle execution errors.
• The architecture enhances efficiency by reducing redundant reasoning and optimizing tool call accuracy, achieving high task success rates.

Searching arXiv for the cited paper and related Planner-Grounder-Corrector terminology. {"^^^^^^^^2query2 (Jeon et al., 19 Sep 2025) \2^^^^^^^^"SLM-Based Agentic AI with P-C-G: Optimized for Korean Tool Use\"", "max_results": 5} Searching for "Planner Grounder Corrector" on arXiv to check for directly named PGC papers. {"^^^^^^^^2query2 Grounder Corrector\" arXiv", "max_results": ^^^^2arXiv (Jeon et al., 19 Sep 2025) \2query2^^^^} Planner-Grounder-Corrector (PGC) denotes a modular agent decomposition in which high-level planning, grounding of abstract intent into executable actions, and correction of failures are separated. In the arXiv paper "SLM-Based Agentic AI with P-C-G: Optimized for Korean Tool Use" (&&&^^^^2query2^^^^&&&), the closest instantiated form is not an explicit PGC architecture but a Planner-Caller-Generator (P-C-G) system for Korean tool use. The paper is best understood as a Planner-Caller-Generator (P-C-G) agent design for Korean tool use, not as an explicit Planner-Grounder-Corrector (PGC) architecture. It nevertheless contains several PGC-like ideas: it separates high-level planning from execution, uses a validating intermediate step that “grounds” abstract plans into executable tool calls, and includes limited replanning when execution breaks the plan. The paper’s best characterization is therefore that P-C-G is PGC-adjacent: conceptually yes, partially; formally no (&&&^^^^2query2^^^^&&&).

^^^^2arXiv (Jeon et al., 19 Sep 2025) \2^^^^. Conceptual scope and architectural interpretation

The paper’s main contribution is a role-specialized, SLM-based agent architecture for tool use that is designed to be practical in Korean-language settings. Its three modules are Planner, Caller, and Generator. The key technical idea is not just “use small models,” but structure the tool-use pipeline so that planning is done once up front rather than repeatedly, tool arguments are normalized and schema-checked before execution, and final response generation is separated from call execution (&&&^^^^2query2^^^^&&&).

Within a PGC interpretation, the closest mapping is straightforward but imperfect.

PGC term	P-C-G analogue	Qualification
Planner	Planner	direct correspondence
Grounder	Caller	grounding is embedded in execution and validation
Corrector	limited replanning / error handling	no distinct Corrector module

The paper explicitly states that the correspondence is imperfect. There is no explicit Grounder module by name; grounding is embedded in the Caller. There is also no dedicated Corrector module; corrections are handled by validation logic and by replanning. The Generator is not a Corrector. A common misconception is therefore to read P-C-G as a renaming of PGC. The paper does not support that interpretation. Instead, it presents a practical agent architecture with PGC-like functionality, especially if “grounding” is interpreted as schema-validated tool execution and “corrector” as exception-driven replanning rather than as a standalone module (&&&^^^^2query2^^^^&&&).

2. Planner: upfront tool-chain design

The Planner receives the user’s instruction/^^^^^^^^2query2 and a list of available tools as tool_info, each with a name and brief description. Its output is a structured plan containing thought, tool_chain, and next. The control label next is one of caller, reject, or conclusion. In the paper’s format, the Planner is effectively asked what tools are needed, in what order, and whether execution should continue (&&&^^^^2query2^^^^&&&).

{ "thought": "...core reasoning...", "tool_chain": ["tool_a", "tool_b", "..."], "next": "caller" | "reject" | "conclusion" }

A major design point is that the Planner is not called after every tool invocation as in a ReAct-style loop. Instead, the system first makes a single upfront plan; the Caller executes that plan sequentially; and the Planner is re-invoked only when necessary, such as when a tool call fails, a tool returns an unexpected format, results contradict the planned sequence, or information turns out to be insufficient. The paper summarizes this as “plan once, execute many, replan only on exceptions or decision points” (&&&^^^^2query2^^^^&&&).

This planning regime is central to the paper’s efficiency argument. The architecture is designed to reduce redundant reasoning and unnecessary planner invocations. A plausible implication is that the Planner serves as the locus of deliberate control, while downstream stages are intended to be narrower and more mechanically constrained. That division of labor is also what makes the architecture resemble the “Planner” portion of a PGC decomposition.

3. Grounding through the Caller

The Caller turns the Planner’s abstract tool_chain into an executable API call. Its job is threefold: tool-call preparation, tool execution, and result normalization. In preparation, it synthesizes arguments and validates them against schema constraints. During execution, it invokes the selected tool. In normalization, it converts tool outputs into a common schema, checks for errors, and determines whether to continue (&&&^^^^2query2^^^^&&&).

The paper explicitly says that the Caller performs pre-/post-validation over required vs. optional fields, data types, and admissible ranges/constraints, including enums, patterns, and min/max constraints. This is important because the Caller is positioned not merely as a function-call wrapper but as a reliability layer. The standardized output is a normalized call object:

{ "name": "<tool_name>", "arguments": { "<param1>": "<param1 value>" } }

The normalized object contains the tool name and an arguments dictionary with the synthesized parameter values. This interface makes the Caller modular and tool-agnostic. In PGC terms, this is the stage that most closely resembles grounding: the Caller “grounds” the Planner’s abstract plan into executable API calls by instantiating parameters, validating schema/value constraints, executing the tool, and normalizing the response (&&&^^^^2query2^^^^&&&).

The paper’s most distinctive mechanism at this stage is the Korean-first value policy. The Caller enforces the rule that value fields are kept in Korean by default; conversion to English or codes is allowed only when the schema explicitly requires it; and exceptions are narrowly whitelisted, such as English-only fields, enums, and regex/format-constrained fields. The stated motivation is to reduce execution failures caused by frequent Korean-to-English code switching in Korean settings. The paper notes that incorrect translation of user names, place names, and other values can break search queries, reservation requests, government-service lookups, and backend identifier matching. This suggests that grounding is not only about syntactic schema compliance but also about preserving semantically exact local-language values under backend constraints (&&&^^^^2query2^^^^&&&).

4. Correction as validation and limited replanning

There is no separate Corrector module in the PGC sense. Instead, correction is distributed across the Caller’s validation and error handling and the Planner’s on-demand replanning. The paper describes this correction-like behavior through three mechanisms: validation failure handling in the Caller, rejection of impossible requests (reject), and limited Planner re-invocation when execution breaks (&&&^^^^2query2^^^^&&&).

The explicit control flow is:

^^^^2arXiv (Jeon et al., 19 Sep 2025) \2^^^^. Planner produces a tool_chain.

1. Caller executes the first tool and subsequent tools in sequence.
2. If information is insufficient or execution fails, Planner is called again.
3. Once sufficient information is available, Generator produces the final answer.

This is a structured loop, but notably not a three-stage PGC pipeline with an explicit separate correction module. The paper is unambiguous on this point: Generator is not a Corrector. The Generator takes the original user request, the accumulated tool outputs, and the dialogue context and minimal metadata, and produces the final natural-language response. It integrates the tool results, summarizes and restructures them, and outputs the final answer in the user’s requested style. The paper emphasizes that the Generator uses the base model without additional fine-tuning and a minimal chat template; it is responsible for producing a polished response such as a summary, a table, a report, or another structured natural-language output (&&&^^^^2query2^^^^&&&).

A common misconception is to equate any post-execution language generation step with correction. The paper explicitly rejects that reading. Correction in this architecture is primarily control-flow correction: validation catches malformed or inadmissible calls, and replanning is triggered on exceptions or decision points rather than run as an iterative correction loop over all outputs. This makes the system more conservative than a fully explicit Corrector design.

5. Formalization and evaluation protocol

The paper includes two compact formalizations: a structured Planner output schema and planning-efficiency metrics. For samples judged correct, it compares the actual number of tool calls PRESERVED_PLACEHOLDER_^^^^2query2^^^^ with the optimal number PRESERVED_PLACEHOLDER_^^^^2arXiv (Jeon et al., 19 Sep 2025) \2^^^^ and defines:

$\begin{aligned} \text{Under-planning} &= \frac{\left|\{\, i\in\mathcal{C}\mid k_{\hat{i}}<k_{\text{opt},i}\,\}\right|}{\left|\mathcal{C}\right|},\[4pt] \text{As-planned} &= \frac{\left|\{\, i\in\mathcal{C}\mid k_{\hat{i}}=k_{\text{opt},i}\,\}\right|}{\left|\mathcal{C}\right|},\[4pt] \text{Over-planning} &= \frac{\left|\{\, i\in\mathcal{C}\mid k_{\hat{i}}>k_{\text{opt},i}\,\}\right|}{\left|\mathcal{C}\right|}. \end{aligned}$

These metrics matter because the paper’s main efficiency claim is that the upfront plan reduces unnecessary tool calls. The paper also defines a successful task through Task Success Rate (TSR): a task is successful only if it addresses the core intent, uses tools logically, and is complete (&&&^^^^2query2^^^^&&&).

The evaluation setup is detailed. The dataset has 4^^^^2query2query2^^^^ examples, ^^^^2arXiv (Jeon et al., 19 Sep 2025) \2query2query2^^^^ per category:

• Single-chain
• Multi-chain
• Missing Parameters
• Missing Functions

The evaluation assumes Korean queries and Korean tool/parameter specifications. To make comparisons fair, the paper enforces a common input/output format, a shared tool-use interface, and matched conditions for baseline models. Scoring is done using Claude 4 as an LLM judge, averaged over five runs. The paper uses this protocol for tool-use correctness, final-answer quality, task success, and constraint handling. The main metrics are tool-use accuracy / call accuracy, overall quality, Task Success Rate (TSR), token usage, and latency; it also separately evaluates planning accuracy via under-/as-/over-planning, execution-stage quality, and constraint awareness (&&&^^^^2query2^^^^&&&).

6. Empirical profile and status relative to PGC

The reported results are specific. For planning, the proposed system achieves 92.3% As-planned and ^^^^2arXiv (Jeon et al., 19 Sep 2025) \2^^^^.6% Over-planning. For tool use, the Caller reaches 75.^^^^2query2^^^^% call accuracy, the best among compared models. On Single-chain, the system records 95.6% call accuracy and 9^^^^2arXiv (Jeon et al., 19 Sep 2025) \2^^^^.2% overall. On Multi-chain, it reaches 33.8% call accuracy—best—and 62.4% overall—second best after GPT-4o-mini at 67.^^^^2query2^^^^%. On Missing Parameters, performance is 66.6%; the paper explicitly notes that parameter completion remains a weakness for SLM-based agents. On Missing Functions, the system is strongest at 9^^^^2arXiv (Jeon et al., 19 Sep 2025) \2^^^^.2%, best among all compared models. The efficiency profile is TSR: 79.7%, slightly above GPT-4o-mini at 79.3%; Tokens average: 436^^^^2query2^^^^.3, the fewest among the SLMs compared; and Latency: 9.^^^^2arXiv (Jeon et al., 19 Sep 2025) \2^^^^ s, competitive though not the fastest (&&&^^^^2query2^^^^&&&).

These results support the paper’s empirical conclusion that the P-C-G design offers a good balance of quality, tool-use reliability, and cost efficiency. They also clarify the status of the architecture relative to Planner-Grounder-Corrector. The system has a clear Planner, a credible grounding/execution layer in the Caller, and a correction-like mechanism through validation and limited replanning. At the same time, it lacks both an explicitly named Grounder and a dedicated Corrector. The best interpretation is therefore the one stated by the paper itself: P-C-G is not explicitly a Planner-Grounder-Corrector architecture, but it implements a PGC-like division of labor, where planning is explicit, grounding is embedded in the Caller, and correction is implicit through validation and limited replanning (&&&^^^^2query2^^^^&&&).