The Agent Model That Decides Without Talking

The Agent Model That Decides Without Talking

Most agents use a language model to decide what to do, then make the operator infer how certain that decision was from a paragraph of generated text.

Fastino’s GLiDE v1.2 takes the opposite route. It accepts text, JSON, or images, evaluates typed questions, and returns probabilities without generating a single output token. Fastino says the model ranks first on the Hugging Face Decision Index v0.4.1 with a score of 71.5.

The interesting part is not the leaderboard position. It is the interface. An agent can route, escalate, abstain, or ask for help using a number that a policy can inspect, rather than a sentence that another model has to interpret.

The missing primitive in agent loops is a decision boundary

A typical tool loop looks like this:

context -> language model -> prose or tool call -> parser -> action

That loop is flexible, but flexibility is also a liability. The model has to express its choice in a format the harness can parse. The harness then has to decide whether the confidence implied by that choice is sufficient for a side effect.

GLiDE exposes a more constrained path:

context -> decision model -> typed probabilities -> policy -> action

The model card describes three question types:

Question typeResultAgent use
choiceProbability over up to 255 named optionsSelect a tool or route a task
noulProbability of yesGate escalation or approval
scoreProbability over ordered levelsSet priority or risk bands

The model returns probabilities for every option. It does not generate an explanation, and it does not pretend that a free form answer is an authorization token.

That is a useful separation. The language model can propose a plan. A decision model can score whether the next action fits a declared policy. The verifier can then apply a threshold that is visible in configuration and logs.

One forward pass changes the cost of checking everything

Fastino’s announcement says GLiDE was designed for one forward pass per question. Its model card reports zero output tokens for the decision response and says questions can be scored together in micro batches.

That matters because verification is often the first thing operators remove when an agent becomes expensive. If every tool call needs another long reasoning turn, the control loop pays a large latency and token cost for safety. A decision model changes the economics of putting checks around more actions.

A simplified policy might look like this:

result = model.decide(
    state=tool_request,
    questions={
        "risk": {
            "type": "choice",
            "instructions": "What should happen next?",
            "criteria": {
                "allow": "Read-only action inside the workspace",
                "review": "Action needs human approval",
                "deny": "Action exceeds the declared scope",
            },
        }
    },
)

route = result["answers"]["risk"]
if route["choice"] == "allow" and route["confidence"] >= 0.90:
    execute_read_only(tool_request)
elif route["choice"] == "review":
    request_approval(tool_request)
else:
    deny(tool_request)

This is an illustrative policy shape, not a claim that GLiDE has been tested in this harness. The important property is that the threshold and the action mapping live outside the model. The model supplies a measurement. The policy owns the consequence.

Calibration is more useful than confidence theater

A model can be accurate and still be dangerous if its confidence is badly calibrated. An agent that is wrong 10 percent of the time but reports 99 percent confidence is harder to operate than one whose probabilities track its actual error rate.

Fastino says GLiDE v1.2 has one of the lowest calibration errors on the Decision Index. Its own blog reports that the model placed second among eleven decision models on an Artificial Analysis index and had the lowest calibration error in that comparison. Those are vendor reported results, not an independent reproduction.

The distinction matters. A leaderboard score answers whether a model got benchmark items right. Calibration asks whether the number attached to the answer is useful when a policy has to choose a threshold.

For an agent operator, the test is not simply:

Did the model select the right tool?

It is also:

When the model says 0.90, is that decision right often enough
for the side effect I am about to permit?

That question turns model evaluation into policy evaluation. The threshold for deleting a temporary artifact is not the threshold for publishing code, rotating credentials, or changing production infrastructure.

The open weight story is less simple than the headline

GLiDE v1.2 is available on Hugging Face, but the local deployment is not a laptop toy. The model card lists 52.2 GB of bf16 weights and recommends a GPU with at least 80 GB of memory. It also lists a 40,000 token default limit per question prompt.

That creates an important contrast. The decision interface is narrow, but the deployment is substantial.

The open weight release gives an operator more control over the inference process, network boundary, logging, and update schedule. It does not remove the cost of hosting the model, the need to protect its endpoint, or the need to validate its probabilities against the operator’s own workload.

The model card also says the model is for internal use only and documents limits: it chooses among options supplied by the caller, does not generate explanations, and returns model estimates rather than guarantees. Those constraints are features when they are made explicit. A narrow model is easier to place behind a verifier than a general model that can silently expand the task.

What builders should change

The release points toward a split architecture for agents:

  1. Use a generative model for synthesis. Let it read, plan, explain, and propose.
  2. Use a decision model for declared choices. Give it typed questions and bounded options.
  3. Keep authorization in ordinary code. A probability is evidence for a policy, not permission by itself.
  4. Calibrate per action class. A useful threshold for low impact reads may be unsafe for writes or secrets.
  5. Log the decision boundary. Store the question, options, probabilities, selected route, threshold, and final action.
  6. Test abstention. A system that cannot say it does not know will turn uncertainty into an action.

The last point is especially important. Fastino’s training writeup says it treated “I don’t know” as another option rather than adding a special inference time rule. Whether that approach transfers to another workload is an open question, but the design direction is sound: abstention should be part of the decision contract.

The model is not the verifier

GLiDE does not make an agent safe by itself. A model that emits probabilities can still be wrong, manipulated by hostile context, or misapplied to a decision it was never evaluated for.

What changes is the control surface. Instead of asking one language model to produce a plan, confidence signal, and authorization shaped as prose, a builder can separate those jobs.

The agent speaks. The decision model scores. The policy decides. The runner stays inside a scope the model cannot expand.

The useful model is not always the one that says the most. Sometimes it is the one that gives the verifier less to misunderstand.

Sources

Keep reading