Hybrid Behavior Trees

A production-grade behavior tree engine combining deterministic control flow with LLM-powered adaptive reasoning for intelligent autonomous systems.

What is Igris BTree?

Igris BTree is a hybrid behavior tree system that bridges the gap between traditional deterministic behavior trees and modern LLM-powered adaptive intelligence. It provides a robust framework for building complex autonomous behaviors that can both follow predefined plans and dynamically adapt to unexpected situations.

Core Philosophy

The system is built on three fundamental principles:

Deterministic + Adaptive: Combine reliable control flow with intelligent adaptation
BYOM (Bring Your Own Model): No vendor lock-in, use any LLM provider you choose
Real-Time Safe: Bounded execution with hard deadlines and safety mechanisms

Key Features

Deterministic Control Flow

Traditional behavior tree nodes for reliable, predictable execution:

Sequence: Execute children in order (AND logic)
Selector: Try children until success (OR logic / fallback)
Parallel: Execute children concurrently
Decorators: Retry, Timeout, Inverter, Repeat

LLM-Powered Adaptive Reasoning

Dynamic planning and recovery capabilities:

LLMPlannerNode: Generate behavior subtrees on-the-fly
SubtreeLoader: Execute dynamically generated plans
ReplanOnFailure: Automatic recovery via LLM when actions fail

Production-Ready Runtime

BTreeExecutor: Lifecycle management with tick loop automation
Bounded Execution: Max ticks, deadlines, and cancellation support
Watchdog Safety: Prevents infinite loops and runaway execution
Real-Time Guarantees: Integration with igris-rt for LLM timeout enforcement

Visualization & Monitoring

TreeVisualizer: Real-time tree state export
Execution Tracing: Tick-by-tick history
Metrics Collection: Replan count, tick rate, failure rates, LLM latency
JSON Export: Dashboard-ready format for WebSocket/REST integration

BYOM Architecture

Pluggable LlmProvider trait: Bring your own model
No vendor lock-in: Works with local models, cloud APIs, or mocks
Full control: Choose your inference backend, costs, and privacy policy

Architecture Overview

┌─────────────────────────────────────────────────────┐
│  Deterministic BTree Control Layer                  │
│  ├─ Sequence: Execute children in order            │
│  ├─ Selector: Try until success (fallback)         │
│  └─ Parallel: Execute children concurrently        │
└─────────────────────────────────────────────────────┘
         ▲                            ▲
         │ Hybrid Integration         │
┌────────┴────────────────────────────┴───────────────┐
│  LLM-Powered Adaptive Nodes                         │
│  ├─ LLMPlannerNode: Generate dynamic subtrees      │
│  ├─ SubtreeLoader: Load LLM plans at runtime       │
│  └─ ReplanOnFailure: Auto-recovery via LLM         │
└─────────────────────────────────────────────────────┘
         ▲
         │ Pluggable (BYOM)
┌────────┴─────────────────────────────────────────┐
│  LlmProvider Trait (customer-supplied)           │
│  - Local models (Phi-3, Qwen, etc.)              │
│  - Cloud APIs (if customer chooses)              │
│  - Mock provider (testing)                       │
└──────────────────────────────────────────────────┘

Use Cases

Robotics & Autonomous Systems

Warehouse Robots: Navigate, pick items, handle obstacles
Delivery Drones: Plan routes, adapt to weather, recover from failures
Agricultural Robots: Follow crop rows, adapt to terrain variations
Service Robots: Interact with humans, adapt to dynamic environments

Mission Planning

Multi-Phase Operations: Deterministic sequences with adaptive recovery
Reconnaissance: Explore unknown environments with dynamic replanning
Search & Rescue: Adapt strategies based on discovered conditions

Game AI

NPC Behaviors: Predictable patterns with adaptive responses
Boss Encounters: Scripted phases with dynamic tactics
Companion AI: Follow player with intelligent problem-solving

Process Automation

Workflow Automation: Structured processes with exception handling
DevOps Pipelines: Build, test, deploy with intelligent recovery
Data Processing: ETL workflows with adaptive error handling

Why Hybrid Behavior Trees?

The Problem with Pure Deterministic Trees

Traditional behavior trees are:

✅ Predictable and testable
✅ Easy to debug and visualize
❌ Brittle when facing unexpected situations
❌ Require exhaustive pre-planning for edge cases
❌ Cannot adapt to truly novel situations

The Problem with Pure LLM Agents

Pure LLM-based systems are:

✅ Flexible and adaptive
✅ Can handle novel situations
❌ Unpredictable and hard to test
❌ Expensive (many LLM calls)
❌ Difficult to debug and validate
❌ May violate safety constraints

The Hybrid Solution

Igris BTree combines the best of both worlds:

✅ Predictable core behaviors (deterministic nodes)
✅ Adaptive recovery (LLM-powered replanning)
✅ Testable with mocks (MockLlmProvider for unit tests)
✅ Cost-efficient (LLM only when needed)
✅ Safe execution (bounded timeouts, watchdog)
✅ Debuggable (visualization, tracing, metrics)

Example: A warehouse robot follows a deterministic navigation sequence. When it encounters an unexpected obstacle, the ReplanOnFailure decorator triggers an LLM to generate a recovery plan. Once recovered, it returns to the deterministic sequence.