Summary of "Which AI Behavior Framework Should You Use? | AI Series 46"

Overview

This summary compares four AI behavior approaches for games — unstructured code (ad-hoc scripts), finite state machines (FSMs), behavior trees, and GOAP (Goal-Oriented Action Planning). For each approach it explains what it is, pros and cons, tooling options, performance and debugging implications, and when to use it.

Key takeaways by framework

Unstructured AI (ad-hoc scripts)

What: Directly write logic (attack, follow, die) and wire scripts together.
Pros: Fast to get started; minimal framework/overhead. Good for extremely simple behaviors (1–2 states).
Cons: Becomes a tangled dependency nightmare as complexity grows. Very hard to debug and maintain.
Use when: Extremely simple NPCs (e.g., basic zombies or monsters).

Finite State Machines (FSMs / State machines)

What: Named states with transitions (similar to Unity Animator). Each state represents a behavior and transitions require conditions.
Pros: Easy to understand and visualize; straightforward debugging with visualizers.
Cons: Transition explosion — roughly O(n^2) transitions as states grow. Each state must know its possible next states and conditions, which becomes unmanageable with many states.
Use when: Small to moderate, clearly state-driven AI.

Behavior Trees

What: A tree of control nodes (selectors, sequences) and leaf actions. Control flow is top-down and child nodes return success/failure/running.
Pros: Very popular; good visualization and debugging; modular and more scalable than FSMs for moderate-to-complex behaviors.
Cons: Need tooling/editor to be practical (otherwise heavy framework work). Trees can become complex and costly if they grow huge.
Tools mentioned: Opsive’s Behavior Designer (visual editor), NodeCanvas, and other Asset Store tools.
Use when: Moderate to complex AI where readability and runtime debugging matter.

GOAP (Goal-Oriented Action Planning)

What: Define goals and available actions (with preconditions/effects). A planner builds action sequences at runtime to reach prioritized goals, using a blackboard of world state.
Pros: Most flexible and scalable for complex, emergent planning. AIs can re-plan and choose achievable goals based on priorities and current state.
Cons: Steep paradigm shift to design; planner can produce unexpected or “weird” solutions. Performance can be heavy when planning deep/large graphs — you must constrain depth and variables. Fewer off-the-shelf visual editors (though some GitHub and Asset Store libraries exist).
Demo details: Example with four goals — wander, fix hunger/eat, pick up item, gather items — and prerequisites (for example, needing a pickaxe to mine iron).
Use when: Large-scale, complex AI requiring planning and flexible goal reasoning — but be prepared to optimize and accept added complexity.

Performance, debugging, and scaling notes

Unstructured code and FSMs scale poorly; debugging becomes difficult as complexity increases.
FSMs suffer transition explosion as the number of states increases.
Behavior trees provide clearer runtime insight via visualization, but require tooling and careful design for very deep trees.
GOAP offers the highest flexibility but requires pruning and constraints for performance; it can be unpredictable without good visualization and limits.
General rule: pick the simplest system that meets your needs and invest in tooling/visualizers for maintainability.

Pick the simplest system that meets your needs — and invest in visual tooling to make debugging and maintenance feasible.

Tools, assets, and resources mentioned

Unity Animator (example of a state machine)
Opsive’s Behavior Designer (visual behavior-tree editor)
NodeCanvas and other behavior-tree tools on the Unity Asset Store
A popular GOAP GitHub repository (500+ stars) and an Asset Store package used as a starter
Video description contains affiliate links (Asset Store, Humble Bundle) and sales
Sponsor: Southern New Hampshire University (SNHU) — promoted computer science and game development degrees

Practical recommendations

Start with unstructured scripts or FSMs for tiny AI.
Use behavior trees for moderate complexity where visibility and modularity help.
Adopt GOAP for large, goal-driven, emergent behaviors if you can handle the design shift and optimization work.
Always use visual tooling where possible to debug and understand runtime behavior.

Main speaker and sources

Presenter: Chris (channel creator, referred to as “Mom Academy” / “Alom Academy” in the transcript)
Sponsor/source: Southern New Hampshire University (SNHU)
Tool/asset authors: Opsive (Behavior Designer), NodeCanvas and other Asset Store tool creators
GOAP: referenced a popular GitHub repo and an Asset Store implementation (500+ stars)