0.1s
When it comes to AI, I think there's one term everyone is pretty familiar with, LLM, large language model. But you'll also hear some other terms like SLM, that's small language model, and FM, that's frontier model. So, what's the difference? Well,
5.2s
LLM, large language model. But you'll also hear some other terms like SLM,
13.7s
that's small language model, and FM, that's frontier model. So, what's the difference? Well,
23.3s
they're not really three separate categories. LLM, it's really the umbrella term, but we can think of SLMs as kind of the efficient specialists and we can think of frontier models as more of the cutting edge. They're all language models, but we label them differently because we use them
30.8s
think of SLMs as kind of the efficient specialists and we can think of frontier models as more of the
39.0s
cutting edge. They're all language models, but we label them differently because we use them
44.8s
differently. So, let's define what each term means and then talk about some use cases that are well suited for each model. And we're going to start with LLMs, large language models. Now, large language models are what most people think of when they hear AI. And we're talking
50.6s
are well suited for each model. And we're going to start with LLMs, large language models. Now,
56.2s
large language models are what most people think of when they hear AI. And we're talking
61.4s
about models that are pretty big. They have tens of billions of parameters. And parameters here means the weights that are learned during training that determine the model's capabilities. and more parameters generally means a bit more knowledge, a bit more nuance, a bit more reasoning. Now, LLMs,
71.1s
means the weights that are learned during training that determine the model's capabilities. and more
77.1s
parameters generally means a bit more knowledge, a bit more nuance, a bit more reasoning. Now, LLMs,
83.5s
we can really think of these as being generalists. And what I mean by that is that they have broad knowledge across many domains and they can handle sophisticated back and forth conversations. Now, there are a lot of different LLMs. Uh, many of them are kind of open source models in this kind
90.2s
knowledge across many domains and they can handle sophisticated back and forth conversations. Now,
95.9s
there are a lot of different LLMs. Uh, many of them are kind of open source models in this kind
103.3s
of parameter range and they typically run in the cloud or in SaaS environments because they need large amounts of GPU memory and processing power. So that's LLM. What about SLM? Well, small. Yeah, they have fewer parameters. So we might be talking about a model that has less than 10 billion
110.3s
large amounts of GPU memory and processing power. So that's LLM. What about SLM? Well, small. Yeah,
118.9s
they have fewer parameters. So we might be talking about a model that has less than 10 billion
127.0s
parameters. So, SLM's just kind of worse version of LLMs. Well, I think rather than worse, it's probably better to think of these guys as not so much generalists, but more as specialists. Today, well-tuned SLMs, they can often match or even beat these bigger models at focused tasks. So, document
135.9s
probably better to think of these guys as not so much generalists, but more as specialists. Today,
144.2s
well-tuned SLMs, they can often match or even beat these bigger models at focused tasks. So, document
151.0s
classification or code routing or summarization, an SLM can often do it faster and cheaper. Some examples of that, well, IBM's Granite models, including the recently released Granite 4.0, that is an SLM. And then we've got some smaller open-source options as well,
157.0s
Some examples of that, well, IBM's Granite models, including the recently released Granite 4.0,
165.2s
that is an SLM. And then we've got some smaller open-source options as well,
171.7s
like certain models that have come from Mistral. And then we've got FMs, Frontier models. Now, these are often hundreds of billions of parameters and quite a bit more. And they also have deep tool integration. But it isn't just the size and the tools because actually plenty of smaller models,
181.1s
these are often hundreds of billions of parameters and quite a bit more. And they also have deep tool
190.5s
integration. But it isn't just the size and the tools because actually plenty of smaller models,
196.0s
they can use tools now as well. What makes frontier models frontier is that they are the most capable type of model that we have today. They have the best reasoning. They're best at complex tasks. So, we can think of models uh that fall into this category as like Claude Sonnet and
203.2s
most capable type of model that we have today. They have the best reasoning. They're best at
211.0s
complex tasks. So, we can think of models uh that fall into this category as like Claude Sonnet and
218.5s
Opus would definitely fit into here. GPT5 from Open AI we could put in here and Gemini Pro from Google. These would all be considered Frontier models. Now, you might be thinking, all right, Frontier models are the most capable. Why don't I just use Frontier models for everything? I mean,
228.1s
Google. These would all be considered Frontier models. Now, you might be thinking, all right,
234.6s
Frontier models are the most capable. Why don't I just use Frontier models for everything? I mean,
239.4s
that's a fair question, but here's where the strategy comes in. The choice of AI model is use case specific. So, let's look at three use cases, and we're going to pick one that fits well with each of the types of models. And let's start with small language models. So, the use case
245.8s
use case specific. So, let's look at three use cases, and we're going to pick one that fits
251.5s
well with each of the types of models. And let's start with small language models. So, the use case
257.6s
I'm going to use here is document classification and routing. So, here's the scenario. We've got a company and it receives thousands of documents every day. So there's a whole bunch of documents coming in. There might be support tickets or insurance claims, whatever. And each one of
263.4s
a company and it receives thousands of documents every day. So there's a whole bunch of documents
271.2s
coming in. There might be support tickets or insurance claims, whatever. And each one of
275.9s
those needs to get routed to the right department and then tagged appropriately. So the documents, they come into our system. And when they get into our system, they hit what we're going to call the classification service. that is going to process these documents and the classification
282.6s
they come into our system. And when they get into our system, they hit what we're going
288.2s
to call the classification service. that is going to process these documents and the classification
297.0s
service that is running on top of a small language model. So the service reads the documents and then it does some classification. So it figures out what the category of each document is. It figures out what the metadata of each document is. And once it's done all that,
306.7s
it does some classification. So it figures out what the category of each document is.
313.5s
It figures out what the metadata of each document is. And once it's done all that,
321.0s
then these messages can be routed. So they get routed to whatever the appropriate queue is to process these messages. A pretty straightforward pipeline. And implementing the classification service is really a perfect job for a small language model. Let me give you some some reasons
329.4s
process these messages. A pretty straightforward pipeline. And implementing the classification
336.1s
service is really a perfect job for a small language model. Let me give you some some reasons
342.9s
why. One reason really comes down to to speed. So an SLM with let's say 3 billion parameters instead of a bigger model with maybe like 70 billion that has simply less computation per inference. So document classification is a pretty straightforward pattern matching exercise and you
351.9s
instead of a bigger model with maybe like 70 billion that has simply less computation per
358.1s
inference. So document classification is a pretty straightforward pattern matching exercise and you
363.8s
don't need massive scale to achieve high accuracy. Uh another good reason comes down to cost. Fewer parameters also means less computational cost per inference. You're doing fewer calculations which uses less memory which requires less GPU resources and then we've also got the advantage of
371.8s
parameters also means less computational cost per inference. You're doing fewer calculations
376.7s
which uses less memory which requires less GPU resources and then we've also got the advantage of
385.1s
governance. Now it turns out that these documents here they contain sensitive data and running an SLM on premise means that the data never leaves that environment. There's no external API calls. There's no questions about compliance. And for regulated industries like finance and healthcare, that's often non-negotiable. So that's why SLMs work for document classification. There's
392.3s
SLM on premise means that the data never leaves that environment. There's no external API calls.
397.8s
There's no questions about compliance. And for regulated industries like finance and healthcare,
403.3s
that's often non-negotiable. So that's why SLMs work for document classification. There's
408.8s
fast inference from fewer parameters. There's predictable infrastructure costs and the data stays in house. All right. Next up, large language models. We're going to go with customer support as the use case here where a customer contacts support with an issue. So maybe their billing
414.8s
stays in house. All right. Next up, large language models. We're going to go with customer support
420.7s
as the use case here where a customer contacts support with an issue. So maybe their billing
425.8s
doesn't match what they expected and it's tied to a a service configuration change and there's also a history of previous tickets about related issues just like basically some complicated stuff. So what can we do here? Well basically we will start with a query. Now the query comes in and
430.6s
also a history of previous tickets about related issues just like basically some complicated stuff.
435.7s
So what can we do here? Well basically we will start with a query. Now the query comes in and
443.0s
it's going to hit the element that we're going to build here which is our basic support system to process this query. And yes, the support system is running on top of a large language model. Now the LLM, it needs to pull information from a bunch of sources. So maybe it needs to pull
450.9s
process this query. And yes, the support system is running on top of a large language model. Now
461.3s
the LLM, it needs to pull information from a bunch of sources. So maybe it needs to pull
468.7s
information from a billing database as part of this processing. Maybe we also need some of the the technical configuration data that needs to be provided as well to the system. And perhaps we'll also include the ticket history of that particular customer who has submitted the query. And that's
476.6s
the technical configuration data that needs to be provided as well to the system. And perhaps we'll
484.2s
also include the ticket history of that particular customer who has submitted the query. And that's
492.2s
all received into the support system. So it synthesizes all of that data. And it's going to need to understand the relationships between all of these different pieces of information. And ultimately what we want it to do is to generate a solution at the end. So this is a much more
497.5s
to need to understand the relationships between all of these different pieces of information. And
502.1s
ultimately what we want it to do is to generate a solution at the end. So this is a much more
509.6s
complex pipeline than simple classification. So, why is it a good fit for LLMs? Well, a few reasons. One of the reasons really comes down just down to the breadth of this solution and what an LLM can do. Now, LLMs are likely pre-trained on broader and more diverse data sets than SLMs can
517.2s
reasons. One of the reasons really comes down just down to the breadth of this solution and what an
524.2s
LLM can do. Now, LLMs are likely pre-trained on broader and more diverse data sets than SLMs can
532.9s
store in their weights. So, that corpus might span technical docs and customer service interactions and basically all of the domains that this task touches. And during pre-training, the model learns patterns and relationships across these different areas where whereas a SLM train with a
538.2s
and basically all of the domains that this task touches. And during pre-training, the model
543.7s
learns patterns and relationships across these different areas where whereas a SLM train with a
549.6s
specific task in mind like document classification that might not have the same level of breadth in its training. And I think the other reason really comes down to generalization. And what I mean by generalization is that customer support queries have a pretty high variability. So different
555.4s
its training. And I think the other reason really comes down to generalization. And what I mean by
564.7s
generalization is that customer support queries have a pretty high variability. So different
571.6s
customers describe the same problems in just like completely different ways. There are a whole bunch of edge cases and an LLM can generalize to scenarios it hasn't explicitly seen before because of its broader training has exposed it to more patterns and more variations. So it can do levels
576.2s
bunch of edge cases and an LLM can generalize to scenarios it hasn't explicitly seen before because
584.5s
of its broader training has exposed it to more patterns and more variations. So it can do levels
590.3s
of nuanced reasoning about how concepts relate even when the specific combination is new. So that's why LLMs work for complex customer support. There's broad pre-training across multiple domains and there's the ability to generalize across scenarios with nuanced reasoning. All right. Then finally, frontier models. So the use case I'm going to go here with is autonomous incident
596.6s
that's why LLMs work for complex customer support. There's broad pre-training across multiple domains
603.0s
and there's the ability to generalize across scenarios with nuanced reasoning. All right.
608.6s
Then finally, frontier models. So the use case I'm going to go here with is autonomous incident
614.5s
response. So we've got a critical system alert that has come in at 200 a.m. in the morning. Don't they always seem to come in then? At least in these videos they do. It's never 2 p.m. on a Tuesday when you're caffeinated and ready. always 200 a.m. So, so the application servers, they're
622.2s
Don't they always seem to come in then? At least in these videos they do. It's never 2 p.m. on a
627.7s
Tuesday when you're caffeinated and ready. always 200 a.m. So, so the application servers, they're
633.1s
maybe timing out and the users can't access the servers. And that normally would wake up an on call engineer who would investigate and fix it. But what if an AI system could handle it? So, let's figure that out. We've got an alert that has come in and it has triggered our system,
637.9s
an on call engineer who would investigate and fix it. But what if an AI system could handle it? So,
645.8s
let's figure that out. We've got an alert that has come in and it has triggered our system,
652.6s
our incident response system that is now going to process and work on that alert. And the incident response system is of course running on a frontier model. Now the frontier model needs to query a bunch of things. So it might query into a monitoring system and it might need to
661.7s
incident response system is of course running on a frontier model. Now the frontier model needs
669.4s
to query a bunch of things. So it might query into a monitoring system and it might need to
678.2s
check some logs in order to be able to process what is going on across multiple services. Then it's going to need to be able to identify the root cause of what's going on. That would be important. It needs to determine the appropriate fixes that need to be applied. And then it needs to execute
685.9s
it's going to need to be able to identify the root cause of what's going on. That would be important.
694.6s
It needs to determine the appropriate fixes that need to be applied. And then it needs to execute
701.5s
that fix by calling out to a series of APIs, maybe restarting services and and rolling back a deployment, something like that. So this is multi-step investigation and execution, and that's the wheelhouse of agentic systems. Now, to to ground this in a dose of reality, most teams today aren't running fully autonomous agents yet. what they're running are frontier
710.0s
a deployment, something like that. So this is multi-step investigation and execution,
716.7s
and that's the wheelhouse of agentic systems. Now, to to ground this in a dose of reality,
722.9s
most teams today aren't running fully autonomous agents yet. what they're running are frontier
730.1s
models as more AI co-pilots with some guardrails built in and human signoff. So there is also probably a human in the loop here at least today. But the underlying capability that lives in the frontier scale model. So frontier models they have very strong agentic capabilities. They're
736.2s
probably a human in the loop here at least today. But the underlying capability that lives in the
744.9s
frontier scale model. So frontier models they have very strong agentic capabilities. They're
755.4s
trained to plan multi-step workflows and then to execute them. They can break down a complex task into steps. They can call the appropriate APIs and they can evaluate their results. Based on that, they can adjust their approach for the next step. So, agentic capabilities. There's also
760.9s
into steps. They can call the appropriate APIs and they can evaluate their results. Based on that,
765.8s
they can adjust their approach for the next step. So, agentic capabilities. There's also
770.8s
a built-in reasoning chain into this whole flow as well. So system failures like this alert, they require multi-step investigation where each step kind of builds on what you learned before. And the chain can be pretty long and complex and and frontier models, they can maintain coherent
781.3s
they require multi-step investigation where each step kind of builds on what you learned before.
785.6s
And the chain can be pretty long and complex and and frontier models, they can maintain coherent
791.7s
reasoning across these extended chains, keeping track of what they've learned, how it connects, and then what to investigate next. So look, when it all comes down to it, SLM, LLM, and FM, they are all language models and the choice comes down to matching capability to need. So you might
796.8s
and then what to investigate next. So look, when it all comes down to it, SLM, LLM, and FM,
808.0s
they are all language models and the choice comes down to matching capability to need. So you might
815.3s
use an SLM when you need speed and low cost or on-prem control. You might use an LLM when you need broad knowledge and nuance reasoning. And you might use a frontier model when you need the absolute best complex reasoning for complex problems. Essentially match the model to the task.
825.0s
need broad knowledge and nuance reasoning. And you might use a frontier model when you need
830.3s
the absolute best complex reasoning for complex problems. Essentially match the model to the task.
