acceptodds
Desk rejected at ICLR 2027

SafeForge: Dynamic Neuro-Symbolic Safety Rule Synthesis for Embodied Action Interception

Desk rejected at ICLR 2027, so left out of the paper lists and the map.

Abstract

Embodied AI agents operating in physical environments must evaluate the safety of proposed actions before execution — a challenge that demands both formal logical guarantees and the flexibility to handle diverse object combinations unseen during design. Existing approaches rely either on rigid rule-based systems that fail on novel entity configurations, or on neural models that lack interpretability and formal safety certificates. We present , a dynamic interpretable neuro-symbolic safety guardrail framework for embodied action safety verification. SafeForge operates through three stages. First, a real-time scene graph builder dynamically models the embodied interaction environment, grounding 3D object positions and semantic attributes into soft spatial predicates via differentiable sigmoid distance kernels. Next, a differentiable neuro-symbolic reasoner performs hierarchical forward chaining with learnable rule weights, instantiating high-level safety rules into scene-grounded, concrete safety conditions tailored to the observed entity configuration. Finally, an action safety judge synthesizes the proposed action type with the entities involved to produce a binary safety decision, accompanied by a full proof trace that provides human-interpretable explanations. We evaluate SafeForge on a curated benchmark of tasks spanning procedurally generated scenes and hazard categories, with an average of action steps per sequence. Extensive experimental results demonstrate that SafeForge achieves strong detection performance while maintaining differentiability for downstream policy learning, outperforming purely neural and purely symbolic baselines in safety detection performance. The source code is available at https://anonymous.4open.science/r/SafeForge.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Agent Safety, Embodied Agents, Runtime Verification, Neuro-Symbolic

Reviews

Among:
Shape:
1234this paper, Bottom 1%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.00 over 3 reviews, above 0% of the others.
Reviewer_jBAvOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

SafeForge is a safety guardrail for embodied agents. It combines scene objects, attributes, and spatial relations with predefined safety templates, uses soft logic to derive concrete constraints, and checks actions against these constraints. The authors evaluate it on SafeAgentBench and a modified long-horizon subset, reporting strong results.

Critical strengths
  1. The problem is important. Considering the environment when judging safety is more reasonable than rejecting actions based only on their names.
  2. The rule reasoning component exposes the conditions that trigger a constraint, making the basis for a safety judgment easier to trace.
Critical weaknesses
  1. Aggregation and learning. I still have questions about directly combining confidence scores from different sources using a product t-norm. The authors acknowledge the independence approximation but provide no calibration results or ablations. It is also unclear how the learnable noisy-OR weights are trained and whether Table 2 uses trained or initial weights. The code contains learnable parameters, but the corresponding experimental details are missing.

  2. Evaluation. Section 4.1 and Appendix C formulate the task as binary classification of an entire plan. The long-horizon tasks are modified by adding explicit hazardous actions, and all 50 instances are unsafe. The 100% result therefore does not by itself show that the system detects implicit temporal hazards or intercepts the step that causes them. Page 7 mentions scene updates, but Algorithm 2 does not show them, and the supplied evaluator reasons only once before the action loop. A complete trajectory is needed to explain scene updates and rule recomputation. If the evaluation only tests plan classification, the claims should be narrowed. The experiments also provide limited evidence of generalization to other scenes. The authors could evaluate original long-horizon tasks and benign tasks, or consider a process-oriented benchmark such as IS-Bench.

  3. Baselines. Appendix B excludes invalid outputs separately for each method without reporting how many samples remain. Some baselines have very low detection rates or high false rejection rates, so input adaptation and task mismatch need to be ruled out, particularly for RoboGuard and AgentSpec. RoboGuard already generates constraints from updated scene information, so its classification as lacking dynamic interception in Table 1 needs explanation. ShieldAgent also uses learnable probabilistic rules, while HomeGuard addresses contextual risks in embodied tasks. The authors should compare with these methods or explain their exclusion.

  4. Rule activation. In the code, templates sharing a hazard predicate are activated using that predicate's aggregated probability. In a check of the activation function, a high fire_hazard(wood,stove) activated cloth- and oil-related templates even when is_cloth(wood)=0 and is_oil(wood)=0. The conditions of each template are not checked separately, which could cause false rejections. The authors should clarify whether this implementation was used in the experiments and how it affects the results.

  5. Code and experimental setup. The code contains two LLM branches: one supplements rules when too few are activated, and the other can directly return an unsafe judgment before symbolic reasoning. Were these branches used for Table 2? If so, how much of the improvement comes from the LLM rather than rule reasoning? This also needs to be reconciled with Table 1's classification of SafeForge as not using an LLM safety judge. In the supplied package, the three data files are empty, and I could not find a complete entry point for reproducing Table 2. The authors should provide the version and configuration used for the experiments.

Questions for authors
  1. Were both LLM branches enabled for Table 2? Can the authors compare an LLM-only judge, the rule system with the LLM branches disabled, and the full system using the same inputs and safety knowledge?
  2. How is the scene updated as actions execute? Can the authors provide a complete trajectory showing observations, rule recomputation, and action interception?
  3. How are templates sharing a hazard predicate activated individually, as discussed in W4? Did this implementation affect the reported false rejection rate?
  4. How many safe and unsafe samples remain for each baseline? Which defense component does “Poex” refer to? The POEX paper mainly introduces an attack method and also studies different defenses, so the comparator needs to be specified.
Reviewer_nM8ROpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

This paper proposes SafeForge, a neuro-symbolic safety framework for detecting and intercepting potentially unsafe actions in embodied AI systems.

The framework consists of three main components. First, it constructs a scene graph containing objects, semantic attributes, spatial relationships, and probabilistic predicates. Second, it applies differentiable forward chaining over predefined safety-rule templates using product-based conjunction and noisy-OR aggregation to derive scene-specific hazard conditions. Finally, a runtime guard checks proposed actions against activated safety rules and blocks actions that match prohibited types and relevant entities, providing interpretable reasoning traces.

The authors evaluate SafeForge on SafeAgentBench, covering detailed, abstract, and long-horizon tasks. The reported results show 98% risk detection with a 2% false rejection rate on detailed tasks, 85% detection on abstract tasks, and 100% detection on an augmented set of 50 unsafe long-horizon tasks.

Critical strengths
  1. Relevant problem and interpretable system design.

The paper addresses the important problem of identifying unsafe actions before execution in embodied AI systems. Combining structured scene representations with explicit safety rules provides an interpretable alternative to purely black-box safety classifiers.

  1. Promising detection performance on the evaluated benchmark.

SafeForge reports strong risk detection and low false rejection rates on the detailed-task subset of SafeAgentBench. The use of scene-specific predicates and explicit rule activation provides a reasonable engineering framework for contextual action filtering.

However, these strengths do not resolve my concerns regarding methodological novelty and whether the experiments substantiate the paper's central claims.

Critical weaknesses
  1. Limited methodological novelty and insufficient evidence supporting the claimed differentiable neuro-symbolic learning mechanism.

My first major concern is that the proposed method appears to rely primarily on predefined safety-rule templates, standard probabilistic logic operations, and relatively simple rule-based action matching.

Section 3.2 explicitly states that the knowledge base consists of 16 predefined reusable rule templates covering 11 hazard categories. The framework instantiates these templates using the entities, attributes, and spatial relationships observed in the current scene.

While such grounding is useful, instantiating predefined rules for specific scene entities is fundamentally different from learning or synthesizing previously unknown safety rules. The paper does not convincingly demonstrate that SafeForge can discover new hazard relationships or construct safety knowledge beyond its predefined templates.

Therefore, the claimed contribution of "dynamic safety rule synthesis" appears considerably stronger than what the implementation actually establishes.

Furthermore, the differentiable reasoning module uses product t-norm semantics for conjunction and noisy-OR for aggregating rule activations. These are established techniques in probabilistic and neuro-symbolic reasoning. The paper does not clearly establish a novel learning or inference mechanism beyond their integration.

More importantly, although the rule weights are described as learnable and the framework is claimed to support end-to-end differentiable optimization, the experimental section does not provide sufficient information about the corresponding training objective, optimization procedure, training data, or learned parameter behavior.

The paper also lacks essential component-level ablations, including comparisons between learned and fixed rule weights, differentiable and hard spatial predicates, and the complete neuro-symbolic framework versus a conventional symbolic rule engine using the same knowledge base.

Consequently, it is unclear whether the reported improvements arise from the proposed differentiable learning mechanism or simply from the predefined safety rules and structured scene representations.

The runtime decision mechanism further limits the methodological contribution. As defined in Equations (13)–(14), an action is rejected when its action type belongs to a prohibited set and either its source or target entity belongs to the entities associated with an activated rule. This is a relatively simple matching mechanism that does not, by itself, establish reasoning over action consequences or temporal safety properties.

Overall, I find the methodological novelty insufficiently demonstrated, particularly given the strong claims regarding dynamic rule synthesis, differentiable neuro-symbolic learning, and interpretable safety verification.

  1. Experimental evaluation does not adequately validate dynamic safety interception, temporal reasoning, or the claimed generalization capabilities.

My second major concern is the substantial mismatch between the capabilities claimed by the paper and the capabilities actually evaluated.

The paper presents SafeForge as a dynamic safety guardrail capable of grounding scene information, synthesizing environment-specific constraints, and intercepting unsafe actions during execution.

However, the main evaluation reformulates SafeAgentBench tasks as binary safe/unsafe classification problems over structured task plans.

This evaluation does not directly establish that the proposed system can reliably operate under dynamically changing environmental states, perception errors, or evolving action consequences. The paper does not provide systematic execution-level experiments measuring runtime interception effectiveness, state-dependent rule updates, intervention latency, or downstream task completion after intervention.

The long-horizon evaluation is particularly concerning.

Section 4.1 and Appendix C.2 explain that the authors construct a modified evaluation set containing only 50 unsafe long-horizon instances by inserting explicit hazard-inducing actions into the original tasks.

Since every instance in this subset is unsafe, a trivial classifier that always predicts "unsafe" would achieve 100% risk detection. Without corresponding safe controls or additional measures of false rejection, this result cannot establish reliable long-horizon safety reasoning.

Furthermore, the reported improvement over AgentAuditor is only 100% versus 98%, corresponding to one additional detected instance in a 50-instance evaluation.

More importantly, inserting explicit hazardous actions may substantially simplify the original challenge of identifying implicit temporal safety violations. Therefore, this experiment does not convincingly demonstrate the ability to reason about delayed consequences or complex dependencies across action sequences.

I also have concerns about the baseline evaluation protocol. Appendix B states that instances producing invalid baseline outputs are excluded from evaluation rather than counted as failures. This potentially results in different effective evaluation populations across methods, making the reported performance comparisons difficult to interpret without per-method coverage statistics.

The paper should report the number of evaluated and excluded instances for each baseline and provide comparisons on a common evaluation population.

Finally, the abstract refers to 120 procedurally generated scenes, but the manuscript does not sufficiently clarify how these scenes are constructed, how they relate to the benchmark tasks, or how the spatial coordinates and probabilistic predicates are obtained and validated. This is particularly important because scene grounding is presented as a central component of the proposed method.

Taken together, the experiments primarily demonstrate promising binary hazard classification performance under a constrained and structured evaluation setting. They do not sufficiently establish the claimed capabilities in dynamic safety-rule synthesis, differentiable learning, or runtime action interception.

These limitations affect the central scientific contributions rather than minor experimental details. Therefore, I do not find the current evidence sufficient to support acceptance.

Questions for authors

Q1. What is actually learned in the proposed differentiable neuro-symbolic framework, and what is the independent contribution of the learning mechanism?

The paper describes learnable rule weights and end-to-end differentiable reasoning, but does not provide sufficient training and optimization details.

Can the authors clarify the training objective, data, optimization procedure, and learned parameters?

More importantly, can the authors provide controlled ablations comparing learned versus fixed rule weights, differentiable versus hard spatial predicates, and the complete framework versus a conventional symbolic rule engine using the same rule templates?

Without these comparisons, it is difficult to determine whether differentiable neuro-symbolic learning contributes meaningfully to the reported performance.

Q2. How do the authors substantiate the claimed dynamic safety interception and long-horizon reasoning capabilities?

The current evaluation primarily measures binary classification accuracy. In particular, all 50 augmented long-horizon instances are unsafe, meaning that an always-unsafe classifier would achieve perfect risk detection.

Can the authors provide evaluations containing both safe and unsafe long-horizon trajectories, including implicit or delayed safety violations?

Can they also demonstrate how SafeForge updates its safety judgments as environmental states change during execution, and report actual intervention effectiveness, false rejection, and downstream task completion?

Such experiments are essential to distinguish dynamic runtime safety reasoning from static hazard classification.

Q3. How are the procedural scenes constructed, and are the baseline comparisons performed on identical evaluation instances?

The paper mentions 120 procedurally generated scenes, but their construction, relationship to the 750 benchmark tasks, and the provenance of the spatial predicates are insufficiently specified.

Can the authors clarify whether these predicates are derived from actual simulated perception outputs or constructed from structured task descriptions?

Additionally, Appendix B states that invalid baseline outputs are excluded from evaluation. How many instances are excluded for each baseline, and how do the comparative results change when all methods are evaluated on the same task population?

Answers to these questions would materially affect my assessment of both the soundness and the methodological contribution.

Reviewer_vmdMOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

SafeForge is a neuro-symbolic runtime guardrail for embodied agents that builds a probabilistic scene graph from perception, applies soft distance kernels, and forward-chains hand-written hazard templates under product and noisy-OR semantics to block planned actions matching prohibited actions/entities and return a proof trace.

Critical strengths

Separating reusable, high-level hazard templates from their scene-specific instantiation, and attaching each block decision to explicit entities, a severity, and a proof trace, is a sensible and practically relevant design for embodied guardrails. If the results held for the purely symbolic version, the interpretability and auditability would be a real advantage over black-box LLM judges.

Critical weaknesses
  1. The reported results cannot be attributed to the method described in the paper. The released reasoner enables an LLM fallback by default (gpt-oss-20b or an API model). When fewer than three symbolic rules fire, the LLM generates additional hazard rules, which have no proof trace, and the code also includes an LLM "inherently unsafe action" check. None of this appears in the paper, and Table 1 explicitly lists SafeForge as not LLM-based. The paper also does not explain how SafeAgentBench text plans are converted into 3D scene graphs or how its action verbs are mapped to the template vocabulary, and no evaluation script is released. Together, these mean the 98%/2% headline cannot be verified and may be driven largely by an LLM judge, which is the kind of method the paper claims to improve on. This alone makes the empirical claims unreliable.
  2. The novelty is limited and the evaluation is too narrow to support the claims. Conceptually, the paper overlaps with existing work on safety-logic verification and context-grounded risk awareness (RoboGuard, ShieldAgent, Safety Chip, AgentSpec), and it does not clearly state what it adds beyond them. The technical part that would distinguish it, learnable or differentiable rule weights and spatial kernels "for downstream policy learning", is never exercised: nothing is trained, and the repository even contains a logic layer whose rule weights are never applied. The evaluation is also narrow:
  • Only one benchmark, SafeAgentBench, is used, and it is run as offline plan classification. The "dynamic interception" capability claimed in Table 1 is therefore never tested. An interactive, process-level benchmark such as IS-Bench, or SafePlan-Bench / SafeMindBench, would be needed.
  • There are no ablations, e.g., soft vs. hard predicates, with vs. without rule weights, threshold γ, number of templates, or with vs. without the LLM fallback.
  • There is no analysis of perception or recognition errors. The method claims to propagate perceptual uncertainty, yet the paper never measures how attribute or position errors from LLaVA-3D (or injected noise) affect detection and false-rejection rates.
  • There is no end-to-end latency measurement, even though the paper claims a "real-time" scene-graph builder and runtime interception, and the pipeline involves a 3D VLM plus possible LLM calls. Without these, the core contribution reduces to 16 hand-written Prolog rules with a threshold, evaluated on a single benchmark, which is incremental relative to existing rule-based guardrails.
Questions for authors

Q1. Besides the disclosed uses of GPT-4 (long-horizon data augmentation and the LLM baselines), the released reasoner enables an inference-time LLM rule generator by default (enable_llm=True in DifferentiableSafetyReasoner). It adds LLM-produced rules whenever fewer than three symbolic rules fire. Was this enabled for Table 2? If so, please report results with it disabled. Q2. Were the rule weights or kernel parameters ever trained? What values of τ, α, and γ were used, and how were they chosen? Q3. Please add ablations of the main components, robustness to perception errors, end-to-end latency, and results on a second benchmark that tests in-episode interception, such as IS-Bench.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Discussion (0)

Sign in to comment.