Today we release the Generalized Lightweight Decision Engine (GLiDE), a model trained specifically for difficult, structured decisions. Using the official Decision Index 0.2.1 scorer, GLiDE achieves a score of 64.81, leading Jev’s published score of 57.91 by 6.90 skill points. It also outperforms Jev across all five evaluation areas and on 31 of 38 benchmarks, including an 11.5-skill-point lead in Knowledge and Reasoning.

GLiDE turns application state and a predefined set of actions into a structured decision, returning one selected action, a confidence score, and probabilities for every option. It makes a fast initial assessment, then allocates additional reasoning when the choice is uncertain. This adaptive reasoning allows the model to excel in highly complex, multi-hop tasks such as making selections among hundreds of tools, selecting the best next action from hundreds of possible paths, and judging or verifying reasoning-intensive model output.

GLiDE is available via the Fastino API.

Decision Index Performance

The Decision Index evaluates decision models across 38 benchmarks covering knowledge and reasoning, language understanding, retrieval and classification, tools and automation, and arts and human taste. We chose it because it measures broad, practical decision-making across both routine and reasoning-intensive tasks. We report chance-adjusted skill scores, which allow results from benchmarks with different chance baselines to be compared, for the overall index and its five evaluation areas, and raw scores for individual benchmarks.

On the overall index, GLiDE scores 64.81, 6.90 skill points above Jev’s published 57.91. It leads across all five areas and 31 of 38 benchmarks, including by 11.5 skill points in Knowledge and Reasoning.

GLiDE’s strongest results compared to Jev appear in reasoning-intensive tasks and tool use:

• Tools and Automation: 83.5 vs 75.1, a lead of 8.4 skill points

• Knowledge and Reasoning: 62.9 vs 51.4, a lead of 11.5 skill points

• CLadder accuracy: 88.7% vs 72.6%

• CRUXEval accuracy: 92.6% vs 73.0%

These results come from our own complete run with the official scorer. GLiDE has not been added to the public leaderboard, where submissions to version 0.2.1 are currently paused.

Using the GLiDE API

The GLiDE API conforms to the System One model schema, turning application state and predefined options into typed, probabilistic decisions that software can use directly. Each request supplies the relevant context through state and defines one or more decisions under questions. For a choice decision, the criteria field specifies the permitted options.

GLiDE returns each decision under answers, including the selected choice, its confidence margin, and probabilities for every option. Because these values are structured, applications do not need to parse or validate generated text before acting on them. They can execute the selected action, apply confidence thresholds, request human approval, or escalate uncertain cases using ordinary application logic.

The example below asks GLiDE to decide how an agent should handle a destructive tool call:

curl -sS "https://api.fastino.ai/v1/systemone" \
  -H "Authorization: Bearer $FASTINO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "fastino/glide",
    "state": {
      "agent_goal": "Reduce production API latency",
      "proposed_tool_call": {
        "tool": "database.execute",
        "arguments": {
          "environment": "production",
          "sql": "DROP TABLE sessions;"
        }
      },
      "context": [
        "The agent has read-only diagnostic access.",
        "No human approved a destructive change.",
        "The latest verified backup is 18 hours old.",
        "The service is still available."
      ]
    },
    "questions": {
      "next_action": {
        "type": "choice",
        "instructions": "What should the agent controller do?",
        "criteria": {
          "execute": "Run the tool call",
          "ask_permission": "Request explicit human approval",
          "sandbox": "Redirect the operation to a test environment",
          "block_and_escalate": "Block the call and alert an operator"
        }
      }
    }
  }'

curl -sS "https://api.fastino.ai/v1/systemone" \
  -H "Authorization: Bearer $FASTINO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "fastino/glide",
    "state": {
      "agent_goal": "Reduce production API latency",
      "proposed_tool_call": {
        "tool": "database.execute",
        "arguments": {
          "environment": "production",
          "sql": "DROP TABLE sessions;"
        }
      },
      "context": [
        "The agent has read-only diagnostic access.",
        "No human approved a destructive change.",
        "The latest verified backup is 18 hours old.",
        "The service is still available."
      ]
    },
    "questions": {
      "next_action": {
        "type": "choice",
        "instructions": "What should the agent controller do?",
        "criteria": {
          "execute": "Run the tool call",
          "ask_permission": "Request explicit human approval",
          "sandbox": "Redirect the operation to a test environment",
          "block_and_escalate": "Block the call and alert an operator"
        }
      }
    }
  }'

curl -sS "https://api.fastino.ai/v1/systemone" \
  -H "Authorization: Bearer $FASTINO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "fastino/glide",
    "state": {
      "agent_goal": "Reduce production API latency",
      "proposed_tool_call": {
        "tool": "database.execute",
        "arguments": {
          "environment": "production",
          "sql": "DROP TABLE sessions;"
        }
      },
      "context": [
        "The agent has read-only diagnostic access.",
        "No human approved a destructive change.",
        "The latest verified backup is 18 hours old.",
        "The service is still available."
      ]
    },
    "questions": {
      "next_action": {
        "type": "choice",
        "instructions": "What should the agent controller do?",
        "criteria": {
          "execute": "Run the tool call",
          "ask_permission": "Request explicit human approval",
          "sandbox": "Redirect the operation to a test environment",
          "block_and_escalate": "Block the call and alert an operator"
        }
      }
    }
  }'

The response uses the following structure:

{
  "answers": {
    "next_action": {
      "type": "choice",
      "choice": "[SELECTED_ACTION]",
      "confidence": "[CONFIDENCE]",
      "probabilities": {
        "execute": "[EXECUTE_PROBABILITY]",
        "ask_permission": "[ASK_PERMISSION_PROBABILITY]",
        "sandbox": "[SANDBOX_PROBABILITY]",
        "block_and_escalate": "[BLOCK_AND_ESCALATE_PROBABILITY]"
      }
    }
  },
  "usage": {
    "input_tokens": "[INPUT_TOKENS]",
    "output_tokens": "[THINKING_TOKENS]"
  }
}

{
  "answers": {
    "next_action": {
      "type": "choice",
      "choice": "[SELECTED_ACTION]",
      "confidence": "[CONFIDENCE]",
      "probabilities": {
        "execute": "[EXECUTE_PROBABILITY]",
        "ask_permission": "[ASK_PERMISSION_PROBABILITY]",
        "sandbox": "[SANDBOX_PROBABILITY]",
        "block_and_escalate": "[BLOCK_AND_ESCALATE_PROBABILITY]"
      }
    }
  },
  "usage": {
    "input_tokens": "[INPUT_TOKENS]",
    "output_tokens": "[THINKING_TOKENS]"
  }
}

{
  "answers": {
    "next_action": {
      "type": "choice",
      "choice": "[SELECTED_ACTION]",
      "confidence": "[CONFIDENCE]",
      "probabilities": {
        "execute": "[EXECUTE_PROBABILITY]",
        "ask_permission": "[ASK_PERMISSION_PROBABILITY]",
        "sandbox": "[SANDBOX_PROBABILITY]",
        "block_and_escalate": "[BLOCK_AND_ESCALATE_PROBABILITY]"
      }
    }
  },
  "usage": {
    "input_tokens": "[INPUT_TOKENS]",
    "output_tokens": "[THINKING_TOKENS]"
  }
}

The complete request schema, decision types, limits, authentication requirements, and error behavior can be found in our docs.

Adaptive Thinking for Decisions of Varying Complexity

Traditional decision models score a set of options in a single fixed pass. This works well for routine classification, but it limits performance when a decision depends on arithmetic, code tracing, temporal logic, conflicting evidence, or several related facts.

GLiDE addresses this limitation with adaptive thinking. It first produces a fast probability distribution, then allocates additional reasoning when the leading result is uncertain and incorporates that reasoning into the final probabilities. This allows GLiDE to spend more computation on difficult decisions while keeping straightforward ones fast.

By integrating reasoning directly into its structured decisions, GLiDE supports a broader range of capabilities:

• Complex agent and tool decisions. GLiDE can navigate large action graphs, choosing the best next step among hundreds of tools while accounting for dependencies, prior outcomes, permissions, and downstream consequences.

• Multi-step reasoning. Additional computation supports decisions involving arithmetic, dates, code tracing, causal relationships, and policies that depend on several facts.

• Long-context decisions. GLiDE’s context window spans 40k tokens, which can hold policies, contracts, support histories, runbooks, and large application states. Oversized requests are rejected rather than truncated, and thinking tokens share the same context window.

Use cases

GLiDE handles the everyday classification and routing tasks served by existing decision models while extending to decisions that require deeper reasoning. Any application that combines context with a defined set of choices can use the same interface. Straightforward decisions remain fast, while uncertain decisions automatically receive additional reasoning.

• Navigating large agent action graphs. Select the next action from hundreds of tools and possible paths while accounting for prerequisites, previous results, permissions, failure states, and downstream consequences.

• Controlling high-risk agent actions. Evaluate a proposed database, infrastructure, or financial operation against the agent’s permissions, organizational policies, system state, and potential impact before deciding whether to execute, sandbox, request approval, or block it.

• Diagnosing production incidents. Combine alerts, logs, recent deployments, dependency health, and runbook instructions to choose among monitoring, restarting, rolling back, isolating, or escalating.

• Applying complex contracts and policies. Trace cross-references, exceptions, dates, thresholds, and conflicting clauses to determine whether a claim should be approved, rejected, revised, or escalated.

• Verifying reasoning-intensive model output. Check answers that depend on arithmetic, temporal reasoning, code execution paths, causal relationships, or multiple supporting facts, then decide whether to accept, reject, or request revision.

• Resolving constrained operational decisions. Choose among predefined plans using scheduling requirements, eligibility rules, resource limits, configuration dependencies, and competing priorities.

Availability

GLiDE is available for inference today on the Fastino API. For information on pricing and getting started, please refer to our docs.