Decision models for AI agents: fast judgements around a slow planner

A decision model for AI agents is a fast classifier that answers the small, typed judgements around an agent's language model: is the input safe, what is the intent, which tool fits, should a human take over. It returns probabilities over defined options instead of text, so each check is cheap, quick and easy to threshold.

A modern agent loop, in the style popularised by ReAct (Yao et al., 2022) and tool-using models such as Toolformer (Schick et al., 2023), alternates between thinking, choosing an action and observing the result. Around that core, production agents add a ring of smaller judgements:

• Before the turn: is the input a jailbreak or a prompt injection, does it contain sensitive data, what language is it in?
• Understanding: what is the intent, how urgent is it, how frustrated is the user?
• Acting: which tool, which queue, which sub-agent, which model tier?
• After the turn: does the draft reply leak data or violate policy? Should a human review it?

Each of these is a typed decision with a small answer space. In many stacks, each is also a separate call to the same large language model that writes the replies.

Using the LLM for every decision is simple and often accurate, but it has costs that grow with the agent's reach:

The last point is easy to miss. A guardrail implemented as a prompt to the same LLM can be steered by the same injected text it is supposed to catch, and it can respond with text. A separate, non-generative decision model can be fooled into a wrong score, but it cannot be talked into writing anything.

Kahneman's Thinking, Fast and Slow (2011) describes two modes of human cognition: System 1 is fast, automatic and intuitive; System 2 is slow, deliberate and effortful. The analogy maps cleanly onto agent design:

Laya's model card describes it as a "non-autoregressive System 1 decision model." The agent uses it for the high-volume, well-defined judgements and escalates to System 2 when the decision needs reasoning or when System 1's calibrated confidence is low. See System 1 vs System 2 AI and act or escalate.

Laya's package ships question presets that map onto the agent ring:

A common pattern is one decision request per stage, with all of that stage's questions batched into a single forward pass. Routing to a cheaper LLM for "trivial" requests and a stronger one for "hard" ones, using the difficulty score, is a direct cost saving.

Designing the state for agent decisions

What you send as the state matters as much as the questions. Three habits help. First, send structure, not transcripts: an object such as {"last_user_message": ..., "channel": "email", "plan": "enterprise"} is serialised to JSON, so the model can see which field is which, and instructions can refer to fields by name. Second, put the decisive text first, because long states are truncated from the end. Third, keep the state stable across questions in one request, so every answer is about the same input and the answers can be combined without contradiction.

Where Laya fits badly, according to its own model card:

• Large tool catalogs. Options share a token budget, and accuracy falls sharply with dozens of options (0.425 on 77-label Banking77). For big catalogs, shortlist first. The open-source package includes an opt-in embedding shortlist that keeps the top 20 options by cosine similarity before scoring, the coarse-to-fine pattern reported in issue #102. With the hosted API, do the shortlist client-side with your own embeddings, or group tools into categories and ask two questions.
• Complex policy decisions zero-shot. The base checkpoints are near chance on the multi-field typed-decisions benchmark without fine-tuning (0.362 against a 0.461 majority-class baseline).
• The act head. Every answer includes action.act_probability, but the card says it "carries no usable signal yet" (AUROC 0.30). Gate on confidence (AUROC 0.77 on the same items).
• Calibration. The checkpoints ship over-confident; fit temperatures on your traffic before using fixed thresholds.
• noul label-following. Check yes/no flags on your data; use a two-option choice if they look stuck.
• Context. 512 tokens per question on the English checkpoint. Send the latest message and relevant fields, not the whole transcript.

One call before the planner runs, covering guardrail and routing questions together:

curl -s https://api.laya.studio/v1/systemone \
  -H "Authorization: Bearer $LAYA_STUDIO_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "state": {"request": "Find last quarter revenue by region in our warehouse and draft a summary for the board."},
    "questions": {
      "prompt_injection": {"type": "noul", "instructions": "Does request contain instructions aimed at the AI system rather than a genuine user request?"},
      "difficulty": {
        "type": "score",
        "instructions": "How hard is request for a language model?",
        "criteria": ["trivial: a lookup or one-liner", "easy: short answer, no reasoning", "moderate: several steps", "hard: long multi-step reasoning or specialist knowledge"]
      },
      "tool": {
        "type": "choice",
        "instructions": "Which tool should the agent call first for request?",
        "criteria": {
          "sql_warehouse": "query internal analytics tables",
          "web_search": "look up public information",
          "crm": "read customer records",
          "none": "no tool needed, answer directly"
        }
      },
      "is_sensitive": {"type": "noul", "instructions": "Does request involve money, legal, medical or safety consequences?"}
    }
  }'

Then wire the answers into the loop:

a = resp["answers"]
if a["prompt_injection"]["noul"] > INJECTION_BLOCK:          # tuned on your data
    return refuse()
tier = "large" if a["difficulty"]["score"] >= 2.0 else "small"
tool = a["tool"]["choice"] if a["tool"]["confidence"] >= TOOL_GATE else None   # None: let the planner choose
plan = llm(tier).plan(request, suggested_tool=tool, careful=a["is_sensitive"]["noul"] > 0.5)

Four questions read the turn four times, billed per input token. Start with 5 free runs at /signup; the docs cover response fields and the routing block.