BDDL: Behavior Domain Definition Language

• BDDL is a formal, object-centric, predicate logic-based language that precisely defines task dynamics, initial states, and goal conditions in robotic and embodied AI systems.
• It employs logical connectives, quantifiers, and explicit metrics to evaluate partial progress and ensure flexible yet rigorous activity specification.
• BDDL integrates seamlessly with simulations, behavior trees, and DSLs, fostering robust evaluation and cross-environment generalization of autonomous agents.

The BEHAVIOR Domain Definition Language (BDDL) is an object-centric, predicate logic-based specification language designed to formally define, instantiate, and evaluate complex activities, particularly for embodied AI benchmarks and robotic systems. It enables the precise description of task dynamics, initial and goal conditions, decision processes, and behavioral constraints, supporting unambiguous interpretation and systematic evaluation across a broad range of environments.

1. Formal Specification and Object-Centric Modeling

The core of BDDL is its predicate logic-based formalism that models activities, states, and objectives as symbolic predicates defined over objects and their relationships (Srivastava et al., 2021). An activity $\tau$ is described by a pair of state sets:

$\tau = \{ S_{(\tau, 0)}, S_{(\tau, g)} \}$

where $S_{(\tau, 0)}$ defines the initial states and $S_{(\tau, g)}$ the acceptable goal states. Objects are associated with category labels (e.g., WordNet synsets like apple.n.01, table.n.02) and manipulated by predicates such as Cooked(obj), OnTopOf(obj1, obj2), Sliced(obj), or InsideOf(obj1, obj2). Predicates can express a range of state properties, including kinematic configuration, material state, or spatial relationships.

BDDL utilizes logical connectives ($\wedge, \vee, \neg, \Rightarrow, \Leftrightarrow$), first-order quantifiers ($\forall$, $\exists$), and domain-specific quantifiers (for_n, for_pairs, for_n_pairs) to encode complex conditions, such as “at least n hamburgers are inside baskets.” This structure enables the definition of tasks at the level of semantic intent rather than concrete physical configuration.

2. Definition of Activities and Expressivity

BDDL formalizes the specification of activities by allowing the declaration of initial conditions (a conjunction of ground literals over predicates and objects) and goal conditions (arbitrary logical formulas over those predicates) (Srivastava et al., 2021). The language supports expression of disjunctions, quantifier alternation, and quantification over object sets.

Goal conditions are “flattened” into alternative conjunctions $C_i$ of ground literals $l_{j_i}$, which enables the tracking of partial progress throughout task execution. Success is measured using the metric

$$Q = \max_{C} \left( \frac{|\{ l_{j_i} : l_{j_i}\ \text{true} \}|}{|C_i|} \right)$$

An agent achieves the goal when $Q=1$ for at least one conjunction $C_i$, ensuring that flexible, non-unique solutions can be specified and recognized.

The expressivity of BDDL allows abstraction over scene parameters, promoting generalization across varying physical environments and object attributes, and supporting infinite instance generation from a single logical task definition.

3. Interoperability, Instantiation, and Symbolic Evaluation

Because predicates in BDDL are defined over categories and properties, activity definitions remain agnostic to particular scenes or object placements. During instantiation, a BDDL specification can be grounded into a concrete environment by sampling compatible objects and poses while adhering to the logical constraints.

In simulation, as the world state evolves, BDDL predicates are re-evaluated, supplying a continuous progress signal for agents (Srivastava et al., 2021). This feature underpins task evaluation: as an agent acts, the current simulated state is mapped via the BDDL predicates to determine whether preconditions, intermediate constraints, or goal states are satisfied.

BDDL also enables the declarative separation of task specification from execution policy, facilitating flexible planning, benchmarking, and cross-environment generalization.

4. Extensions for Process and Temporal Reasoning

Temporal and process-based specification frameworks—such as those developed using Behavioral QLTL (Giacomo et al., 2021)—can be mapped onto or layered with BDDL. Here, BDDL’s object-predicate formalism serves as the atomic substrate for temporal planning formulas:

$\forall X\, \exists Y\, \psi$

where $X$ are environment variables and $Y$ are controllable choices. Temporal operators (next $X$, until $U$, eventually $F$, globally $G$) can be incorporated to articulate complex behaviors, such as contingency plans or liveness guarantees.

Behavioral QLTL, when applied to BDDL, ensures that decisions (represented as existential choices) depend only on the history of observations, a property essential for synthesizing reactive, implementable strategies for autonomous agents. The automata-theoretic underpinnings give tight complexity bounds for synthesis and realizability.

5. Integrated Formalisms: Behavior Trees and DSLs

BDDL interfaces with or inspires higher-level formalisms such as Behavior Trees (BTs), stateful extensions, and domain-specific languages (DSLs) (Serbinowska et al., 21 Nov 2024, Biggar et al., 26 Nov 2024, Ingrand, 17 Feb 2025). State variables, shared blackboards, and control flow constructs (Sequence, Selector, Parallel, Monitor, etc.) can be expressed in tree-based DSLs that align with the modular, object-predicate approach of BDDL.

Formulation of BTs in a formal language such as Fiacre and translation to Time Transition Systems (TTSs) enables model checking and temporal property verification (LTL/CTL). For example, properties like

$\Box ((\text{battery} = \text{Critical}) \Rightarrow \Diamond_{[0,2]} (\text{land.status} = \text{tick_node}))$

can be directly checked against the model (Ingrand, 17 Feb 2025). The modular approach allows reusability and runtime verification through tools like Tina and Hippo.

Reactive, functionally typed behavior languages in Haskell support modular composition, dataflow, and advanced control structures such as reactive selection and safety monitoring, removing common ambiguities of classical BTs and further supporting the design and implementation of complex autonomous behavior (Biggar et al., 26 Nov 2024).

6. Applications, Toolchains, and Practical Workflow

BDDL is central to the BEHAVIOR benchmark, serving as the standard for defining, instantiating, and scoring agent performance on a broad suite of household activities (Srivastava et al., 2021). Tool support includes pipelines for automatic grounding in simulated environments (e.g., iGibson 2.0), continuous symbolic evaluation, and instance generation. The object-centric model facilitates domain randomization and large-scale benchmarking.

In robotic planning and formal verification, translation from BDDL and associated BT DSLs to formal models (Fiacre, nuXmv, etc.) supports exhaustive model checking (safety, liveness, timing properties), runtime enforcement, and the deployment of verified controllers in safety-critical domains (Serbinowska et al., 21 Nov 2024, Ingrand, 17 Feb 2025).

Proposed toolchains include translators from visual BPM models or XML representations to BDDL predicate statements (1006.4892), supporting roundtrip design and enabling business process integration, automated test generation, and direct traceability from visual requirements to executable specifications.

7. Limitations, Research Directions, and Impact

The declarative, predicate-centric paradigm of BDDL enables precise task definition and a high degree of abstraction, but also raises challenges for handling concurrency, process semantics, and dataflow in large-scale system integration. For example, parallelism expressed as logical “AND” in BDDL currently leaves operational semantics to downstream interpreters (1006.4892), prompting continued research into parallel and reactive constructs.

The translation of BDDL specifications into temporal-logic-based controllers or verifiable models (e.g., through BTs and DSLs) is an area of active standardization, with ongoing developments in performance, expressivity, and formal verification capacities (Ingrand, 17 Feb 2025, Serbinowska et al., 21 Nov 2024). The separation of role concerns (domain expert vs. system engineer) is also a focus, ensuring usability and correctness in practical workflows (Pérez-Álvarez et al., 2020).

BDDL’s adoption in the BEHAVIOR benchmark and embodied AI community has enabled large-scale, fair, and flexible evaluation of agent generalization, planning, and task completion under diverse conditions. Its methodology bridges the semantic gap between high-level human-centric task definition and the concrete, symbolic reasoning required for robust, scalable AI system evaluation.