New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Beehave

by jame581 in jame581/GodotPrompter

A skill your agent uses when using the Beehave addon — pure-GDScript behavior trees with composites, decorators, leaves, a blackboard, and a visual runtime debugger

MITAuto-check passedGame Development

Install Beehave

skills CLI
$ npx skills add jame581/GodotPrompter --skill beehave -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install jame581/GodotPrompter beehave --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/jame581/GodotPrompter.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/beehave .claude/skills/beehave && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
beehave
GitHub stars
799
Token cost
~2.8k tokens
SKILL.md length
929 words
Files
2 (incl. references)
Skills in repo
58
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when using the Beehave addon — pure-GDScript behavior trees with composites, decorators, leaves, a blackboard, and a visual runtime debugger

  • Works in 6 steps: When to use Beehave → Install & enable → Tree composition → …
  • Using the Beehave addon — pure-GDScript behavior trees with composites
  • SKILL.md covers 1. When to use Beehave, 2. Install & enable, 3. Tree composition and 4. The leaf contract, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Beehave is an agent skill from jame581/GodotPrompter. Use when using the Beehave addon — pure-GDScript behavior trees with composites, decorators, leaves, a blackboard, and a visual runtime debugger

Its SKILL.md is about 2.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/custom-nodes.md`).

It sits in Game Development, covering Game development. It works with Godot, C# and C++. The repository describes itself as: Agentic skills framework for Godot 4.x. Domain-specific skills for AI coding agents (Claude Code, Copilot, Antigravity, Cursor). The licence is MIT.

When your agent uses it

  • Using the Beehave addon — pure-GDScript behavior trees with composites
  • A visual runtime debugger

Example prompts

  • “/beehave”

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. When to use Beehave
  2. Install & enable
  3. Tree composition
  4. The leaf contract
  5. Blackboard
  6. Visual debugger

What it can do on your machine

Read from SKILL.md and the folder at commit 1e7d79d. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are gdscript).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Beehave loads about 2.8k tokens when it runs, and up to ~4.2k if it reads all its reference files. Until then it costs about 38 tokens; SKILL.md has 929 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~38
When it runs · the whole SKILL.md, loaded when a task matches
~2.8k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~4.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from jame581/GodotPrompter at commit 1e7d79d, republished under its MIT licence (© jame581). 929 words, ~2,767 tokens.

Download SKILL.mdSave it as .claude/skills/beehave/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
beehave
description
Use when using the Beehave addon — pure-GDScript behavior trees with composites, decorators, leaves, a blackboard, and a visual runtime debugger

Beehave

Related skills: ai-navigation for the movement leaves drive, state-machine for core-engine FSM, limboai for a heavier C++ BT+HSM alternative, godot-brainstorming for choosing an AI approach.

Addon: Beehave · version v2.9.2 · Godot 4.1+ · MIT · source: https://github.com/bitbrain/beehave · written in GDScript (no official C# API — this skill is GDScript-only by design).

1. When to use Beehave

ApproachBest for
Core-engine FSM (state-machine skill)Simple agents, < 5 states, no addon
Beehave (GDScript addon)Lightweight BT, GDScript-only projects, fast iteration
LimboAIBT and HSM together, visual editor, C++ performance, C# support (module build)

Choose Beehave when your project is GDScript-only, you want a behavior tree without a custom engine build, and you value a simple node-in-scene-tree authoring workflow. Beehave trees live entirely in the scene tree — every composite, decorator, and leaf is a regular Node child. For a heavier C++/C# solution with HSM integration, use the limboai skill instead. For plain state machines without a BT, use the built-in state-machine skill.

C# note: Beehave has no official C# API (zero .cs files in addons/beehave/). From C# you can call the GDScript API via Godot cross-language interop (GetNode<Node>(...).Call("tick", actor, blackboard)), but Beehave provides no typed C# classes.

2. Install & enable

  1. Godot AssetLib → search "Beehave" → Download → Reload project.
    Or copy the addons/beehave/ folder from the GitHub release into res://addons/beehave/.
  2. Enable the plugin: Project → Project Settings → Plugins → tick Beehave.
    Two autoloads are registered: BeehaveGlobalMetrics and BeehaveGlobalDebugger.
  3. Optional — copy script_templates/ from the addon into the project root for leaf scaffolding templates.

3. Tree composition

A Beehave tree is built from three kinds of nodes, all placed as regular scene-tree children:

RoleNodeBehavior
Tree rootBeehaveTreeTicks the child every frame (or physics/manual); extends Node (not BeehaveNode)
CompositesSequenceComposite, SelectorComposite, SimpleParallelComposite, …Flow control — AND / OR / parallel logic
DecoratorsInverterDecorator, CooldownDecorator, RepeaterDecorator, …Wrap one child to modify its result
LeavesActionLeaf, ConditionLeaf subclassesYour custom game logic
Composite quick reference
ClassLogic
SequenceCompositeAND — all children must succeed; fails on first failure
SequenceReactiveCompositeAND — re-evaluates from first child every tick while running
SelectorCompositeOR — succeeds on first success; fails if all fail
SelectorReactiveCompositeOR — re-evaluates from first child every tick while running
SimpleParallelCompositeRuns two children simultaneously; result follows primary (child 0)
SequenceRandomCompositeShuffled AND — executes children in random order
SelectorRandomCompositeShuffled OR — tries children in random order
Decorator quick reference
ClassEffect
InverterDecoratorFlips SUCCESS ↔ FAILURE; passes RUNNING through
AlwaysSucceedDecoratorForces SUCCESS; passes RUNNING through
AlwaysFailDecoratorForces FAILURE; passes RUNNING through
RepeaterDecoratorRe-runs child until it succeeds repetitions times
LimiterDecoratorCaps child to max_count running ticks, then FAILURE
CooldownDecoratorBlocks re-execution for wait_time seconds after child finishes
TimeLimiterDecoratorGives child wait_time seconds; interrupts if still running
DelayDecoratorWaits wait_time seconds before first executing child
UntilFailDecoratorLoops child until it returns FAILURE, then returns SUCCESS
Minimal scene-tree example
gdscript
# Scene tree:
#   Enemy (CharacterBody2D)
#     BeehaveTree               ← tick_rate = 1, process_thread = PHYSICS
#       SelectorComposite
#         SequenceComposite     ← "attack if in range"
#           IsInRangeCondition
#           AttackAction
#         PatrolAction          ← fallback

# BeehaveTree exports:
# @export var enabled: bool = true
# @export var tick_rate: int = 1          (1 = every frame; 3 = every 3 frames)
# @export var process_thread: ProcessThread = PHYSICS
# @export var blackboard: Blackboard      (auto-created if not set)
# @export_node_path var actor_node_path   (defaults to parent node)

# Access the tree from code if you need manual control:
@onready var bt: BeehaveTree = $BeehaveTree

func _ready() -> void:
    # Reduce tick cost: evaluate AI every 3 physics frames
    bt.tick_rate = 3
    # Default process_thread is PHYSICS — switch to IDLE if actor uses _process
    bt.process_thread = BeehaveTree.ProcessThread.IDLE

tick_rate note: tick_rate = 1 evaluates every frame; tick_rate = 3 every 3 frames. Increase for distant/background NPCs to save CPU. Default process thread is PHYSICS — if the actor script uses _process instead of _physics_process, set process_thread = IDLE to keep them in sync.

4. The leaf contract

Leaves hold your game logic. Subclass ActionLeaf for multi-tick work or ConditionLeaf for single-frame checks, then override tick(actor, blackboard).

gdscript
# IsInRangeCondition.gd
class_name IsInRangeCondition
extends ConditionLeaf

@export var detection_range: float = 150.0

func tick(actor: Node, blackboard: Blackboard) -> int:
    # Beehave types `actor` as Node; cast to your concrete type for 2D members.
    var body := actor as Node2D
    var target: Node2D = blackboard.get_value("target")
    if body == null or not is_instance_valid(target):
        return FAILURE
    var in_range := body.global_position.distance_to(target.global_position) <= detection_range
    return SUCCESS if in_range else FAILURE
gdscript
# AttackAction.gd
class_name AttackAction
extends ActionLeaf

@export var attack_duration: float = 0.5

func tick(actor: Node, blackboard: Blackboard) -> int:
    var elapsed: float = blackboard.get_value("attack_elapsed", 0.0)
    elapsed += get_physics_process_delta_time()

    if elapsed >= attack_duration:
        blackboard.erase_value("attack_elapsed")
        # `actor` is typed Node; guard game-specific methods (or cast to your actor type).
        if actor.has_method("play_attack_animation"):
            actor.call("play_attack_animation")
        return SUCCESS

    blackboard.set_value("attack_elapsed", elapsed)
    return RUNNING

func after_run(actor: Node, blackboard: Blackboard) -> void:
    # Clean up any per-run state when the tree interrupts this action
    blackboard.erase_value("attack_elapsed")

Return codes (defined on BeehaveNode):

  • SUCCESS — action complete / condition met.
  • FAILURE — action failed / condition not met; parent composite decides what to do next.
  • RUNNING — action needs more frames; tree will call tick() again next frame (ActionLeaf only — ConditionLeaf should never return RUNNING).

Optional overrides:

  • before_run(actor, blackboard) — called once before the first tick of a run.
  • after_run(actor, blackboard) — called when the child finishes (SUCCESS/FAILURE) or is interrupted.
  • interrupt(actor, blackboard) — called when the tree interrupts a running node.
Show full SKILL.md (328 more words)Show less

5. Blackboard

The Blackboard node is a shared key/value store passed to every tick() call. BeehaveTree auto-creates an internal one if you don't assign an external Blackboard node.

gdscript
# Share one Blackboard across multiple BeehaveTrees on the same actor.
# Assign the same exported Blackboard node to each tree in the Inspector.

# Read / write from any leaf's tick():
func tick(actor: Node, blackboard: Blackboard) -> int:
    # Write
    blackboard.set_value("target", actor.get_nearest_enemy())

    # Read with default
    var speed: float = blackboard.get_value("move_speed", 200.0)

    # Conditional check
    if blackboard.has_value("stunned"):
        return FAILURE

    # Erase (sets key to null; has_value returns false after erase)
    blackboard.erase_value("temp_flag")

    return SUCCESS

Named namespaces: every method accepts an optional blackboard_name: String parameter (default "default"). Use this to keep separate namespaces on one Blackboard node without name collisions (e.g., per-enemy state vs. shared world state).

Built-in expression leaves: BlackboardSetAction, BlackboardEraseAction, BlackboardHasCondition, and BlackboardCompareCondition let you manipulate the Blackboard entirely via Inspector exports (no GDScript required). Expressions run via Godot's Expression.execute([], blackboard) — so you can call get_value("key") directly in the expression string.

6. Visual debugger

Beehave ships an EditorDebuggerPlugin that adds a 🐝 Beehave tab to the bottom editor panel while your game is running:

  1. Run the project from the Godot editor.
  2. Open the Debugger panel → click the 🐝 Beehave tab.
  3. Select a tree from the list to activate live visualization — active nodes are highlighted each tick.
  4. Optional: click the detach button to float the panel, or set Project Settings → beehave/debugger/start_detached = true to always start detached.

To track per-tree CPU cost in the Performance panel, set custom_monitor = true on the BeehaveTree node. This registers beehave [microseconds]/process_time_<actor_name>-<id> as a Performance monitor.

For a walkthrough of writing custom decorators and conditions, see references/custom-nodes.md.

Implementation checklist

  • addons/beehave/ copied into project; plugin enabled in Project Settings → Plugins
  • BeehaveTree added as a child of the actor; actor_node_path set (or left blank to default to parent)
  • process_thread matches actor's loop: PHYSICS for _physics_process, IDLE for _process
  • tick_rate tuned — increase for background NPCs (e.g., 3) to reduce per-frame cost
  • Every tick() override returns SUCCESS, FAILURE, or RUNNING — never void/null
  • ConditionLeaf subclasses never return RUNNING
  • Per-run state written to the Blackboard, not stored on the leaf node itself (leaf nodes are shared)
  • after_run or interrupt cleans up any Blackboard keys the action wrote
  • External Blackboard node exported and shared when multiple BeehaveTree nodes need the same data
  • Visual debugger checked at runtime to verify tick flow before shipping AI logic

© jame581, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (references) in skills/beehave of jame581/GodotPrompter.

  • SKILL.md
  • references/custom-nodes.md

Open the folder on GitHubat commit 1e7d79d

Compare with similar skills

Beehave next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Beehave compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Beehave this skilljame581/GodotPrompter799—~2.8kAutomated safety check: PassMIT
Headless BuildRandallLiuXin/GodotMaker5501 repos~454Automated safety check: PassCustom licence
Godotericrisco/rsc-harness174—~3.6kAutomated safety check: PassMIT
Unityericrisco/rsc-harness174—~4kAutomated safety check: PassMIT
Setup Enginepixel-cellar/Claude-Code-Game-Studios346—~1.5kAutomated safety check: PassMIT
Validate GsdkPlayFab/gsdk170—~645Automated safety check: PassApache-2.0

Similar skills

  • Headless Build

    RandallLiuXin/GodotMaker

    Compile-check a Godot project using headless mode. An agent skill from RandallLiuXin/GodotMaker.

    550 GitHub starsUsed in 1 repo~454 tokens
    Game DevelopmentAuto-check passed

  • Godot

    ericrisco/rsc-harness

    A skill your agent uses when writing, reviewing, or debugging Godot 4.x games in GDScript or C — scenes, nodes, custom Resources, autoload/EventBus signals, typed GDScript, CharacterBody2D/3D…

    174 GitHub stars~3.6k tokensUpdated 2 days ago
    Game DevelopmentAuto-check passed

  • Unity

    ericrisco/rsc-harness

    A skill your agent uses when writing, reviewing or structuring Unity game code in C for Unity 6 LTS — GameObjects and the Transform hierarchy, the MonoBehaviour lifecycle, prefabs and variants…

    174 GitHub stars~4k tokensUpdated 2 days ago
    Game DevelopmentAuto-check passed

  • Setup Engine

    pixel-cellar/Claude-Code-Game-Studios

    配置项目的游戏引擎和版本。将引擎锁定到 CLAUDE.md 中，检测知识缺口，当版本超出 LLM 训练数据时通过 WebSearch 填充引擎参考文档。

    346 GitHub stars~1.5k tokensUpdated 6 mo ago
    Agent WorkflowsAuto-check passed

  • Validate Gsdk

    PlayFab/gsdk

    Validates PlayFab Game Server SDK (GSDK) integrations in game server projects.

    170 GitHub stars~645 tokensUpdated yesterday
    Game DevelopmentAuto-check passed

  • Godot Admob App Open

    poingstudios/godot-admob-plugin

    Provides instructions to implement, load, show, and destroy App Open ads (shown on application startup or app resume) in GDScript and C.

    632 GitHub stars~1k tokensUpdated 8 days ago
    Game DevelopmentAuto-check passed

More from jame581/GodotPrompter

All 58 skills in this repo

  • Godot 2D Essentials

    jame581/GodotPrompter

    Covers Godot 4.3+ 2D systems with GDScript and C# examples: canvas layers, draw order, TileMaps, parallax, lights and shadows, particles and custom drawing.

    799 GitHub stars~2.3k tokensUpdated yesterday
    Auto-check passed

  • Godot 3D Essentials

    jame581/GodotPrompter

    Covers Godot 4.3+ 3D systems such as materials, lighting, shadows, environment, global illumination, fog, LOD, occlusion culling and decals, with GDScript first and C# second.

    799 GitHub stars~3.7k tokensUpdated yesterday
    Auto-check passed

  • Godot Ability System

    jame581/GodotPrompter

    Builds a data-driven ability system in Godot 4 from Resources and a component node, with cooldowns, buffs, stat modifiers, gameplay tags and HUD binding.

    799 GitHub stars~3k tokensUpdated yesterday
    Auto-check passed

  • Godot Addon Development

    jame581/GodotPrompter

    Covers Godot 4.3+ editor plugins: plugin folders, @tool scripts, the EditorPlugin lifecycle, custom inspectors, dock panels and gizmos, in GDScript and C#.

    799 GitHub stars~3.3k tokensUpdated yesterday
    Auto-check passed

  • Godot AI Navigation

    jame581/GodotPrompter

    Covers pathfinding and enemy movement in Godot 4.3 and later: navigation regions, NavigationAgent nodes, steering, behavior trees and patrol routes.

    799 GitHub stars~3.5k tokensUpdated yesterday
    Auto-check passed

  • Godot Animation System

    jame581/GodotPrompter

    Covers animation in Godot 4.3 and later: AnimationPlayer basics, AnimationTree blend trees and state machines, sprite animation, skeleton IK and code-driven motion.

    799 GitHub stars~3.8k tokensUpdated yesterday
    Auto-check passed

Works with

Categories

Questions about Beehave

What does Beehave do?

A skill your agent uses when using the Beehave addon — pure-GDScript behavior trees with composites, decorators, leaves, a blackboard, and a visual runtime debugger. Beehave is an agent skill from jame581/GodotPrompter.

When should I use Beehave?

Beehave fits situations like: using the Beehave addon — pure-GDScript behavior trees with composites; A visual runtime debugger.

How do I install Beehave in Claude Code?

Run `npx skills add jame581/GodotPrompter --skill beehave -a claude-code`. Or copy the skill folder (skills/beehave in jame581/GodotPrompter) into .claude/skills/beehave in your project. Claude Code loads it when a task matches its description.

How do I install Beehave in Codex?

Run `npx skills add jame581/GodotPrompter --skill beehave -a codex`. Or copy the skill folder (skills/beehave in jame581/GodotPrompter) into .agents/skills/beehave in your project. Codex loads it when a task matches its description.

Can I use Beehave in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jame581/GodotPrompter --skill beehave -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/beehave, .gemini/skills/beehave, .github/skills/beehave and .opencode/skills/beehave in your project.

What does Beehave need to run?

SKILL.md names no scripts, command-line tools or credentials: Beehave is instructions for the agent only.

Does Beehave access the network?

SKILL.md names 1 domain. As links in the text: github.com. This is read from the text; nothing was executed.

Is Beehave safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Beehave use?

Beehave is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Beehave use?

About 2.8k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.4k tokens, read only when the agent opens those files.

What are the alternatives to Beehave?

Skills that share tags, products or a category with Beehave: Headless Build (RandallLiuXin/GodotMaker, 550 stars), Godot (ericrisco/rsc-harness, 174 stars), Unity (ericrisco/rsc-harness, 174 stars) and Setup Engine (pixel-cellar/Claude-Code-Game-Studios, 346 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Beehave?

jame581 (a GitHub user) maintains it in jame581/GodotPrompter, which has 799 GitHub stars. The repository holds 58 skills in this directory. The repository was last updated on October 8, 2026.

Source: jame581/GodotPrompter on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.