
Researcher @fastinoAI | Creator of GLiNER Models (GLiNER2, GLiNER2.5, GLiGuard) https://xitter.cf/t.co/pajN3oi7ZO
Reunion Island
Joined February 2014
- Tweets3K
- Following330
- Followers825
- Likes3.6K
urchade retweeted
You can now post-train Qwen3.6-35B-A3B with the Fastino Training API. Here are 3 ideas for what you can build:
Decision model → FT on context-plus-options pairs labeled with the correct choice. RL rewards picking the right option with well-calibrated confidence in a single short answer.
Text-to-SQL analyst → SFT on question-to-query pairs for a specific database schema. RL runs each query and rewards an exact match with the correct result set.
Fast reasoner that thinks less → SFT on concise reasoning traces for math or code. RL rewards correct answers minus a penalty for thinking tokens, so it gets cheaper while maintaining accuracy.
Training API: agent.fastino.ai
The Fastino Training API now supports Qwen3.6-35B-A3B for training and inference.
It’s strong at coding and reasoning, with tool calling to plan and execute multi-step agentic workflows, making it a great foundation for production AI that needs to make decisions and take action.
The model is also multimodal, supporting text, image, and video inputs.
Start training: agent.fastino.ai
urchade retweeted
6 lessons from fine-tuning @NVIDIAAI Nemotron 3.5 Super VL across finance, healthcare and math:
1. Teach the interface; Super already has the knowledge
-Largest gains from learning exact programs, spans + output fields
-Small amounts of format-specific data made a huge difference
-Focus on the artifact, not explanatory prose
2. A few hundred correctly labeled examples go a long way
-500 examples produced a 42-point accuracy gain
-Only 15 minutes of training
-Correctness + consistent formatting mattered more than volume
3. Mix skills to protect neighboring tasks
-Narrow tuning pulled related tasks toward the wrong output format
-More single-skill data made the interference worse
-A balanced mixture preserved multiple behaviors
4. Recipes transferred to Nemotron Super
-Data + hyperparameters developed on Nemotron 3.5 Lightning reused unchanged
-Transfer held across every task measured
-Recipe search on the smaller model, then one run on Super
5. Fine-tuning teaches length, not just content
-One task went from 1,597 → 113 output tokens
-Accuracy still increased by 8.4 points
-Math RL produced 25% shorter answers + ~6 points higher accuracy
6. Use 1x to 2x the full-adapter learning rate, and give the model room to think
-2x LR produced larger healthcare gains on 7 of 8 evaluations
-Higher token limits prevented strong answers from being cut off
-At 1,024 tokens, 39% of base math responses were truncated
For more on benchmarks and training recipes see our latest blog.
Blog: fastino.ai/blog/nvidia-nemot…
urchade retweeted
Replying to @NVIDIAAI
@NVIDIAAI and we go together like peanut butter and jelly. 😋 Incredible work from the genius @DhruvAtreja1 👏👏🔥🔥
We collaborated with @NVIDIAAI on early access post-training. Spoiler alert: It's an incredible model to train!
Technical blog: fastino.ai/blog/nvidia-nemot…
urchade retweeted
Today we’re launching the Fastino Training API for supervised fine-tuning and reinforcement learning.
The Fastino Training API includes day-zero support for @NVIDIAAI Nemotron 3.5 Super VL, alongside Nemotron 3.5 Lightning.
Our API gives ML and research teams low-level control over post-training without requiring them to provision GPUs or operate separate training and generation systems.
A few highlights:
• Write your own SFT and RL loops in Python
• Train with importance sampling, PPO, CISPO, or DRO
• Run grouped sampling with token log probabilities
• Save and resume adapter and optimizer checkpoints
• Pay per token processed, not per GPU hour
• Spend 25% to 85% less than Tinker’s published rates
• Migrate existing Tinker workloads by changing only the server address and API key
Along with the Training API, we’re releasing two start-of-the-art open weight models fine-tuned on NVIDIA Nemotron 3.5 Super VL, specialized for finance and healthcare. Together, they improved performance across all 15 held-out benchmarks we measured.
And for a limited time, we’re offering discounted pricing on training for NVIDIA Nemotron 3.5 Super VL through the Fastino Training API.
Try it now: agent.fastino.ai/
urchade retweeted
We just launched the cheapest training API in the world, and all the routes are tinker compatible!
Today we’re launching the Fastino Training API for supervised fine-tuning and reinforcement learning.
The Fastino Training API includes day-zero support for @NVIDIAAI Nemotron 3.5 Super VL, alongside Nemotron 3.5 Lightning.
Our API gives ML and research teams low-level control over post-training without requiring them to provision GPUs or operate separate training and generation systems.
A few highlights:
• Write your own SFT and RL loops in Python
• Train with importance sampling, PPO, CISPO, or DRO
• Run grouped sampling with token log probabilities
• Save and resume adapter and optimizer checkpoints
• Pay per token processed, not per GPU hour
• Spend 25% to 85% less than Tinker’s published rates
• Migrate existing Tinker workloads by changing only the server address and API key
Along with the Training API, we’re releasing two start-of-the-art open weight models fine-tuned on NVIDIA Nemotron 3.5 Super VL, specialized for finance and healthcare. Together, they improved performance across all 15 held-out benchmarks we measured.
And for a limited time, we’re offering discounted pricing on training for NVIDIA Nemotron 3.5 Super VL through the Fastino Training API.
Try it now: agent.fastino.ai/
urchade retweeted
We collaborated with @NVIDIAAI on early access post-training. Spoiler alert: It's an incredible model to train!
Technical blog: fastino.ai/blog/nvidia-nemot…
urchade retweeted
Best Nemotron model I've used on agentic multi-turn tasks. Our team at @fastinoAI had early access to the weights and this one is plugged into a few of my agents. Awesome work guys 👏 @NVIDIAAI
urchade retweeted
Today we’re launching the Fastino Training API, a low-level post-training API for running SFT and RL loops on hosted GPUs, along with day-zero support for @NVIDIAAI Nemotron 3.5 Super VL.
The API gives users control over the training loop, data, rewards, and evaluations, while handling the infrastructure for model execution, sampling, gradient computation, weight updates, and checkpoints.
The Fastino Training API is fully compatible with the Tinker SDK and cookbook, so teams can run existing SFT and RL workflows on it without rewriting their training loops.
Switching over from Tinker can reduce post-training costs by 25% to 85%, and setup is easy. Just swap the server address and API key in your environment, and your training and sampling clients, model configurations, and tooling stay the same.
In addition to day-zero support for Nemotron 3.5 Super VL, the Fastino Training API supports training for Nemotron 3.5 Lightning.
To celebrate the launch of the model, we’re offering a limited-time discount on training for Nemotron 3.5 Super VL on the Fastino Training API.
We’re also releasing two open weight specialized models fine-tuned from NVIDIA Nemotron 3.5 Super VL using the Fastino API, one for finance and one for healthcare. Both models showed improved performance across all 15 benchmarks we measured.
Start training: agent.fastino.ai/
Read the launch blog: fastino.ai/blog/fastino-trai…
urchade retweeted
Artificial Analysis officially ranked GLiDE as the # 2 Decision Model in the WORLD 🤯🤯🤯
Trained a SOTA foundational model that is # 2 in the world according to the holy grail benchmark, Artificial Analysis. Lifetime personal bucket list item ✅
What a life 🤯
urchade retweeted
Great to see GLiDE at #2, and we have a huge update coming out this week
Seeing the model perform this well on a completely independent evaluation shows just how strong the model is
Is seems adaptive thinking is a big reason why:
-GLiDE first calculates a fast probability distribution
-If the leading answer is uncertain, reasoning turns on
-That reasoning is incorporated into the final probabilities
Easy decisions stay fast, harder decisions get extra compute. This is especially useful for knowledge, reasoning and complex tool routing, where most decision models fail
We will be releasing the weights and a full rundown on how we trained the model with our training api
Try it through the Fastino API with code USE_GLIDE for free credits.
Introducing the Artificial Analysis Decision Index, benchmarking decision models across classification, tool calling, knowledge and reasoning. Jev leads among decision models; language models such as Claude Haiku 5.5 still deliver higher accuracy, but at much higher cost and latency
Decision models deliver structured answers or classifications with associated probabilities, offering faster responses and lower costs than using language models. The Artificial Analysis Decision Index v1.0 compares the capability, cost, and speed of decision models and also compares to language models.
Benchmarks in the Artificial Analysis Decision Index v1.0:
➤ AA-Omniscience-Decision: A private dataset of 500 questions adapted from the proprietary AA-Omniscience benchmark, measuring decision models’ knowledge and tendency to hallucinate
➤ HLE-MultiChoice: 513 text-only multiple-choice questions from Humanity’s Last Exam, testing decision models’ reasoning capabilities
➤ When2Call: A tool-calling benchmark from NVIDIA, testing whether models can correctly decide to call a tool, request clarification, decline to answer, or respond directly, evaluating capabilities relevant to agentic workflows and tool routing
➤ WildGuardTest: A safety benchmark evaluating models’ classification capabilities across harmful user requests, assistant refusals, and harmful responses. We use a subset of 835 of the original 1,725 test rows where all three human annotators agreed on all three labels, after excluding questions that consistently trigger model refusals
Key results:
➤ Jev 1.13 leads the Decision Index, and sits on the Capability vs. Cost Pareto frontier: Jev 1.13 from @typesafeai scores 58 on the Artificial Analysis Decision Index, ahead of GLiDE (54) from @fastinoAI and Microsoft-Decision-1 (54) from @Microsoft. Decider v1.1 27B from @perplexity_ai has the lowest Cost per 1M Tasks at $17, with Microsoft-Decision-1 ($31) and Jev 1.13 ($42) also on the Capability vs. Cost Pareto frontier. Celeris-1 Decision has the fastest Time per Task at 0.06 seconds, more than 2x faster than Jev 1.13 (0.13 seconds per task)
➤ Decision models are poorly calibrated on knowledge and reasoning tasks: Across almost all probability levels for chosen answers, accuracy falls below that probability for all decision models. This gap is largest on AA-Omniscience-Decision and HLE-MultiChoice, while most models are relatively well-calibrated on WildGuardTest (classification) and When2Call (tool calling)
➤ Decision models offer significant speed and cost advantages over language models, but trail on knowledge and reasoning: On classification and tool-calling tasks, leading decision models perform comparably to language models while being significantly faster and cheaper. However, language models substantially outperform on knowledge and reasoning. Claude Haiku 5.5 (Low) scores 61 on the Decision Index, 3 points ahead of Jev 1.13, but takes 1.4 seconds per task vs. 0.13 seconds (11x slower) and costs $184 per 1M Tasks vs. $42 for Jev 1.13 (4.4x more expensive)
We will continue to develop the Artificial Analysis Decision Index to help developers and companies better understand when and how to use decision models.
urchade retweeted
I paired Jev and GLiNER with an LLM coaches to play Doom:
- GLiNER makes split-second calls, and the LLM sets the strategy ("go get a plasma rifle")
- GLiNER gained far more from LLM coaching than Jev. Massively outperforming solo-Jev, Jev+LLM, and solo-GLiNER
urchade retweeted
Everyone is talking about specialized models today, so perfect timing to show this! I gave the Fastino Agent one goal: teach GLiNER Decide to play Mario. It built data, fine-tuned via our API, analyzed failures, and ran each new experiment autonomously. The before/after is wild
urchade retweeted
Next week, we’re headed to Berlin for @NVIDIAGTC.
We’re excited to connect with the community, explore the latest developments in AI, and share what we’ve been building.
If you’re attending and want to chat, schedule a meeting with our team here: calendly.com/d/d32c-tcj-b73/…
urchade retweeted
This is what we are seeing all over. Building your own frontier model isn’t hard anymore.
Specialists beat generalists. And you don’t need a special set of skills.
Fine-tuning a SOTA model can be done by your agent.
The decision model wave is finally opening eyes to model overkill. Let’s go 🥷
We were able to fine tune an open weight model (Qwen3.5-9B) on proprietary internal data at @coinbase, and it out performed frontier models, at much lower cost and speed, for a specialized task (fraud prevention in this case).
I think we'll see more of this pattern inside companies. The frontier models are amazing generalists. But increasingly you'll see specialist models out perform on more narrow tasks, either working on teams, or by themselves.
We're making it easy to fine tune models internally for our employees. We even have a skill for it in our internal harness that makes it easy to spin these up and start training them:
"/fine-tune-and-serve-llm I want to fine-tune Qwen for payments risk review. help me get started"
I imagine we'll have some backend services that could be replaced entirely by this new architecture.
urchade retweeted
there's a critical difference between benchmaxxed models and ones made by people who truly care about reliability that, by definition, doesn't show up on benchmarks
(we've somewhat learned this for string LLMs...)
Replying to @julianharris
There's something wet-sponge-feeling about the qwen fine tunes that I can't explain compared to Jev
urchade retweeted
Your coding agent can now use our models.
If you're building with Cursor, Claude Code, or Codex, you can plug GLiDE and GLiNER2.5-Decide straight into your projects using our new agent skills. Use them for classification, tool selection, evaluation, routing, and complex decision-making.
Setup is easy:
1. Create a Fastino account and grab your API key
2. Install the GLiDE or GLiNER skill
3. Give your agent access to your Fastino API key
4. And start building
From there, your agent can figure out where Fastino models fit into your workflow and help implement them directly into your application.
Get your API key: agent.fastino.ai
Learn how to use the skills:
- GLiDE skill: docs.fastino.ai/concepts/gli…
- GLiNER skill: docs.fastino.ai/concepts/gli…
urchade retweeted
Natty or not? 🏋️ We asked our SOTA decision model GLiDE to judge 9 famous gym transformations.
It matched human expert labels by More Plates More Dates and Greg Doucette 9/9. @Derek_Fitness
Move over, Jev.
Introducing GLiDE, the first decision model that thinks.
Ranks #1 on the Decision Index, beating Jev by 6.9 points.
GLiDE uses adaptive thinking. To give you an idea of how it works:
It calculates a fast probability distribution.
If the leading answer is uncertain, reasoning is turned on.
Reasoning is then incorporated into the final probabilities.
This means that the model only uses reasoning capabilities for the complex decisions that need them, keeping the model fast while also expanding the types of tasks it can do.
As a result, GLiDE outperforms Jev by 11.5 points in Knowledge and Reasoning and across all five evaluation areas of the Decision Index.
Reasoning allows GLiDE to perform highly complex tasks that traditional decision models struggle with, including:
Choosing among hundreds of tools and possible paths.
Executing, sandboxing, escalating, or blocking sensitive operations.
Checking outputs involving arithmetic, code, dates, or multiple facts.
GLiDE is available now through the Fastino API. Use code USE_GLIDE for free credits.
GLiDE API: agent.fastino.ai
Try GLiDE !!!
Introducing GLiDE, the first decision model that thinks.
Ranks #1 on the Decision Index, beating Jev by 6.9 points.
GLiDE uses adaptive thinking. To give you an idea of how it works:
It calculates a fast probability distribution.
If the leading answer is uncertain, reasoning is turned on.
Reasoning is then incorporated into the final probabilities.
This means that the model only uses reasoning capabilities for the complex decisions that need them, keeping the model fast while also expanding the types of tasks it can do.
As a result, GLiDE outperforms Jev by 11.5 points in Knowledge and Reasoning and across all five evaluation areas of the Decision Index.
Reasoning allows GLiDE to perform highly complex tasks that traditional decision models struggle with, including:
Choosing among hundreds of tools and possible paths.
Executing, sandboxing, escalating, or blocking sensitive operations.
Checking outputs involving arithmetic, code, dates, or multiple facts.
GLiDE is available now through the Fastino API. Use code USE_GLIDE for free credits.
GLiDE API: agent.fastino.ai
urchade retweeted
Introducing GLiDE, the first decision model that thinks.
Ranks #1 on the Decision Index, beating Jev by 6.9 points.
GLiDE uses adaptive thinking. To give you an idea of how it works:
It calculates a fast probability distribution.
If the leading answer is uncertain, reasoning is turned on.
Reasoning is then incorporated into the final probabilities.
This means that the model only uses reasoning capabilities for the complex decisions that need them, keeping the model fast while also expanding the types of tasks it can do.
As a result, GLiDE outperforms Jev by 11.5 points in Knowledge and Reasoning and across all five evaluation areas of the Decision Index.
Reasoning allows GLiDE to perform highly complex tasks that traditional decision models struggle with, including:
Choosing among hundreds of tools and possible paths.
Executing, sandboxing, escalating, or blocking sensitive operations.
Checking outputs involving arithmetic, code, dates, or multiple facts.
GLiDE is available now through the Fastino API. Use code USE_GLIDE for free credits.
GLiDE API: agent.fastino.ai
urchade retweeted
Using decision models to book flights to SFO are boring so why not have a decision model land a flight at SFO instead. GLiDE can do just that, adjusting to weather conditions live it is able to safely land at SFO using our GLiDE Fastino API in realtime.
Give it a go yourself on agent.fastino.ai and if you build something cool tag @henryfastino or @fastinoAI and we'll see if we can hook you up with some free credits.
Introducing GLiDE, a thinking decision model built for reasoning-intensive decisions.
Using the official Decision Index 0.2.1 scorer, GLiDE scores 64.81, leading Jev by 6.90 skill points and outperforming it across all five evaluation areas, including an 11.5-point lead in Knowledge and Reasoning.
Typically, decision models are designed to score a set of options in one pass. GLiDE takes that process a step further by recognizing when a decision requires more effort.
After producing an initial answer, GLiDE quickly assesses its confidence. When the result is uncertain, the model automatically allocates more compute to thinking further and incorporates that reasoning into its final probabilities.
This allows GLiDE to move beyond straightforward classification into complex, multi-step decisions like selecting from hundreds of tools, choosing the best next action from hundreds of possible paths, or judging and verifying reasoning-intensive model outputs.
With every decision, it returns:
• The selected action
• A corresponding confidence score
• A probability distribution across the available options
GLiDE is available today for inference and training on the Fastino API.
Try it now on the Fastino API: agent.fastino.ai
Read the release blog: fastino.ai/blog/introducing-…



























