Coder Legion - Recent posts tagged finite-state-machines

LLMs are great at novelty. Operations reward determinism.

Thu, 30 Apr 2026 20:37:14 +0000

Most production queries aren't novel - they're recurring patterns that have already been solved.
Re-running them through a full model call every time is unnecessary overhead.

Engram is a proposal for a deterministic operations layer that sits in front of LLMs:

Queries hit a confidence-weighted graph first
High-confidence paths return answers directly - no model call
Novel cases escalate to the LLM, and confirmed answers write back as reusable paths
The graph accumulates knowledge across sessions; model calls decrease over time

The same architecture works as an agent mesh, a structured tool gateway with policy enforcement, and persistent memory for LLM agents via MCP.

This is early-stage (Phase 1 of 15), published as a design proposal, not a product launch. I wrote up the full architecture - the reasoning, the trade-offs, and what's still an open question.

Full article

Live demos & simulations

Learn how FSM_API uses decoupled state machines to run a "Fox and Dog" AI simulation.

Thu, 09 Oct 2025 22:17:48 +0000

Implementing Behavior Trees with FSM_API: The Quick Brown Fox and Lazy Sleeping Dog Demo

Finite State Machines (FSMs) are a foundational pattern for organizing complex logic in software, from game AI to business workflows. The FSM_API library provides a high-performance, engine-agnostic C# solution for building and managing these systems with clarity and efficiency.

This article dives into the Quick Brown Fox and Lazy Sleeping Dog demo, an excellent, practical example found in the FSM_API public repository. It showcases how to implement simple, interacting AI agents, effectively decoupling agent data from agent behavior logic using the library's core features.

FSM_API Core Concepts in the Demo

Every behavioral entity in this simulation—the Fox and the Dog—relies on three core FSM_API concepts:

The State Context (IStateContext): This is your actual game object (the Fox or the Dog), holding the data (e.g., Position, Speed, CollidedAgents) and implementing the transition methods. It must implement the IStateContext interface, which requires providing a Name and an IsValid property.
The FSM Definition: This is the reusable blueprint of states (e.g., "Sleeping", "Walking") and the rules for transitioning between them.
The FSM Instance: This is the live, active version of the blueprint, associated with a specific agent context. Both agents' FSMs are set up to run in the "Update" processing group.

The Lazy Sleeping Dog's Behavior

The LazySleepingDog class is initialized at Position = 3 and starts in the "Sleeping" state. Its FSM defines a classic threat response lifecycle:

State	OnUpdate Action	Transition Condition (to)	Transition Target
Sleeping	Console log: "...is sleeping!"	`IsAwake(context)`: `CollidedAgents.Any()`	Awake
Awake	Console log: "...is awake!"	`ShouldChase(context)`: `VisibleAgents.Any(s => s is QuickBrownFox)`	Chasing
Chasing	`Position` increases by `Speed` (set to 3 on enter)	`IsMangling(context)`: `CollidedAgents.Any(s => s is QuickBrownFox)`	Mangling
Mangling	Console log: "...is Mangling the fox!"	N/A	N/A

Crucially, in the "Mangling" state's OnEnterMangling handler, the dog directly uses the FSM_API to transition the collided agent's state (the Fox) to "Mangled":

// Inside OnEnterMangling for the dog
dog.CollidedAgents.FirstOrDefault()?.State.TransitionTo("Mangled");

The Quick Brown Fox's Behavior

The QuickBrownFox starts at Position = 0 and its FSM defines its attempts to flee the dog and reach a winning position:

State	OnUpdate Action	Transition Condition (to)	Transition Target
Walking	`Position` increases by `Speed` (1)	`ShouldJump(context)`: `VisibleAgents` within 2 units	Jumping
Jumping	`Position` increases by `Speed` (1)	`ShouldLand(context)`: `Position` reaches `JumpEnd` (initial position + 2)	Walking
Fleeing	`Position` increases by `Speed` (set to 2 on enter)	N/A	N/A
Mangled	Console log: "...is being mangled!"	N/A	N/A

The Fox's ultimate defensive move is the transition to "Fleeing", which is triggered by a direct collision with a LazySleepingDog. However, if the Dog catches it while fleeing, the Dog forces the Fox into the terminal "Mangled" state.

The Simulation Loop (`SimpleDemoContext`)

The SimpleDemoContext acts as the game manager, controlling the flow of the entire application. It sets up the following structure:

Processing Groups: It creates a "Main" group for the application's FSM (AppFSM) and an "Update" group where the agents' FSMs run.
Tick Logic: The core simulation runs in OnUpdateExecuting:
- It clears previous frame's agent data.
- It performs Vision and Collision checks based on the agents' current Position and Sight range, populating the VisibleAgents and CollidedAgents lists.
- It calls FSM_API.Interaction.Update("Update"). This single call iterates through and updates all FSM instances assigned to the "Update" group (the Fox and the Dog), triggering their onUpdate actions and checking their transition conditions.
Shutdown: The application's AppFSM transitions to "Shutdown" if a key is pressed, if the Fox reaches the WinPosition (10), or if any agent's state is "Mangled". The FSM_API then manages the cleanup.

The Program.cs file initiates the simulation and loops the main update call until the application context becomes invalid. This structure demonstrates how FSM_API cleanly separates an agent's Data (IStateContext properties) from its Behavioral Logic (the FSM Definition) and relies on a central Simulation Tick (FSM_API.Interaction.Update()) to drive complex, interactive AI.

Stay Tuned for the Advanced Demo

This simple, 1D simulation laid the groundwork, but the next step is building a true environment!

Stay tuned for a follow-up article where we'll use these exact same agent FSMs to create an advanced 2D environment with multiple dogs and foxes interacting simultaneously. This will highlight the true power of decoupled FSM definitions.

Follow us to stay informed! And for much more content, advanced articles, and discussions about our vision for the software for the singularity, check out our:

Patreon Page

Get the Code

You can explore the full implementation of this FSM-driven AI simulation and the FSM_API library structure by cloning the public repository:

https://github.com/TrentBest/SimpleDemos

FSM_API by The Singularity Workshop

Thu, 09 Oct 2025 08:47:52 +0000

Stop Dreaming, Start Building: The Ultimate Flowchart-to-Code Solution

If you've ever felt that programming complex applications was reserved for technical "experts," or if your internal projects become a tangled mess of code after just a few weeks, this is for you.

The FSM_API by The Singularity Workshop is here to eliminate complexity and make solid, professional code accessible to everyone.

The Secret Weapon: If You Can Map a Flowchart, You Can Code It

The biggest barrier to entry isn't complex syntax; it's structure. The solution is the Finite State Machine (FSM).

Imagine any system—a character, a door, an application. It can only be in one State at a time. The FSM forces you to define simple, visual logic for how it moves between those States.

No more nested boolean flags or debugging spaghetti code. Just clean, clear, visual logic.

Designed for Empowerment: The Non-Coder Jumpstart

We built this API to be your ideal entry point into robust application design:

Non-Coder Overview: Our package includes a dedicated guide that translates implementation details directly into understandable, logical flows for beginners.
Foundational Theory: Master the pattern quickly with included guides like "What is an FSM?" and "Core Concepts."

️ Built for Professionals, Accessible to Everyone

As you grow from a beginner to an expert, the FSM_API scales with you. We hide the complexity of enterprise-grade development while still providing its benefits:

True Decoupling & Interoperability: FSM Definitions are reusable logic blueprints, decoupled from your game objects (Contexts). You can dynamically swap the "brain" without touching the "body."
Bulletproof Performance: The API is built from the ground up to be robust and thread-safe. Your application will remain stable, even when logic runs in parallel threads.
Rapid Deployment: Define complex state machines using a fluent, builder-style API that keeps your code concise.

Stop debugging code you don't understand. Start building logical systems that just work!

Nuget: https://www.nuget.org/packages/TheSingularityWorkshop.FSM_API/

Git Repo: https://github.com/TrentBest/FSM_API

Brought to you by:

The Singularity Workshop - Tools for the curious, the bold, and the systemically inclined.
Follow The Singularity Workshop on Patreon

Because state shouldn't be a mess.

Support the project: Donate via PayPal