@@ -15,9 +15,9 @@
 from agent_control_evaluators import get_evaluator_instance
 from agent_control_models import (
     ConditionNode,
-    ControlDefinition,
-    ControlDefinitionRuntime,
+    ControlAction,
     ControlMatch,
+    ControlScope,
     EvaluationRequest,
     EvaluationResponse,
     EvaluatorResult,
@@ -43,12 +43,30 @@ def _compile_regex(pattern: str) -> Any:
     return re2.compile(pattern)
 
 
+class ControlDefinitionLike(Protocol):
+    """Runtime control shape required by the engine."""
+
+    enabled: bool
+    execution: Literal["server", "sdk"]
+    scope: ControlScope
+    condition: ConditionNode
+    action: ControlAction
+
+
 class ControlWithIdentity(Protocol):
     """Protocol for a control with identity information."""
 
-    id: int
-    name: str
-    control: ControlDefinition | ControlDefinitionRuntime
+    @property
+    def id(self) -> int:
+        """Database identity for the control."""
+
+    @property
+    def name(self) -> str:
+        """Human-readable name for the control."""
+
+    @property
+    def control(self) -> ControlDefinitionLike:
+        """Runtime control payload used during evaluation."""
 
 
 @dataclass
 
@@ -268,6 +268,8 @@ class SteeringContext(BaseModel):
 type JsonValue = JSONValue
 
 _TEMPLATE_PARAMETER_NAME_RE = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
+MAX_TEMPLATE_DEFINITION_DEPTH = 12
+MAX_TEMPLATE_DEFINITION_NODES = 1000
 
 
 def _validate_re2_value(value: str, *, field_name: str) -> str:
@@ -279,6 +281,35 @@ def _validate_re2_value(value: str, *, field_name: str) -> str:
     return value
 
 
+def _validate_template_definition_structure(value: JsonValue) -> JsonValue:
+    """Validate template definition nesting and overall size."""
+    stack: list[tuple[JsonValue, int]] = [(value, 1)]
+    node_count = 0
+
+    while stack:
+        node, depth = stack.pop()
+        node_count += 1
+
+        if depth > MAX_TEMPLATE_DEFINITION_DEPTH:
+            raise ValueError(
+                "definition_template nesting depth exceeds maximum of "
+                f"{MAX_TEMPLATE_DEFINITION_DEPTH}"
+            )
+
+        if node_count > MAX_TEMPLATE_DEFINITION_NODES:
+            raise ValueError(
+                "definition_template size exceeds maximum of "
+                f"{MAX_TEMPLATE_DEFINITION_NODES} JSON nodes"
+            )
+
+        if isinstance(node, dict):
+            stack.extend((nested_value, depth + 1) for nested_value in node.values())
+        elif isinstance(node, list):
+            stack.extend((nested_value, depth + 1) for nested_value in node)
+
+    return value
+
+
 class TemplateParameterBase(BaseModel):
     """Base definition for a template parameter."""
 
@@ -416,6 +447,12 @@ def validate_parameter_names(
                 )
         return value
 
+    @field_validator("definition_template")
+    @classmethod
+    def validate_definition_template_structure(cls, value: JsonValue) -> JsonValue:
+        """Limit template nesting and size to keep rendering bounded."""
+        return _validate_template_definition_structure(value)
+
 
 class TemplateControlInput(BaseModel):
     """Template-backed input payload for control create/update requests."""
@@ -626,7 +663,56 @@ def leaf_parts(self) -> ConditionLeafParts | None:
 ConditionNode.model_rebuild()
 
 
-class ControlDefinition(BaseModel):
+def _build_observability_identity(
+    condition: ConditionNode,
+) -> ControlObservabilityIdentity:
+    """Build a stable selector/evaluator identity for a condition tree."""
+    all_evaluators: list[str] = []
+    all_selector_paths: list[str] = []
+    seen_evaluators: set[str] = set()
+    seen_selector_paths: set[str] = set()
+    leaf_count = 0
+
+    for selector, evaluator in condition.iter_leaf_parts():
+        leaf_count += 1
+        selector_path = selector.path or "*"
+
+        if evaluator.name not in seen_evaluators:
+            seen_evaluators.add(evaluator.name)
+            all_evaluators.append(evaluator.name)
+
+        if selector_path not in seen_selector_paths:
+            seen_selector_paths.add(selector_path)
+            all_selector_paths.append(selector_path)
+
+    return ControlObservabilityIdentity(
+        selector_path=all_selector_paths[0] if all_selector_paths else None,
+        evaluator_name=all_evaluators[0] if all_evaluators else None,
+        leaf_count=leaf_count,
+        all_evaluators=all_evaluators,
+        all_selector_paths=all_selector_paths,
+    )
+
+
+class _ConditionBackedControlMixin:
+    """Shared helpers for control models backed by a condition tree."""
+
+    condition: ConditionNode
+
+    def iter_condition_leaves(self) -> Iterator[ConditionNode]:
+        """Yield leaf conditions in evaluation order."""
+        yield from self.condition.iter_leaves()
+
+    def iter_condition_leaf_parts(self) -> Iterator[ConditionLeafParts]:
+        """Yield leaf selector/evaluator pairs in evaluation order."""
+        yield from self.condition.iter_leaf_parts()
+
+    def observability_identity(self) -> ControlObservabilityIdentity:
+        """Return a deterministic representative identity for observability."""
+        return _build_observability_identity(self.condition)
+
+
+class ControlDefinition(_ConditionBackedControlMixin, BaseModel):
     """A control definition to evaluate agent interactions.
 
     This model contains only the logic and configuration.
@@ -725,53 +811,12 @@ def to_template_control_input(self) -> TemplateControlInput:
             template_values=dict(self.template_values),
         )
 
-    def iter_condition_leaves(self) -> Iterator[ConditionNode]:
-        """Yield leaf conditions in evaluation order."""
-        yield from self.condition.iter_leaves()
-
-    def iter_condition_leaf_parts(self) -> Iterator[ConditionLeafParts]:
-        """Yield leaf selector/evaluator pairs in evaluation order."""
-        yield from self.condition.iter_leaf_parts()
-
     def primary_leaf(self) -> ConditionNode | None:
         """Return the single leaf node when the whole condition is just one leaf."""
         if self.condition.is_leaf():
             return self.condition
         return None
 
-    def observability_identity(self) -> ControlObservabilityIdentity:
-        """Return a deterministic representative identity for observability.
-
-        The representative selector/evaluator comes from the first leaf in
-        evaluation order so composite trees still populate top-level event
-        dimensions. The full ordered, deduped leaf context is also returned.
-        """
-        all_evaluators: list[str] = []
-        all_selector_paths: list[str] = []
-        seen_evaluators: set[str] = set()
-        seen_selector_paths: set[str] = set()
-        leaf_count = 0
-
-        for selector, evaluator in self.iter_condition_leaf_parts():
-            leaf_count += 1
-            selector_path = selector.path or "*"
-
-            if evaluator.name not in seen_evaluators:
-                seen_evaluators.add(evaluator.name)
-                all_evaluators.append(evaluator.name)
-
-            if selector_path not in seen_selector_paths:
-                seen_selector_paths.add(selector_path)
-                all_selector_paths.append(selector_path)
-
-        return ControlObservabilityIdentity(
-            selector_path=all_selector_paths[0] if all_selector_paths else None,
-            evaluator_name=all_evaluators[0] if all_evaluators else None,
-            leaf_count=leaf_count,
-            all_evaluators=all_evaluators,
-            all_selector_paths=all_selector_paths,
-        )
-
     model_config = {
         "json_schema_extra": {
             "examples": [
@@ -799,7 +844,7 @@ def observability_identity(self) -> ControlObservabilityIdentity:
     }
 
 
-class ControlDefinitionRuntime(BaseModel):
+class ControlDefinitionRuntime(_ConditionBackedControlMixin, BaseModel):
     """Slim runtime control model that ignores template authoring metadata."""
 
     model_config = ConfigDict(extra="ignore")
@@ -835,41 +880,6 @@ def validate_condition_constraints(self) -> Self:
         _validate_common_control_constraints(self.condition, self.action)
         return self
 
-    def iter_condition_leaves(self) -> Iterator[ConditionNode]:
-        """Yield leaf conditions in evaluation order."""
-        yield from self.condition.iter_leaves()
-
-    def iter_condition_leaf_parts(self) -> Iterator[ConditionLeafParts]:
-        """Yield leaf selector/evaluator pairs in evaluation order."""
-        yield from self.condition.iter_leaf_parts()
-
-    def observability_identity(self) -> ControlObservabilityIdentity:
-        """Return a deterministic representative identity for observability."""
-        all_evaluators: list[str] = []
-        all_selector_paths: list[str] = []
-        seen_evaluators: set[str] = set()
-        seen_selector_paths: set[str] = set()
-        leaf_count = 0
-
-        for selector, evaluator in self.iter_condition_leaf_parts():
-            leaf_count += 1
-            selector_path = selector.path or "*"
-
-            if evaluator.name not in seen_evaluators:
-                seen_evaluators.add(evaluator.name)
-                all_evaluators.append(evaluator.name)
-
-            if selector_path not in seen_selector_paths:
-                seen_selector_paths.add(selector_path)
-                all_selector_paths.append(selector_path)
-
-        return ControlObservabilityIdentity(
-            selector_path=all_selector_paths[0] if all_selector_paths else None,
-            evaluator_name=all_evaluators[0] if all_evaluators else None,
-            leaf_count=leaf_count,
-            all_evaluators=all_evaluators,
-            all_selector_paths=all_selector_paths,
-        )
 
 class EvaluatorResult(BaseModel):
     """Result from a control evaluator.
 
@@ -36,6 +36,13 @@
 }
 
 
+def _nested_template_value(depth: int) -> object:
+    value: object = "leaf"
+    for _ in range(depth):
+        value = {"nested": value}
+    return value
+
+
 def test_control_definition_requires_template_fields_together() -> None:
     with pytest.raises(
         ValidationError,
@@ -98,6 +105,32 @@ def test_template_definition_rejects_invalid_parameter_name() -> None:
         )
 
 
+def test_template_definition_rejects_excessive_nesting() -> None:
+    with pytest.raises(
+        ValidationError,
+        match="definition_template nesting depth exceeds maximum",
+    ):
+        TemplateDefinition.model_validate(
+            {
+                "parameters": {},
+                "definition_template": _nested_template_value(12),
+            }
+        )
+
+
+def test_template_definition_rejects_excessive_size() -> None:
+    with pytest.raises(
+        ValidationError,
+        match="definition_template size exceeds maximum",
+    ):
+        TemplateDefinition.model_validate(
+            {
+                "parameters": {},
+                "definition_template": list(range(1001)),
+            }
+        )
+
+
 def test_create_control_request_parses_template_payload_as_template_input() -> None:
     request = CreateControlRequest.model_validate(
         {
 
@@ -1,7 +1,5 @@
-from collections.abc import Iterator
-
 from agent_control_engine import list_evaluators
-from agent_control_models import ConditionNode, ControlDefinition, TemplateControlInput
+from agent_control_models import ControlDefinition, TemplateControlInput
 from agent_control_models.errors import ErrorCode, ValidationErrorItem
 from agent_control_models.server import (
     AgentRef,
@@ -39,6 +37,7 @@
 )
 from ..logging_utils import get_logger
 from ..models import Agent, AgentData, Control, agent_controls, agent_policies, policy_controls
+from ..services.condition_traversal import iter_condition_leaves_with_paths
 from ..services.control_definitions import parse_control_definition_or_api_error
 from ..services.control_templates import remap_template_api_error, render_template_control_input
 from ..services.evaluator_utils import (
@@ -59,32 +58,6 @@
 template_router = APIRouter(prefix="/control-templates", tags=["controls"])
 
 _logger = get_logger(__name__)
-
-
-def _iter_condition_leaves(
-    node: ConditionNode,
-    *,
-    path: str = "data.condition",
-) -> Iterator[tuple[str, ConditionNode]]:
-    """Yield each leaf condition with its dot/bracket field path."""
-    if node.is_leaf():
-        yield path, node
-        return
-
-    if node.and_ is not None:
-        for index, child in enumerate(node.and_):
-            yield from _iter_condition_leaves(child, path=f"{path}.and[{index}]")
-        return
-
-    if node.or_ is not None:
-        for index, child in enumerate(node.or_):
-            yield from _iter_condition_leaves(child, path=f"{path}.or[{index}]")
-        return
-
-    if node.not_ is not None:
-        yield from _iter_condition_leaves(node.not_, path=f"{path}.not")
-
-
 def _serialize_control_definition(control_def: ControlDefinition) -> dict[str, object]:
     """Serialize control data for storage while omitting null scope fields."""
     data_json = control_def.model_dump(
@@ -130,7 +103,10 @@ async def _validate_control_definition(
     """Validate evaluator config for a control definition."""
     available_evaluators = list_evaluators()
     agent_data_by_name: dict[str, AgentData] = {}
-    for field_prefix, leaf in _iter_condition_leaves(control_def.condition):
+    for field_prefix, leaf in iter_condition_leaves_with_paths(
+        control_def.condition,
+        path="data.condition",
+    ):
         leaf_parts = leaf.leaf_parts()
         if leaf_parts is None:
             continue