What is state machines in AI Agents? A Guide for developers in wealth management

State machines are a way to model an AI agent as a set of explicit states, with rules that control how it moves from one state to another. In AI agents, a state machine defines what the agent is allowed to do next based on its current state, the input it received, and the outcome of the last action.

How It Works

Think of a state machine like a wealth management onboarding workflow.

A client starts in New Lead, moves to KYC Pending, then Risk Profile Collected, then Account Ready, and finally Active Client. The system does not guess the next step. It checks the current state, evaluates the event, and transitions only when the required conditions are met.

That is exactly how you want an AI agent to behave in regulated environments.

Instead of letting the model freewheel through a long conversation, you constrain it with states such as:

• •idle
• •collecting_documents
• •verifying_identity
• •waiting_for_approval
• •ready_to_execute
• •escalated_to_human

Each state has:

• •Allowed inputs
• •Allowed actions
• •Exit conditions
• •Fallback paths

For example, if the agent is in verifying_identity, it should not start discussing portfolio allocation. It should either:

• •ask for missing documents,
• •call an identity verification service,
• •or escalate if verification fails.

That is the main value: predictable control flow.

A useful analogy is a bank branch queue.

You do not walk straight from the entrance to approving a mortgage. You check in, wait for triage, get routed to the right desk, and only then proceed. A state machine makes an AI agent behave like that queue system instead of like a chatty intern with too much autonomy.

Simple flow example

stateDiagram-v2
    [*] --> idle
    idle --> collecting_documents: user starts onboarding
    collecting_documents --> verifying_identity: docs uploaded
    verifying_identity --> waiting_for_approval: verification passed
    verifying_identity --> escalated_to_human: verification failed
    waiting_for_approval --> ready_to_execute: compliance approved
    ready_to_execute --> [*]

In practice, your agent runtime stores the current state in a database or workflow engine. Every user message or tool result becomes an event that triggers a transition. The LLM can still help interpret intent or draft responses, but the state machine decides what happens next.

Why It Matters

Developers in wealth management should care because state machines solve problems that show up immediately in production:

• •

  They reduce regulatory risk

  You can prevent an agent from taking actions out of sequence. No portfolio recommendation before suitability checks. No account opening before KYC completion.

• •

  They make behavior testable

  You can unit test each transition: given state X and event Y, expect state Z. That is much easier than testing open-ended prompt behavior.

• •

  They support human-in-the-loop workflows

  Escalation is just another transition. If confidence drops or compliance flags appear, route to an advisor or operations team.

• •

  They improve auditability

  You get a trace of what happened and why. That matters when compliance asks why an agent recommended one path over another.

Real Example

Consider an insurance or wealth management onboarding assistant for high-net-worth clients.

The agent’s job is to help collect documents, verify identity, confirm risk tolerance, and prepare the account for advisor review. A naive chat agent might answer questions well but fail badly on process control. A state machine keeps it disciplined.

Scenario

A client wants to open a managed investment account.

States

• •start
• •collecting_personal_info
• •collecting_financial_profile
• •verifying_kyc
• •checking_suitability
• •advisor_review
• •approved
• •rejected

Transitions

• •If the client provides name, address, and tax ID → move to collecting_financial_profile
• •If financial profile is complete → move to verifying_kyc
• •If KYC passes → move to checking_suitability
• •If suitability score is within policy → move to advisor_review
• •If advisor approves → move to approved
• •If any step fails → move to rejected or advisor_review depending on policy

What the AI agent does at each step

This setup gives you two layers of control:

• •The LLM handles language and extraction.
• •The state machine handles process logic.

That split matters in wealth management because most failures are not about language quality. They are about sequence violations:

• •wrong order of operations,
• •skipped compliance steps,
• •incomplete handoffs,
• •unlogged decisions.

A state machine prevents those failures by design.

Related Concepts

If you are implementing this pattern in an AI agent stack, these topics sit right next to it:

• •

  Workflow orchestration

  Tools like Temporal, Step Functions, or durable execution engines often host the actual state transitions.

• •

  Finite State Machines vs Statecharts

  Statecharts add hierarchy and parallel states when simple flat states get messy.

• •

  Tool calling / function calling

  The LLM decides which tool to invoke; the state machine decides whether that tool is allowed now.

• •

  Human-in-the-loop review

  Essential for suitability checks, exception handling, and compliance escalation.

• •

  Conversation memory

  Memory stores context; state machines store process position. They are not the same thing.

Keep learning

• •The complete AI Agents Roadmap — my full 8-step breakdown
• •Free: The AI Agent Starter Kit — PDF checklist + starter code
• •Work with me — I build AI for banks and insurance companies

By Cyprian Aarons, AI Consultant at Topiax.