FORGE: Multifaceted Research Systems

• FORGE is a research designation with varied definitions and applications, functioning as an algorithm, framework, or observatory depending on the field.
• It encompasses systems for latent-space exploration, memory-efficient LLM training, generative retrieval, molecular optimization, and vulnerability analysis.
• The nomenclature reflects broad interdisciplinary usage, from interactive design tools and compiler infrastructures to physical observatories in geothermal and cosmological research.

FORGE is a recurrent research designation rather than a single method. In current usage it names domain-specific systems for architectural latent-space exploration, memory-efficient large-model training, contact-rich robot assembly, generative retrieval, molecular optimization, vulnerability analysis, smart-contract dataset construction, code-provenance recovery, and geothermal or cosmological observatories and emulators. Depending on context, the term may denote an acronymized algorithm, a software framework, or the Utah Frontier Observatory for Research in Geothermal Energy, so its technical meaning is defined primarily by the surrounding field and paper title rather than by a common core formalism (Dunnell et al., 2024, Kukreja et al., 22 Jun 2026, Noseworthy et al., 2024, Chen et al., 23 Jun 2025, Lellouch et al., 2020).

1. Nomenclature and research landscape

The research literature uses FORGE and closely related names as labels for heterogeneous artifacts: interactive design tools, compiler and training infrastructures, control systems, security pipelines, and field-scale scientific programs. In several cases the name is expanded as an acronym, including "Fused On-Register Gradient Elimination" for LLM training, "Forming Semantic Identifiers for Generative Retrieval" for recommender systems, "Failure-Optimized Reflective Graduation and Evolution" for agent memory, "Fragment-Oriented Ranking and GEneration" for molecular optimization, and "Foundational Optimization Representations from Graph Embeddings" for MIP instance embeddings (Kukreja et al., 22 Jun 2026, Fu et al., 25 Sep 2025, Bogdanov et al., 15 May 2026, Zhang et al., 11 May 2026, Shafi et al., 28 Aug 2025).

Usage	Domain	Core characterization
Form Forge (Dunnell et al., 2024)	Architectural design	Explicit latent-variable manipulation of StyleGAN2-ADA forms
FORGE (Kukreja et al., 22 Jun 2026)	LLM systems	In-backward, tile-wise optimizer fusion
FORGE (Noseworthy et al., 2024)	Robotics	Force-threshold-conditioned contact-rich manipulation
FORGE (Fu et al., 25 Sep 2025)	Recommender systems	Industrial benchmark for semantic identifiers in generative retrieval
FORGE (Chen et al., 23 Jun 2025)	Smart-contract security	LLM-driven CWE-classified dataset construction
FORGE (Shafi et al., 28 Aug 2025)	Optimization	Vector-quantized graph embeddings for MIP instances
FORGE (Shaikh, 2 Jun 2026)	Cybersecurity automation	Multi-agent graduated exploitation and detection engineering
FORGE / Utah FORGE (Lellouch et al., 2020)	Geothermal science	Frontier Observatory for Research in Geothermal Energy

Related naming variants extend the same lexical pattern without denoting the same system: "DeepForge" addresses microstructural control in hot forging, "O-Forge" couples an LLM with Mathematica for asymptotic analysis, "CLT-Forge" supports cross-layer transcoders and attribution graphs, "Forge-UGC" is a universal graph compiler, and "Forge-and-Quench" is a unified multimodal generation framework (Petrik et al., 2024, Khaitan et al., 14 Oct 2025, Draye et al., 22 Mar 2026, Kumar et al., 14 Apr 2026, Zeng et al., 8 Jan 2026). This suggests that FORGE functions in the literature less as a stable technical term than as a reusable project label applied to systems that emphasize construction, synthesis, or staged transformation.

2. Generative design, retrieval, and content synthesis

"Form Forge" is a prototype creative system for interactively exploring the latent space of architectural forms derived from François Blanciak's sketches. It fine-tunes a StyleGAN2-ADA model whose mapping network has eight fully connected layers of width 512, exposes all 512 latent dimensions, and renders a 512×512 grayscale output. The interface represents the latent code as 512 angular "ticks" surrounding the generated image, supports direct scalar manipulation, includes exponential decay $w_i(t+1)=w_i(t)\cdot(1-\lambda)$, and uses a Flask back end with a React front end. Training used 1,017 sketches, horizontal-flip augmentation to 2,034 images, and 235 "ticks" of optimization, corresponding to $\simeq 461$ epochs (Dunnell et al., 2024).

"Forge-and-Quench" addresses unified multimodal image generation by letting an MLLM first rewrite the conversational context into an enhanced instruction and then mapping that instruction to a virtual visual representation called the Bridge Feature. The Bridge Adapter is trained as a diffusion-style transformer over frozen SigLIP features of shape $24\times 24\times 1152$, using the fidelity loss $$\mathcal{L}_{\rm fid}=\mathbb{E}\|v_b-\hat v_b\|_2^2$$. In an ablation on MeiGen-Image, adding the diffusion-based Bridge Adapter changes COCO-30K FID from 23.97 to 19.86 with 0.49 s latency, whereas autoregressive and direct-projection alternatives are weaker in FID or slower in latency (Zeng et al., 8 Jan 2026).

In industrial recommendation, FORGE provides a benchmark for semantic identifiers in generative retrieval using 14 billion user-item interactions collected over 10 consecutive days, 131 million users, and 251 million unique items from Taobao. Item representations combine processed text embeddings, 512-d image embeddings, and the most co-occurring item $i^+$; semantic identifiers are built with multimodal fusion, an InfoNCE objective, and RQ-VAE residual quantization. The framework introduces EmbHR@$K$ and a Gini coefficient as direct SID metrics, reports offline gains of $+27\%$ to $+35\%$ in HR@100 and $+13\%$ to $+19\%$ in HR@500 for its optimized setting, and in online analysis on "Guess You Like" reports PVR $\simeq 461$0, HR $\simeq 461$1, and transaction count $\simeq 461$2 over 7 days. Its offline pretraining strategy reaches production base performance in 4 days versus 10 days from scratch (Fu et al., 25 Sep 2025).

In molecular design, FORGE reformulates optimization as context-aware local editing. Stage 1 ranks fragments by property contribution under full molecular context, and Stage 2 generates explicit fragment replacements; the model is built on Qwen3-0.6B with atom-level retokenization and is trained on context-conditioned SME+ edit pairs and ChEMBL matched molecular pairs. Reported results include Prompt-MolOpt SUM values of 4.587, 4.302, and 2.882 at similarity thresholds $\simeq 461$3, 0.4, and 0.6, a PMO-1k SUM of 12.42, and ChemCoTBench success rates of $\simeq 461$4 on DRD2 and $\simeq 461$5 on JNK3 (Zhang et al., 11 May 2026). A plausible implication is that, across these generative uses, FORGE often denotes a pipeline that inserts an explicit intermediate representation—latent coordinates, bridge features, semantic identifiers, or fragment edits—between input specification and final synthesis.

3. Systems infrastructure, optimization, and formal reasoning

FORGE in LLM training denotes "Fused On-Register Gradient Elimination for Memory-Efficient LLM Training." Its starting point is the observation that standard reverse-mode differentiation materializes every weight gradient and creates a "gradient floor" of $\simeq 461$6 bytes at the boundary between backward pass and optimizer step. FORGE partitions a linear weight matrix into $\simeq 461$7 tiles, accumulates each gradient tile in fp32 registers, and applies the optimizer update before the tile is ever written to HBM. For element-wise-separable optimizers the fused step is exact in fp32, while bf16 and 8-bit regimes are treated as faithful approximations with stochastic rounding for unbiased bf16 weight stores and 64-wide block quantization for INT8 moments. On single-GPU Llama-3.1-8B training at BS=1 and SEQ=512 on H200, fused AdamW is reported at 75.0 GiB peak and 150.9 ms/step, while FORGE with INT8 states is 35.4 GiB and 99.1 ms/step; in tensor-parallel Megatron-LM, the released memory permits 8B training at four times the micro-batch of a standard optimizer on the same GPUs (Kukreja et al., 22 Jun 2026).

"FORGE: Foundational Optimization Representations from Graph Embeddings" pre-trains a vector-quantized graph autoencoder for MIP instances without solver labels. MIPs are mapped to bipartite variable-constraint graphs, encoded with two GraphSAGE layers to $\simeq 461$8, quantized into a codebook of $\simeq 461$9, and summarized at the instance level by a code-frequency histogram. In unsupervised evaluation, pre-training on 1,800 MIPLIB instances and testing on 1,050 unseen D-MIPLIB instances yields an NMI of 0.843, compared with 0.790 for label propagation and 0.087 for a mean-readout baseline. Fine-tuned embeddings are then used for warm-start variable prediction and integrality-gap prediction, both of which improve a commercial solver (Shafi et al., 28 Aug 2025).

Compiler infrastructure appears under "Forge-UGC," a four-phase graph compiler consisting of FX graph capture, six optimization passes, lowering to typed NPUIR, and backend analysis with liveness, linear-scan allocation, and device-affinity scheduling. The optimization passes reduce graph node count by 14.2 to 21.9%, buffer allocation reduces peak buffer count by 30 to 48%, and scheduling reduces NPU-CPU transitions by 42 to 65%. Across six model families from 125M to 8B parameters, Forge-UGC reports 6.9 to 9.2x faster compilation than OpenVINO and ONNX Runtime, with 18.2 to 35.7% lower inference latency and 30.2 to 40.9% lower energy per inference while keeping max absolute logit differences below $24\times 24\times 1152$0 and KL divergence below $24\times 24\times 1152$1 (Kumar et al., 14 Apr 2026). CLT-Forge occupies a related systems niche for mechanistic interpretability: it trains cross-layer transcoders with feature-wise sharding, compresses activation caches from approximately 20 TB to 4 TB for LLaMA-1B on 300 M tokens, and supports CLTs with $24\times 24\times 1152$2 M features on an $24\times 24\times 1152$3 GB GPU cluster (Draye et al., 22 Mar 2026).

"O-Forge" applies the name to formal asymptotic reasoning. It uses an LLM to suggest a finite domain decomposition, then exports the regimes to Mathematica's Resolve for fully symbolic verification. The system was tested on $24\times 24\times 1152$4 asymptotic problems, typically requiring $24\times 24\times 1152$5 regimes, and includes a case study answering a MathOverflow question posed by Terence Tao via a three-regime decomposition with witness $24\times 24\times 1152$6 (Khaitan et al., 14 Oct 2025). This suggests a common infrastructure pattern in several FORGE systems: a decomposition stage proposes a structured representation, and a constrained backend executes or verifies the resulting pieces.

4. Robotics, control, and self-improving agents

In robotics, FORGE stands for "Force-Guided Exploration for Robust Contact-Rich Manipulation under Uncertainty." The method formulates each assembly primitive as a POMDP, conditions a recurrent PPO policy on a user-specified force threshold $24\times 24\times 1152$7, and adds a soft penalty $24\times 24\times 1152$8. Sim-to-real transfer is supported by dynamics randomization over controller gains $24\times 24\times 1152$9, Cartesian action scales $$\mathcal{L}_{\rm fid}=\mathbb{E}\|v_b-\hat v_b\|_2^2$$0 cm, dead zones $$\mathcal{L}_{\rm fid}=\mathbb{E}\|v_b-\hat v_b\|_2^2$$1 N, friction, initial poses, and observation noise; the actor also predicts an early-termination score. On 585 real-world trials across three tasks, reported performance is $$\mathcal{L}_{\rm fid}=\mathbb{E}\|v_b-\hat v_b\|_2^2$$2 success for 8 mm peg insertion, $$\mathcal{L}_{\rm fid}=\mathbb{E}\|v_b-\hat v_b\|_2^2$$3 for medium gear meshing, and $$\mathcal{L}_{\rm fid}=\mathbb{E}\|v_b-\hat v_b\|_2^2$$4 for M16 nut threading, all with lower mean and max contact forces than a non-randomized, unpenalized baseline. A four-stage planetary gearbox assembly achieves 3/5 full-pipeline success, and early termination saves $$\mathcal{L}_{\rm fid}=\mathbb{E}\|v_b-\hat v_b\|_2^2$$5 s per trial (Noseworthy et al., 2024).

A different FORGE, "Failure-Optimized Reflective Graduation and Evolution," addresses gradient-free agent improvement through prompt-injected natural-language memory. It wraps a Reflexion-style inner loop inside a staged population protocol over $$\mathcal{L}_{\rm fid}=\mathbb{E}\|v_b-\hat v_b\|_2^2$$6 parallel instances and $$\mathcal{L}_{\rm fid}=\mathbb{E}\|v_b-\hat v_b\|_2^2$$7 stages, using a failure threshold $$\mathcal{L}_{\rm fid}=\mathbb{E}\|v_b-\hat v_b\|_2^2$$8, a graduation threshold $$\mathcal{L}_{\rm fid}=\mathbb{E}\|v_b-\hat v_b\|_2^2$$9, and memory artifacts in Rules, Examples, or Mixed form. The champion instance's memory is broadcast to active agents between stages, while graduated instances are frozen. On CybORG CAGE-2 against the B-line attacker, the framework improves average evaluation return by $i^+$0-$i^+$1 over zero-shot and by $i^+$2-$i^+$3 over isolated Reflexion across all 12 model-representation conditions, while reducing major-failure rates below $i^+$4 to as low as $i^+$5 (Bogdanov et al., 15 May 2026).

A closely named control-system variant, "DeepForge," combines a 1D convolutional front end, a GRU, and model predictive control for microstructural control in three-stroke hot forging. It predicts six full-field outputs from surface-temperature measurements with grain-size MAE $i^+$6, runs in $i^+$7 ms per stroke versus 20 s for FE simulation, and in a disturbed case increases $i^+$8 and $i^+$9 from 10 s to 30 s to restore $K$0 in the target region (Petrik et al., 2024). Taken together, these systems use FORGE or Forge as a label for closed-loop adaptation under uncertainty, but they do so at very different control levels: physical contact forces, natural-language memory, and thermo-mechanical process state.

5. Security, software provenance, and vulnerability analysis

"FORGE: Multi-Agent Graduated Exploitation and Detection Engineering" is a five-agent pipeline composed of Intel, Generator, Planner, Exploit, and Detector agents. Its central abstraction is a four-level exploitation-depth taxonomy, from L0 (no evidence) to L3 (full compromise), assessed turn by turn by an LLM-primary oracle and used both for prioritization analysis and for producing Sigma and Snort rules from OpenTelemetry traces. On 603 CVEs drawn from CVE-GENIE, the system reports 424/603 generation-and-deploy successes, 409/603 end-to-end L1+ exploitations ($K$1), mean exploit depth $K$2, mean exploit turns 9.5, and average cost USD 1.50 per CVE. Detection rules derived from L2+ traces have significantly higher span-normalized grounding than L1-derived rules ($K$3), and 93.4% of generated Snort rules yield zero false positives on a synthetic benign corpus (Shaikh, 2 Jun 2026).

In smart-contract security, FORGE is the first automated approach for building vulnerability datasets from audit reports. Its pipeline consists of a Semantic Chunker, a MapReduce Extractor, a hierarchical Tree-of-Thoughts classifier over a software-focused CWE tree, and a Code Fetcher. Running on 6,454 audit reports, it produces a dataset with 81,390 Solidity files and 27,497 vulnerability findings across 296 CWE categories. Manual assessment reports macro precision 95.6%, macro recall 78.4%, macro F1 86.1%, and classification consistency with human experts at Krippendorff's $K$4. Benchmarking 13 tools on the resulting dataset yields a best F1 of 18.59% for Semgrep, highlighting the limits of current detection capability (Chen et al., 23 Jun 2025).

Code-provenance research applies the name differently in "Deforking the World of Code." That work constructs a deforking map for WoC V2604 from 51.79 million shared-commit groups using a hub-node star encoding and parallel Louvain clustering, while capped variants suppress boilerplate-induced over-merging. Validation against GitHub ForkEvents gives 99.01% edge agreement conditional on both repositories being present in WoC. The recovered project families include 775,420 multi-forge families, corresponding to 5.41% of all deforked families with size $K$5, and 216,013 families, or 1.51%, whose canonical root is not on GitHub. The release also includes a fork-exclusion list with 134,132,789 declared-fork children and a detached-fork inventory of 455,550 edges (Mockus, 28 Jun 2026). A plausible implication is that several FORGE systems in security and software engineering replace binary labels with graded or clustered structure—exploit depth, hierarchical CWE placement, or cross-forge fork families—to preserve information lost by coarse taxonomies.

6. Physical-science observatories and emulators

In geothermal seismology, FORGE refers to the Frontier Observatory for Research in Geothermal Energy site in Utah. A downhole DAS deployment in monitoring well 78-32 reached 985 m depth, sampled at 2000 Hz with channel spacing of 1 m and gauge length of 10 m, and recorded 10.5 days of continuous data during initial EGS stimulation in April-May 2019. Processing with slant-stack/semblance, manual QC, and matched filtering identifies 82 earthquakes, compared with 4 non-stimulation events in the regional UUSS catalog over the same interval; 16 of the 82 DAS events are visually identifiable on the local surface array. The DAS catalog has $K$6, compared with $K$7 for the surface catalog, while single-well localization remains azimuthally ambiguous (Lellouch et al., 2020).

Thermal forecasting at Utah FORGE has been studied using generalized decline curves and machine-learning surrogates. The modified Arps family introduces an equilibrium temperature $K$8 into exponential, harmonic, hyperbolic, and stretched-exponential decline equations so that produced-fluid temperature reaches a finite asymptote. Validation against well 16B(78)-32 data from April 7-10, 2024 shows higher $K$9, lower RMSE, and lower AIC for all modified forms than for their conventional counterparts. On a 110-case thermo-hydro-mechanical simulation dataset, the equation-informed neural network reaches hold-out MAE $+27\%$0 and RMSE $+27\%$1, while a Gaussian process surrogate attains RMSE $+27\%$2 and MAE $+27\%$3 with well-calibrated uncertainty; full THM simulation requires 6-8 hours (Khalaf, 2 Jan 2026).

Hydraulic stimulation modeling for Utah FORGE analyzes two April 2022 stages in well 16A(78)-32 that differed mainly in fluid viscosity. Stage 2 used slickwater with $+27\%$4 Pa·s, and stage 3 used a cross-linked gel that began near $+27\%$5 Pa·s and thermally degraded to $+27\%$6-$+27\%$7 Pa·s. Although the injection-rate schedules and wellhead pressures were similar, microseismicity diverged after shut-in: slickwater showed immediate arrest, while the gel stage sustained microseismicity for hours and defined a near-vertical N15°E-striking plane. The stage-3 seismic radius follows the viscosity-storage-dominated radial hydraulic-fracture scaling $+27\%$8, and matching the final radius requires $+27\%$9; for slickwater, a dilatant shear-fracture interpretation is plausible only under sufficient dilatancy (Brisson et al., 20 Apr 2026).

Outside geothermal science, FORGE also denotes the "f(R) Gravity Emulator" simulation suite for modified-gravity cosmology. That project uses 200 full $+35\%$0 simulations over 50 Latin-hypercube nodes spanning $+35\%$1, $+35\%$2, $+35\%$3, and $+35\%$4, with paired boxes of $+35\%$5 particles in $+35\%$6 volumes and $+35\%$7 particles in $+35\%$8 volumes. Its matter-power-spectrum emulator achieves cross-validated accuracy better than 2.5% for the majority of nodes up to $+35\%$9, and external validation against F6 and F5 simulations gives maximum relative errors of $+13\%$0 and $+13\%$1 over most of $+13\%$2 (Arnold et al., 2021). Here, unlike the algorithmic FORGE systems, the name identifies either an experimental field program or a simulation suite and emulator project in physical science.