FORGE: Functional Reasoning & Grounded Execution

• FORGE is a research paradigm that integrates explicit functional reasoning with real-time execution feedback via structured intermediate representations.
• It employs role decomposition and persistent agent states to systematically separate planning from execution, enhancing system stability and accuracy.
• Empirical results across domains demonstrate significant performance gains over reactive models, with improvements in software patch success rates and robotic manipulation.

Searching arXiv for the specified FORGE-related papers and closely related grounding/functional-reasoning works. Searching "(Zhou et al., 7 Jul 2026) FORGE functional tool-use generalization keypoint trajectory reasoning" FunctiOnal Reasoning and Grounded Execution (FORGE) denotes a research paradigm in which an intelligent system reasons over explicit functional structures—such as hypotheses, invariants, dependencies, executable tests, trajectories, or typed programs—and closes the loop through real execution, tool interaction, or environment feedback rather than relying on plausibility alone. The term is made explicit in robotic tool-use generalization, where FORGE is defined as a two-stage policy that separates functional reasoning from grounded execution (Zhou et al., 7 Jul 2026). Closely related software-engineering work argues for “structured, state-aware, and execution-grounded reasoning” as an alternative to reactive prompt-only behavior (Tse-Hsun et al., 4 Feb 2026), while AgentForge operationalizes the principle that “every code change must survive sandboxed execution before propagation” in autonomous software engineering (Kumar et al., 13 Apr 2026).

1. Conceptual foundations

FORGE is grounded in a contrast between reactive agents and structured, state-aware, execution-grounded agents. Reactive systems make decisions mainly from conversation history and the latest observation; they reconstruct their understanding at each step, which leads to reasoning drift, forgotten assumptions, and unstable interpretation of execution feedback. By contrast, a FORGE-style agent maintains an explicit agent state: a persistent representation of hypotheses, invariants, dependencies, and pre- and post-conditions that can be revised as evidence arrives (Tse-Hsun et al., 4 Feb 2026).

Within this view, functional reasoning is reasoning over explicit intermediate objects rather than over unstructured text alone. In software engineering, those objects include relevant code elements, their dependencies, assumptions formed in earlier steps, expected behavior, and tentative alternative hypotheses. In robotic tool use, the corresponding objects are function-relevant keypoints and their future trajectories. In manipulation and visual reasoning, related work uses typed functional programs, scene-graph operations, and explicit object–relation structures to express what an action or object is for rather than merely what it looks like (Zhou et al., 7 Jul 2026, Wang et al., 2023, Chen et al., 2022).

Grounded execution is the companion principle that these functional representations must be checked against an external environment. The position paper on software-engineering agents formulates this as mapping execution feedback—tests, logs, traces, compiler messages—to the corresponding hypotheses or invariants, identifying which parts of the internal state are affected, and revising planned actions accordingly (Tse-Hsun et al., 4 Feb 2026). This shift makes correctness a property of environment outcomes rather than of model confidence.

2. Formal models of reasoning and execution

A central formalization of FORGE appears in AgentForge, which models LLM-based software engineering as a finite-horizon MDP over repository states. The state is

$$s_t = (\mathcal{R}_t, \mathcal{M}_t, \mathcal{H}_t),$$

where $\mathcal{R}_t$ is the current repository, $\mathcal{M}_t$ is episodic memory, and $\mathcal{H}_t$ is cumulative execution history. A code patch $a_t$ induces a transition through the execution environment,

$$s_{t+1} = \mathcal{E}(s_t, a_t) = (\mathcal{R}_t \oplus a_t,\ \mathcal{M}_t,\ \mathcal{H}_t \cup \{(a_t, o_t, e_t)\}),$$

and reward is defined by benchmark test semantics:

$$r_t = \mathbf{1}\big[\text{all FAIL\_TO\_PASS pass} \ \wedge\ \text{no PASS\_TO\_PASS regress}\big].$$

This makes sandbox execution the transition function and test outcomes the reward oracle (Kumar et al., 13 Apr 2026).

The same paper states an “execution signal dominance” claim: pass/fail indicated by execution is treated as a lower-variance, higher-fidelity estimator of functional correctness than any likelihood-based proxy, and therefore policies using execution feedback are expected to outperform policies that rely only on model likelihood, even when the latter use larger models (Kumar et al., 13 Apr 2026). This is the strongest explicit theoretical argument in the literature for giving execution a privileged epistemic role.

In robotic tool use, FORGE is formalized as a two-stage policy:

$$\pi_{\mathrm{FORGE}}(\mathbf{a}_{t:t+H} \mid \mathbf{o}_t, \mathbf{q}_t, \mathbf{x}_t) = \pi_{\mathrm{sys1}}(\mathbf{a}_{t:t+H} \mid \mathbf{o}_t, \mathbf{q}_t, \hat{\mathbf{X}}_{t:t+H}) \circ \pi_{\mathrm{sys2}}(\hat{\mathbf{X}}_{t:t+H} \mid \mathbf{o}_t, \mathbf{x}_t).$$

Here, System-2 predicts a future keypoint trajectory from action-free observations, and System-1 grounds that trajectory into robot actions using limited demonstrations. The decomposition explicitly separates functional intent from embodiment-specific execution (Zhou et al., 7 Jul 2026).

A related training-time formulation appears in execution-grounded reasoning supervision. There, reasoning steps $\mathbf{s}$ are treated as a sequence conditioning the final answer $\mathbf{y}$,

$\mathcal{R}_t$0

with $\mathcal{R}_t$1 derived from executable traces rather than from human- or model-written chain-of-thought alone (Jung et al., 12 Jun 2025). This suggests that FORGE is not only an inference-time control principle but also a supervision principle.

3. Architectural patterns

Several recurring architectural patterns define FORGE-style systems. The first is role decomposition. AgentForge uses Planner, Coder, Tester, Debugger, Critic, and a central Orchestrator. The Planner produces a structured plan, the Coder emits unified diffs, the Tester generates tests and triggers sandbox execution, the Debugger iteratively repairs failed patches, and the Critic performs a final pass/fail judgment before memory update (Kumar et al., 13 Apr 2026). The software-engineering position paper generalizes this into a state store, reasoning planner, executor/tool interface, feedback interpreter, memory/knowledge base, and consistency monitor (Tse-Hsun et al., 4 Feb 2026).

The second pattern is shared state with bounded local context. AgentForge combines episodic memory of successful task–code pairs with a repository index over source files, while all agents receive a consistent orchestrated context. SAGE uses an analogous hierarchy in the smart-home setting: a top-level agent-tool recursively calls specialized sub-agents, each with its own prompt, tool subset, and decision history. This dynamic tree of prompts lets the system decompose tasks while keeping local reasoning focused (Kumar et al., 13 Apr 2026, Rivkin et al., 2023).

The third pattern is execution-centered control loops. AgentForge implements a mandatory Tester–Debugger loop in Docker; SAGE interleaves reasoning with discrete actions over device APIs, monitoring code, and external services; the firmware-analysis FORGE interleaves reasoning and tool interaction through a reasoning–action–observation loop and organizes the global search state as a Dynamic Forest of Agents (Kumar et al., 13 Apr 2026, Rivkin et al., 2023, Zhang et al., 16 Apr 2026).

Domain	Representative mechanism	Reported outcome
Software engineering	Mandatory sandbox, Planner–Coder–Tester–Debugger–Critic	40.0% resolution on SWE-BENCH Lite
Robot tool use	System-2 keypoint trajectory reasoning + System-1 grounding	over 2X improvement in average success rate
Firmware binary analysis	Feedback-driven execution with Dynamic Forest of Agents	1,274 vulnerabilities across 591 unique binaries
Smart home assistance	Dynamically constructed tree of LLM prompts and tool calls	75% success on 50 tasks

These architectures differ in substrate, but they share a control principle: reasoning is decomposed into local subproblems, and each subproblem is advanced only through concrete interaction with tools or environments rather than through self-simulated continuation.

4. Empirical realizations across domains

In autonomous software engineering, AgentForge provides the clearest full-stack instantiation. On SWE-bench Lite, it achieves 40.0% resolution and 37.5% patch rate, compared with 14.0% resolution for single-agent GPT-4o, 12.0% for ReAct-style GPT-4o, and 18.1% for published SWE-agent. Ablations on 100 tasks show that removing the Debugger drops performance from 42% to 31%, removing the Tester to 28%, and removing the Planner to 19%, supporting the claim that execution feedback and role decomposition independently drive performance (Kumar et al., 13 Apr 2026).

In robotic manipulation, FORGE is explicitly presented as a solution to functional generalization: humans can repurpose unseen tools for the same function, whereas end-to-end visuomotor policies overfit to previously seen tool geometries. The proposed intermediate representation is a 2D keypoint trajectory, which outperforms affordance images and human video prompts in unseen-tool hitting tasks. On the seven-tool benchmark, FORGE achieves an overall average success rate of 0.36, versus 0.17 for Diffusion Policy, 0.09 for a flow-matching baseline, and 0.08 for a generic keypoint baseline; in real-world evaluation it reaches 0.63 overall versus 0.22 for the baseline (Zhou et al., 7 Jul 2026).

In reasoning supervision, code execution has been used as grounded supervision for chain-of-thought generation. Execution traces extracted with Snoop are translated into natural-language reasoning and used for supervised fine-tuning. The generated supervision reaches 98.3% final-output correctness versus 87.3% for CodeI/O, and 91.5% intermediate-step correctness versus 73.0%, while also reducing inference token usage and “overthinking” (Jung et al., 12 Jun 2025).

In firmware binary analysis, a different FORGE system rethinks vulnerability analysis as feedback-driven execution. Evaluated on 3,457 real-world firmware binaries, it identifies 1,274 vulnerabilities across 591 unique binaries with 72.3% precision, while the Dynamic Forest of Agents improves both coverage and verified findings relative to single-agent or sequential-only variants (Zhang et al., 16 Apr 2026).

In smart-home assistance, SAGE demonstrates that a FORGE-like controller can integrate user preferences, device APIs, external services, persistent monitoring, and visual disambiguation. On a benchmark of 50 smart-home tasks, it reaches a 75% success rate, compared with 30% for existing LLM-enabled baselines (Rivkin et al., 2023).

Earlier work provides conceptual precursors. ProgramPort translates manipulation instructions into typed executable programs composed of functional modules grounded on vision and action, yielding improved zero-shot and compositional generalization (Wang et al., 2023). REX constructs multimodal explanations by traversing a functional program and grounding keywords in image regions, explicitly coupling reasoning traces to grounded evidence (Chen et al., 2022).

5. Representational choices and execution signals

A distinctive feature of FORGE research is the diversity of intermediate functional representations. In software engineering, these include hypotheses, invariants, dependencies, tests as executable specifications, and repository states (Tse-Hsun et al., 4 Feb 2026, Kumar et al., 13 Apr 2026). In robotics, they include hitting points, target points, tool-mask keypoints, and future keypoint trajectories (Zhou et al., 7 Jul 2026). In manipulation and visual reasoning, they include typed DSL programs, object masks, relations, goals, and reasoning graphs (Wang et al., 2023, Chen et al., 2022).

These representations are not interchangeable. The robot paper explicitly compares affordance images, human video prompts, and 2D keypoint trajectories, concluding that keypoint trajectories best balance functional expressiveness and action groundability (Zhou et al., 7 Jul 2026). The software-engineering position paper similarly argues that execution feedback should not be appended as raw conversational text but mapped to explicit hypotheses and invariants in a persistent state (Tse-Hsun et al., 4 Feb 2026). A plausible implication is that FORGE is best understood less as a fixed architecture than as a design criterion for choosing representations that are simultaneously semantically meaningful and executable.

Another recurring theme is the choice of execution signal. AgentForge uses stdout, stderr, and test outcomes from a mandatory Docker sandbox (Kumar et al., 13 Apr 2026). Binary-analysis FORGE uses tool outputs and structured evidence chains from Radare2/Grighra plus validation passes (Zhang et al., 16 Apr 2026). SAGE grounds execution in device states, API responses, and code-generated monitor conditions (Rivkin et al., 2023). Execution-grounded supervision uses deterministic program traces as the source of stepwise reasoning labels (Jung et al., 12 Jun 2025). In all cases, the feedback channel is external to the LLM and therefore constrains reasoning by environment behavior rather than by narrative coherence.

This pattern extends beyond the papers that explicitly use the FORGE name. RoleGen, for example, models the context-dependent Functional Role of items in conversion trajectories and couples an LLM reasoner to a generative recommendation backbone through a “Reasoning-Execution-Feedback-Reflection” closed loop. The paper presents this as a FORGE-style planner–executor architecture in which counterfactual reasoning over functional roles is calibrated by real user feedback (Luo et al., 13 Feb 2026).

6. Limitations, misconceptions, and terminological ambiguity

FORGE research is unified by a family resemblance, not by a single standardized implementation. One misconception is that any tool-using LLM with execution access qualifies. The position paper argues instead for explicit state, historical coherence, and structured updates from execution feedback; AgentForge further requires execution-grounded verification as a mandatory gate, not an optional post hoc check (Tse-Hsun et al., 4 Feb 2026, Kumar et al., 13 Apr 2026). Another misconception is that execution alone solves long-horizon reasoning. In practice, failures still arise from faulty localization, ineffective patch generation, cognitive deadlock, weak multi-file coordination, brittle generated tests, and environment constraints in software engineering; in robotics, manually specified functional points, 2D-only keypoints, and execution smoothness remain open issues (Kumar et al., 13 Apr 2026, Zhou et al., 7 Jul 2026).

There are also important training-time limitations. Execution-grounded automated AI research shows that evolutionary search over executed ideas can be sample-efficient, finding a post-training method that reaches 69.4% versus a 48.0% GRPO baseline and a pre-training recipe that reaches the target in 19.7 minutes versus 35.9 minutes for nanoGPT. By contrast, reinforcement learning from execution reward improves average reward but not the upper bound because models collapse onto simpler ideas (Si et al., 20 Jan 2026). This suggests that FORGE systems require careful exploration mechanisms if execution feedback is to foster discovery rather than conservative local optimization.

Finally, the acronym FORGE is heavily overloaded in recent literature. Unrelated expansions include “Fine-grained Multimodal Evaluation for Manufacturing Scenarios” (Jian et al., 8 Apr 2026), “Failure-Optimized Reflective Graduation and Evolution” (Bogdanov et al., 15 May 2026), “Fabricated Orchestrated Reasoning chain for aGent Exploitation” (Pan et al., 6 Jul 2026), and “Multi-Agent Graduated Exploitation and Detection Engineering” (Shaikh, 2 Jun 2026). This terminological ambiguity makes disambiguation necessary: in the present sense, FORGE refers specifically to the paradigm of functional reasoning coupled to grounded execution.

Taken together, the literature presents FORGE as a general strategy for building systems that reason about what actions, code changes, trajectories, or objects are for, encode that reasoning in explicit intermediate structures, and validate or refine those structures through real execution. The paradigm has already produced concrete results in software engineering, robotic tool use, reasoning supervision, firmware analysis, and smart-home control, while leaving open a substantial agenda on state representation, cross-file or cross-module dependency reasoning, richer grounding channels, and exploration under execution-based feedback (Kumar et al., 13 Apr 2026, Zhou et al., 7 Jul 2026, Tse-Hsun et al., 4 Feb 2026).