Back

Building with GLiDE: Multimodal Decisions and Fine-Tuning

Building with GLiDE: Multimodal Decisions and Fine-Tuning

Building with GLiDE: Multimodal Decisions and Fine-Tuning

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:

npm install playwright sharp
npx playwright install chromium
export FASTINO_API_KEY="your_api_key_here"
npm install playwright sharp
npx playwright install chromium
export FASTINO_API_KEY="your_api_key_here"
npm install playwright sharp
npx playwright install chromium
export FASTINO_API_KEY="your_api_key_here"

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:

npx skills add https://docs.fastino.ai --skill fastino-glide
npx skills add https://docs.fastino.ai --skill fastino-glide
npx skills add https://docs.fastino.ai --skill fastino-glide

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 the instructions field.

  • 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:

{
  "primary_button_style": {
    "type": "noul",
    "instructions": "Does the target primary button have orange fill, dark text, and square corners?",
    "criteria": {
      "true": "All three properties match.",
      "false": "At least one property does not match."
    }
  }
}
{
  "primary_button_style": {
    "type": "noul",
    "instructions": "Does the target primary button have orange fill, dark text, and square corners?",
    "criteria": {
      "true": "All three properties match.",
      "false": "At least one property does not match."
    }
  }
}
{
  "primary_button_style": {
    "type": "noul",
    "instructions": "Does the target primary button have orange fill, dark text, and square corners?",
    "criteria": {
      "true": "All three properties match.",
      "false": "At least one property does not match."
    }
  }
}

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.

GLiDE-2B before and after fine-tuning, comparing accuracy, macro precision, macro recall, and macro F1 for speed, lane position, and following gap on held-out simulator scenarios.

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.

Subscribe to our newsletter

Get the latest updates on model releases, product news, and research.

Fastino Inc. (“Fastino”) develops specialized AI models and provides APIs designed to support structured data extraction, classification, reasoning, and production AI workflows. Fastino is a technology company and does not provide legal, financial, compliance, or advisory services.

Any outputs, predictions, classifications, or decisions generated through Fastino models are based on the configuration, data, and implementation provided by the customer. Fastino does not control, verify, or guarantee the accuracy, completeness, or suitability of model outputs for any specific purpose. By using this website or Fastino’s models and services, you acknowledge that all content and outputs are provided for informational and operational purposes only and agree to our Terms of Use and Privacy Policy.

2026 Fastino Inc.

All rights reserved

Subscribe to our newsletter

Get the latest updates on model releases, product news, and research.

Fastino Inc. (“Fastino”) develops specialized AI models and provides APIs designed to support structured data extraction, classification, reasoning, and production AI workflows. Fastino is a technology company and does not provide legal, financial, compliance, or advisory services.

Any outputs, predictions, classifications, or decisions generated through Fastino models are based on the configuration, data, and implementation provided by the customer. Fastino does not control, verify, or guarantee the accuracy, completeness, or suitability of model outputs for any specific purpose. By using this website or Fastino’s models and services, you acknowledge that all content and outputs are provided for informational and operational purposes only and agree to our Terms of Use and Privacy Policy.

2026 Fastino Inc.

All rights reserved

Subscribe to our newsletter

Get the latest updates on model releases, product news, and research.

Fastino Inc. (“Fastino”) develops specialized AI models and provides APIs designed to support structured data extraction, classification, reasoning, and production AI workflows. Fastino is a technology company and does not provide legal, financial, compliance, or advisory services.

Any outputs, predictions, classifications, or decisions generated through Fastino models are based on the configuration, data, and implementation provided by the customer. Fastino does not control, verify, or guarantee the accuracy, completeness, or suitability of model outputs for any specific purpose. By using this website or Fastino’s models and services, you acknowledge that all content and outputs are provided for informational and operational purposes only and agree to our Terms of Use and Privacy Policy.

2026 Fastino Inc.

All rights reserved