Behave documentation


Since the launch of Behave 2, documentation has been available through the AngryAnt community – accessible via the Unity help menu, when Behave 2 is installed.

This page contains documentation for Behave 1.4 and is no longer valid for the latest version of Behave – and will only be available so long as Behave 1.4 remains supported.

Behave 1.4 documentation

By default available for Unity, Behave runs on all Unity target platforms and does not require Unity pro. Once the package has been imported, you are all set.

Use the on-page navigation for documentation on various areas of Behave and don’t forget to check out the videos and external material section for additional documentation on Behave and behaviour trees.

Runtime types




These are the types used by the Behave runtime classes. Specifically the Tree class and the IAgent interface and therefore you will be using them as well.


enum BehaveResult { Running, Success, Failure };


BehaveResult TickForward (Tree sender, string stringParameter, float floatParameter, IAgent agent, object data);
void ResetForward (Tree sender, string stringParameter, float floatParameter, IAgent agent, object data);
BehaveResult TickForwardShort (Tree sender);
void ResetForwardShort (Tree sender);

The library class




As you compile your Behave library, the resulting .NET assembly will be set to contain a single point of entry – the library class. This is where you will be able to retrieve tree instances from, enums of the actions and delegates and so forth. If you do a debug build, you will also get an info text file generated, containing the name of the class, all enums, their integer values and so forth.

Static functions

Tree InstantiateTree (TreeType treeType, IAgent agent);
TreeType Type (Tree tree);
bool IsAction (int id);
bool IsDecorator (int id);


TreeType { CollectionName_TreeName, …, Unknown };
ActionType { ActionName, …, Unknown };
DecoratorType { DecoratorName, …, Unknown };
PriorityType { PriorityName, …, Unknown };
ContextType { ContextName, …, Unknown };





The Tree class is an abstract class from which each compiled Behave tree in your library inherits. It is the interface you will use to communicate with the tree instances you receive from your library class.


BehaveResult Tick ([IAgent agent, object data]);
void Reset ([IAgent agent, object data]);
void SetInitForward (int id, TickForward init);
void SetInitForward (int id, TickForwardShort init);
void SetTickForward (int id, TickForward tick);
void SetTickForward (int id, TickForwardShort tick);
void SetResetForward (int id, ResetForward reset);
void SetResetForward (int id, ResetForwardShort reset);


int ActiveContext { get; }
// A context can be set by a component at any time and remains in place until another context is set or the tree tick ends. Subtrees inherit contexts.
float Frequency { get; }
// The frequency is set in the tree designer, but has no impact on the runtime apart from the return value of this property
int ActiveID { get; }
// In a tick or init call on an agent, this will be the ID of the action or decorator
// These are set after execution of a tick method on an agent:
int LastTicked { get; }
int LastTickedAction { get; set; }
int LastTickedDecorator { get; set; }
float LastTickTime { get; }
// This is grabbed from UnityEngine.Time.time
bool DebugAvailable { get; }
// If the above returns true, then debug is available and these get updated:
string Name { get; }
int ActiveComponent { get; }





This is the interface you will be implementing on scripts responsible for handling action and decorator invokes. The interface itself is quite short and simple, but I will add in here the documentation on the action and decorator handlers which are automatically reflected and hooked up to your tree instances on creation.

What this basically means is that any method following a specific pattern of naming and declaration will be recognised as the handler for an action or decorator during the instantiation process of a tree. This is very similar to how Start, Awake and other events are automatically detected and invoked on Unity MonoBehaviours without being part of the MonoBehaviour class definition.

Your absolute bare minimum implementation of an agent is to just implement the Tick and Reset methods of the interface which means whenever an action or decorator is ticked or reset, those methods will be invoked. If you set up forwards/handlers for actions and decorators, those will be used in stead.

Remember that in stead of relying on automatic registration of handlers, you can always use the SetForward methods of the Tree class to manually specify which method should handle a given action or decorator. This also has the advantage of being able to cluster handling of related actions/decorators in a single method.


BehaveResult Tick (Tree sender, bool init);
void Reset (Tree sender);
int SelectTopPriority (Tree sender, params int[] IDs);

Recognised handlers (must be public)

BehaveResult Init{Name}{Action|Decorator} (Tree sender, string stringParameter, float floatParameter, IAgent agent, object data);
BehaveResult Tick{Name}{Action|Decorator} (Tree sender, string stringParameter, float floatParameter, IAgent agent, object data);
void Reset{Name}{Action|Decorator} (Tree sender, string stringParameter, float floatParameter, IAgent agent, object data);
BehaveResult Init{Name}{Action|Decorator} (Tree sender);
BehaveResult Tick{Name}{Action|Decorator} (Tree sender);
void Reset{Name}{Action|Decorator} (Tree sender);
BehaveResult {Name}{Action|Decorator} {get; set;}
// For properties, get is recognised as the tick handler and set as the reset handler. You are not required to implement both for one to be recognised.

Videos and external material

The following brief videos provide an overview of Behave:

These external resources are great for understanding both Behave and behaviour trees:

  • “Behavior trees for next-gen game AI” article and video presentation by Alex J. Champandard of An account is required to view the video, but subscription is free.
  • “Introduction to Behaviour Trees” by Bjoern Knafla for #AltDevBlogADay. A nice introduction to how behaviour trees work – including examples. Choice and naming of component differs a bit from Behaves component set, but everything in the article is achievable with the Behave components.
  • “Oh, Behave! AI with behaviour trees in Unity and C#”" video masterclass by me for This video goes through some of the inner workings of Behave – including its compiler and code generation structure. An AIgameDev Premium account is required to access this video.