Guide

GLiDE is Fastino Labs' family of decision models for tasks with a defined set of possible answers. You provide context and permitted outcomes, and it returns structured results such as selected options, scores, or yes/no probabilities, along with confidence information. By scoring outcomes in one forward pass per question, GLiDE avoids the text-generation overhead of a generative LLM. This supports fast decisions with more predictable inference times, helping applications handle repeated requests and respond as inputs change. Earlier this month, we released five GLiDE models, ranging from 0.4B to 27B parameters.
Spam filtering and support ticket triage are common uses for decision models because each task has a clear set of outcomes. In this tutorial, we use GLiDE to show how the same approach works for design review and simulated driving. The first project is a brand checker for design and marketing teams. GLiDE began with text-only inputs, but its vision capabilities now let us compare website screenshots with written brand rules and visual references. We'll show how to prepare those inputs and turn brand guidelines into concrete checks for your own brand.
Our driving simulator uses a compact model for fast, repeated decisions as traffic and road conditions change. We used the Fastino Training Agent to fine-tune it on labeled text reports, teaching it to choose speed, lane position, and following distance according to the simulator's driving policy.
Demo 1: Build a visual brand checker
As we add pages and content to our website, some designs drift from our brand guidelines. Even a page with the right logo can feel off brand because of its buttons, typography, or imagery. Our checker compares selected page regions against rules derived from our brand guidelines, using logo and imagery references where relevant.
1. Gather written guidance and visual references
Start with a clearly defined brand system and guidelines that GLiDE can use as the basis for its reviews. For our demo, we exported our guidelines as HTML and extracted the color values, font specifications, logo artwork, reference images, and example graphics. HTML made those materials easier to access, but you can prepare them in another format.
You can begin with a smaller package focused on the elements you want to review:
Input | What to include |
|---|---|
Brand brief | Concrete rules for the elements you want to check, including exact values and exceptions where relevant |
Logo reference | Your official logo artwork |
Imagery references | One or two images illustrating the intended visual treatment |
Evaluation candidate | The page or design being evaluated, kept separate from references |
2. Define the assessment criteria
Before building the brand checker, turn the guidance into explicit checks. For each one, name the element being reviewed, the evidence needed, what passes or fails, and any exceptions. Our demo groups its checks into seven categories: identity, colors, typography, layout, components, imagery, and voice.
Here are three examples of simplified checks:
Check | What passes | What fails | When to leave it unchecked |
|---|---|---|---|
Primary button | Orange fill, dark text, and square corners | White text on orange | When the component isn't a primary button |
Logo | Official artwork with its proportions preserved | Distorted artwork | When the visible region provides too little evidence to judge identity |
Nature imagery | Photography that matches the references' motion and atmospheric light | A visual style that conflicts with the references | For product screenshots, logos, and icons, which need their own criteria |
The demo uses a more detailed rubric. Use this format to define checks based on your own brand rules and visual references.
3. Set up capture and inference
For this demo, we chose a Node.js server with Playwright and Sharp. GLiDE doesn't require this setup, so you can use other tools to capture pages and process images.
To follow our setup, get a Fastino account and API key and install:
Node.js 22 or later, with npm.
Playwright and Chromium for browser automation, screenshots, and element coordinates.
Sharp for cropping and resizing images.
From your Node.js project:
Keep the key on the server, which sends the review images and rules to Fastino for inference. If you're using a coding agent, the Fastino GLiDE skill provides integration guidance:
4. Capture regions with enough context
Capture the page, then save an ID, bounding box, visible text, and crop for each component you want to review. Include a wider image of the surrounding page so the model can distinguish a primary action from a secondary link. For uploaded designs, let the reviewer select regions manually.
Keep each component's original position and size so the brand checker can outline the right area, even if the image sent to GLiDE is resized. Exact font checks need browser evidence, such as computed styles, because pixels alone may be insufficient.
5. Turn each rule into a decision
Call the GLiDE inference API at POST /v1/systemone, with model set to fastino/GLiDE. Build each request from the rubric:
Put a cropped image of the component, surrounding context, and captured text/style information in
state.Add clearly labeled logo or imagery references only when relevant.
Add each brand check to
questions, with its rule written in theinstructionsfield.Tell GLiDE to review the page's text as content and ignore any commands written on the page.
Our imagery requests use four images: the target, surrounding context, and two style references. That reaches the API's current four-image limit, so attach references selectively.
This simplified entry in questions checks a primary button. Our demo separates these styling properties into several checks. The noul answer gives the probability that the button meets the stated rule:
The demo adds a separate choice question for checks that depend on applicability or sufficient context, including identity, layout, voice, and code frames. Other checks are selected by component type. The evidence question has three outcomes:
ready: the rule applies to this component, and the images and text provide enough detail to check it.not_applicable: the component has no content that this rule is meant to check.insufficient_evidence: the rule may apply, but the images or text don't show enough detail to decide.
The binary and evidence questions go in the same request. For checks using this pattern, the brand checker shows “On brand” or “Not on brand” only when the evidence answer is ready. Otherwise, it explains why the check was skipped.
6. Connect findings to the design
Use each component's saved ID to connect its answers to the design. We would recommend that the interface should:
Link findings to clickable annotations using the captured coordinates.
Show completed findings in page order, using a moving scan to guide reviewers through the design.
Show errors and unchecked regions alongside completed findings.
GLiDE judges the submitted region, while the brand checker places the annotation. Let reviewers inspect the probabilities alongside each finding.
7. Test a controlled change
Review an approved design and a copy with one deliberate violation, such as white text on an orange primary button. Check whether the judgment changes and the annotation points to that button.
Also test an image showing only the component being reviewed, with too little surrounding context to judge it, and check whether the brand checker leaves the result unchecked. Handle missing reference files explicitly as errors or unchecked results, never as passes.
Demo 2: Fine-tuning decision models for a driving simulator
Our city driving simulator uses GLiDE-2B fine-tuned with the Fastino Training Agent. The model chooses speed, lane position, and following-gap intents from text telemetry.
The reason to fine-tune is to teach GLiDE the simulator's driving policy. Each action has a defined meaning for the controller, and the expected choice depends on how your policy weighs visibility, road conditions, and nearby traffic. For example, your policy might call for a slower speed and longer following gap in fog, even when the traffic layout stays the same.
We generated about 30,000 labeled scene reports from the simulator, including matched pairs where only the weather or visibility changed. We used 23,998 of those reports to fine-tune GLiDE against the decisions required by our driving policy.
The recording shows children at a crosswalk, a swerving cyclist, a lane closure, and an approaching emergency vehicle, with decisions and probabilities beside the scene.
The recording replays saved GLiDE answers alongside the simulation.
The simulator renders the 3D scene for viewers, but sends only text to GLiDE. Current GLiDE fine-tuning accepts text-only decision rows.
1. Define the scene report and permitted actions
Convert telemetry into a consistent report covering the road, weather, visibility, nearby pedestrians, cyclists, and vehicles. Include your vehicle's state and relevant distances. If you don't have a dataset to start with, the Fastino Training Agent can help generate training examples for the scenarios you want the model to handle.
Use a separate choice question for each intent. For example:
Decision | Example permitted outcomes |
|---|---|
Speed | Proceed, ease off, slow down, stop, or yield |
Lane position | Keep lane, nudge left or right, change lanes, or pull over |
Following gap | Normal, extended, or wide |
Your expert policy should specify when each outcome is appropriate and how to resolve competing demands. A controller translates the selected intents into steering, braking, and acceleration.
Make sure each outcome has enough training examples, including less common lane-change actions, and evaluate those actions separately.
2. Give the Training Agent an objective and evaluation criteria
Give the Training Agent the decisions above, your expert policy, and available simulator data. Set out the requirements for training and evaluation:
Expected labels for scene reports, including matched cases where only weather or visibility changes.
Separate training and evaluation scenarios, so neighboring ticks do not appear in both sets.
A base-model comparison and targets for decision quality and response latency.
The Training Agent can prepare data, run experiments, and compare models against your requirements. Review the training plan before experiments begin, then use the evaluation report to decide which model to integrate. Access is available by request.
3. Evaluate decisions and driving behavior
On held-out scenarios, fine-tuning raised our accuracy from 43% to 80% for speed, 36% to 88% for lane position, and 46% to 94% for following gap.

For your own evaluation, check both the model's choices and the simulator's behavior:
Compare the base and fine-tuned models on held-out reports using the same questions and options.
Replay scenarios with the controller to check actions such as stopping at a crosswalk or making room for a cyclist, recording outcomes and end-to-end latency.
Test delayed responses to verify that the controller rejects stale decisions and follows its fallback behavior.
Deploy GLiDE for your own use case
For your own project, define what GLiDE should decide and how you'll check its answers against your rules or labeled examples.
Explore the demo library for more applications built with GLiDE and GLiNER.
Try GLiDE on the Fastino platform with your own inputs and decision criteria.
Request access to the Fastino Training Agent to explore agentic post-training of open weight models like GLiDE, GLiNER, and more. Or use the Fastino Training API to run your own training workflow.