Models have got so powerful, the a lot of these kind of open
source libraries, the way I describe is they're kind of
liquefied. When MCP was launched, we didn't
have clawed code, we didn't have goose, we didn't have fast
agent. And you know, we would bring an
MCP server set of tools to A to a model and we would prompt it
and we'd kind of be delighted if it did one or two calls.
Yeah. But the consequence of this has
been incredibly important. Sean Smith is a software
engineer, open source advocate, and one of the most influential
contributors to the rapidly growing MCP ecosystem at Hugging
Face. He's helped to create tools used
by developers around the world to build more capable AI
systems, including the Hugging Face MCP Server and Fast Agent.
His work focuses on making advanced AI more accessible,
interoperable, and useful for the next generation of builders.
It is wild when you're here. Most folks say yeah I haven't
written a line of code in a while now.
Ideas have become more important than just writing code.
Pretty much anyone can build an LLM app in a few lines.
In a few lines of code it is. In an afternoon session.
Wow. So that's kind of incredibly,
incredibly Valve. Yeah, it's like a small door
that opens up into a mansion. It's.
Absolutely extraordinary. Yeah, if you migrate your code
to Rust and then migrate it to another language, it's a cheat
code because you get better performance.
Since it's so opinionated, you really have to make it work with
Rust. It's like New York.
If you can make it with Rust, you can make it anywhere.
When I think open source models these days, I mean, I know Gemma
Ford just came out, but Quinn models are incredible.
Yeah, you've got the Min Max models.
There's a lot of really good options that aren't necessarily
homegrown American. Yeah, I know Reflections trying
to make an open source one. So far they haven't come out
with anything, so yeah, more patiently waiting.
Yeah, and Allen AI also is another instituted.
And they're doing great stuff. Yeah, but it's, it's less
directly competitive like 4B models and large language
models, right? It's more they do a lot of what
I would consider creative. Maybe creative is not the right
word, just like different types of models.
So research. You know, I think it's an
important part of progressing the industry that people
actually try different approaches, produce research
models and share those results with the public.
And it's always the case that while a model may not be useful
for general purpose, it may be the case that it's a particular
property of a model is useful for a specific for a specific
use case, well for other researchers to build on.
Yeah, and that's the beauty of research out in the open.
Precisely. You used to get a lot more
companies sharing how they trained their models I feel like
and less and less now. I remember the Llama 3 paper
came out and that was great to see.
Even Llama 4 was really good. That is an open model still, but
you saw like Open AI was doing it a little bit.
Yeah, Open AI were very, very generous with GPTOSS.
And again, I think, you know, it is worth in this conversation
kind of drawing distinction between an open weight model
where the weights of the model and so that you can run
inference with it is what is shared and something which is
fully open source, which would be the entire training pipeline
and environments and data sets that went into the model.
So there is a distinction between those two things.
And obviously what we're talking about is open weight models and
not necessarily fully open source pipe.
Yeah, the fully open source is very hard to do right,
especially if you're worried about somebody suing you for the
data that you used. Potentially that's one aspect to
it. The other thing is the amount
of, you know, organization effort and time it would take to
also do that in a reproducible way.
But, but certainly, you know, we see a lot of a lot of very
useful open data sets. And to your point about the
research, that's also critically, critically important
because what's happening in post training in, in the kind of
things that end users would be able to do with fine tuning and,
and customisation is, you know, massively opened up by people
sharing their reinforcement learning environments and
obviously a huddle face. We have libraries like, you
know, TRL that help people customize models themselves.
So so the publishing of research and the making accessible so
that our users can can implement it and take these ideas.
And one of them is. How much have you been going
down the rabbit hole of the RL environments?
A reasonable amount I referenced.
I referenced this in my talk actually.
So I gave a talk at this in this conference and one of the kind
of opening things was that so in terms of like a rabbit hole, not
so much. But the consequence of this has
been incredibly important because if we kind of think
about when MCP was launched, we didn't have clawed code, we
didn't have goose, we didn't have fast agent.
And you know, we would bring an MCP server set of tools to a, to
a model and we would prompt it. And we kind of, I'd be delighted
if it did one or two calls another time.
The Sonic models were specifically good, being able to
chain two or three tall calls together and in with those
earlier models, when we talk often a lot about skills, I'm
sure it will come up in this conversation.
That kind of ability for the model to navigate and ingest
content and then make decisions on it wasn't actually there.
And it's RL that's really given models that capability.
So, you know, placing models into an environment and
rewarding them based on the right behaviour and training on
that means that we've now got these, you know, incredible self
propelling tool loops where we can get 8090 a hundred turn tool
loops. And that opens up, obviously,
the immense power of these coding agents.
Yeah, it's funny. I remember two years ago at
Nurips, RL was the huge thing again.
Again, I guess again, because it's not like it just fell out
of favor for a little bit and then came back and you see it
became the hot thing two years ago and now we're reaping the
benefits of it. Yeah, absolutely.
I was saying again, I think one of the the kind of other quite
amazing things is SWE bench where.
Yeah, Sweet Bench is great. Yeah, exactly.
And their reference agent, their mini SWE agent is 100 lines of
code with a single tool, a free form, not even adjacent tool and
it can get 76% which is close to state-of-the-art.
So models using a single tool are able to score that high on,
on SWE bench. And I think as as kind of
integrators as people building solutions and and platforms,
kind of understanding how the models have been trained in that
way means that we can build far more efficient solutions.
Well, talk to me a little bit about Fast Agent and what the
inspiration was behind it. So I mean the the inspiration
behind it was it's originally a fork of a project called MCP
Agent, which was a kind of an early framework.
So, and again, this has changed so much over the last 12 to 14
months that previously if you were looking to do LLM
integration, you'd be kind of looking at frameworks and
libraries and looking at the API surface and thinking, is this
something that I can kind of I can kind of work with.
So you'd be out the window now. Yeah, exactly.
Yeah. But you'd be thinking, right,
Well, how is the API surface? Is this something that is easy
to use? There's an NCP kind of
accelerated that somewhat because with MCP, rather than
building your own custom tool functions and integrating them,
you, you kind of just had a standard way of, of doing this.
So the, the kind of inspiration there was that actually, you
know, you can build on the MCP primitives and start to build
some really, really complex applications.
And in particular, you know how it's the model context protocol,
but particularly how you can load context into the model and
how powerful that is to actually get that from NCP service
because you can, you can port them between other tools and
frameworks and you can reuse them in different ways.
So, so the, the kind of goal initially was to kind of build a
almost like an inversion of control framework, but for using
models and context. And I had specific goals in
mind. So I was looking at particular
use cases around kind of enterprise consulting, so
regulatory impact assessment, organizational design impacts.
And in those kind of environments you often want to
chain large chunks of of context together, you want to integrate
external information. And so the, so the whole frame
was kind of designed for those sort of, I would call them low
volume innovative workflows. So that was kind of where it
went. And then it's become a reference
platform for MCP to fill MCP specification support including
sampling and elicitations and those things.
And yeah, a very capable CLI and agents as tools or sub agents
system which let you build some quite complex applications.
I'm not sure I've I've fully understood the becoming a
reference platform. Can you explain that?
Yeah. So with MCP, it's the protocol
itself has got quite a large surface area.
So it's split, you know, the high level we saw about things
being application controlled or model controlled and user
controlled. And then in each of those
buckets, clients and service have different features.
And of course the thing that we're kind of most familiar with
is that we have NCP servers and they supply tools and then your
LLM can call the tools. There's a lot more sophisticated
features in there. So, you know, we have resources
for for bringing content into the application.
You can list them and find those, find that content.
And a lot of MCP implementations don't necessarily support that
full feature set. So for people building MCP
servers, it can be quite difficult to have a reference
client where you can say, right, well, you know, I want to try
sampling or I want to rely on elicitation.
And so Fast Agent has been a great platform for people to
build those kind of integrations.
So it makes it very, very easy to connect to MCP servers in
development and makes it very, very easy to use some of those
advanced features and and test them out.
So it's a way for me to leverage this working well in the way
that it's supposed to work and test if it is valuable for my
use case. Exactly.
And a good, a good example of that is so as part of the NCP
repository, we have a a server called the everything server,
which is an NCP server which contains all of these features.
And you can then you can then use all of these features so.
It lets you play around with it. It's like try before you buy
type thing. Precisely, precisely so.
So that's quite important and it, it also acts as it can also
acts as an MCP server platform. So you can deploy any of these
kind of agentic workflows and tool bundles as a server itself,
which again is hugely powerful. So one example of that we have
at the moment is the Hugging face.
We've, you know, we're quite keen on being very efficient
with people's context windows. Yeah.
So, so we have a tool which has got, we have a couple of tools
which have a very, very small token surface area, but give you
a huge amount of functionality. OK tell me more.
I like this. Yeah.
So, so there's two that I think are probably worth talking
about. And again, kind of just playing
back to the previous conversation about reinforcement
learning, these kind of things have now possible because of the
slightly stronger models. Yeah, so the first of those is
what we call our dynamic space tool.
Now on Hugging Face, we've got a way for people to deploy machine
learning applications. So when you see a new image
generation model or an OCR model or a text generation model,
quite often there'll be an application that's bundled with
it which you can go to and you can use to test the application
out. And so that's a lot of fun.
And we have, you know, it's a genuinely useful environment for
people to deploy applications. We have zero GPU platforms.
So you can actually deploy these applications without it costing
you a lot of dollars, right? So.
And you're hosting it too, right?
Yeah. So we, yeah.
So we host it the zero GPU platform as you deploy, for
example, your own image generator model and you can then
use it without incurring the huge expense of renting A
renting a GPU. Now what the dynamic Spaces does
is give the user the ability through plain natural language
prompting to say things like, well, I want to create an image,
I want it to be photo realistic. And then we can select the
appropriate machine learning model and dynamically generate
calls to that model so that you can then integrate it.
And you can say I want to change the camera angle.
So we know that we have low end to adaptation models that can
change the camera angle. So it will then use that.
So you can paste an image URA in and say, well, I want to look at
that, look at that from a bird's eye view.
I want to see the camera angle from a 45° image.
So through a kind of very, very narrow tool surface.
I think ChatGPT measured it at 45 tokens.
You open up the ability to access.
Oh, that's. Behind infinite machine learning
models, infinite multimodal and textual and audio capabilities
through throughout very. So that's kind of incredibly,
incredibly. Powerful.
Yeah. It's like a small door that
opens up into a mansion. A.
Small door that opens up into a mansion and you can then chain
those things together because the output from 1 can be used
for another. So because because we restore
the content. The second example of that is
our new hub query tool. So it's it's still labeled as
experimental, but one of the great things about our users is,
is that when they have an account, they have a certain
amount of influence that they can use.
And that gives us the opportunity.
For example, with the new hub query tool, again, it's a very
small token surface, about a hundred 150 tokens.
But unless you just do free form queries to to the hub and you
can say, you can say, you know, find me trending image
generation models which have got a number in their name.
And so that call goes to the MCP server and then it gets routed
to actually a fast agent MCP server which generates some
Python code. Yeah.
So we have at the moment it's using GPTO SS120B.
So it's an incredibly fast model.
And the system prompt is loaded with our API surface or
customized API surface to make it more efficient.
And we generate some Python code in one shot, execute the code in
a secure sandbox, we use Pedantics Monti framework, and
then we return the results. And we return the results
without post processing them because the LLN that called us
can actually do that processing. So it's incredibly efficient.
And why not do any semantic search?
Or like why generate the Python code versus just doing some
hybrid search? Yeah.
So I mean, we, we have hybrid and semantic search, but what
the, what the ability to generate the code does is it's,
it allows them all to communicate effectively any kind
of natural language or change query that you want.
So for example, I can say who in the Hugging Face organization
follows me or gave me the GitHub profiles of all the people in
the Hugging Face organization that follow me and do that with
them. So it gives you this kind of
infinite joining possibility, OK.
Yeah, yeah. So you can really narrow down
that search space or you can make it very unique to what
you're looking for. Yeah, precisely.
So I can see, for example, what, you know, I can ask in natural
language terms, what models have my followers recently liked.
Yeah, which again is quite use of information and isn't
something which is easily accessible through.
Yeah. Through filtering, yeah, yeah,
if you're clicking or filtering. So it kind of gives you that,
those infinite possibilities. Have you played around?
This just makes me think of a perfect.
It's a perfect use case for MCP apps.
Absolutely, one of the reasons I'm so excited about MCP apps.
So when we look at the traffic we get to the to the Harbin, and
this will probably sort of lead us to talk more about some of
the agentic flows is we see, you know, a lot of usage from
interactive applications like our own chat UI platform or
Claude AO ChatGPT. So, you know, typically in that
mode, people are accessing it through through a chat interface
and they're working with the content interactively.
And then of course we have, you know, agentic systems like clock
code and someone which we'll we'll come back to later.
And so for users which are working with this data
interactively, often what they're doing is using the MCP
server for navigation. So they're, they're interacting
with the hub and they're saying, OK, So what models are trending?
Or I'm looking for a particular model in this particular
parameter range. And the thing that happens with
normal MCP tool calls is you, you, you send the tool call and
the, the tool returns a set of information and that information
ends up in the querying models context window.
And then it generates expensive output tokens replaying the
information that the tool just gave you.
And if the model doesn't need to do any extra processing of that
data, you've effectively just, you know, kind of burned
electricity. For no real reason.
And so NCP apps is a wonderful way to actually meet users where
they are, particularly in those rich, rich chat applications,
because we can use the models where they're great for doing
that navigation. But we don't necessarily need to
replay all of the content and generate expensive output tokens
and fill the context because the users can see can see what's
happening. And so we've done.
We were, we were very early in adopting MCPUI&MCP.
UI is the same as MCP apps or it is.
It's not no. So, so MCPUI when I first came
across about 12 months ago, so the first version of the dev
summit, it was, I think it was on my kind of final slide
because we, we just kind of learned about it.
I was like, this is this is something to be excited about.
Anita and Liad had had been toying this idea where you could
use parts of the MCP specifications.
So resources, resources in particular because it lets you
deliver arbitrary content and then supplementing that with,
with talk all information. And it was a, it was a great
pattern because it was something that you could build into your
clients relatively easily. And it was quite easy for server
authors to display content through a, you know, basically
through a frame, through a frame window.
And that got sort of reasonable adoption.
So we, we implemented it in our server a hugging face because
there were some kind of quite key applications where that
could where that would work and a few other clients did the
same. And so there was, you know,
quite, quite neat SDK, server SDK and client SDK.
Around about that time, Open AI launched a very similar
technology called Access DK, which kind of built on it.
And it was a bit more, a bit more restrictive, not
restrictive in a bad way, but it was far more opinionated in how
you should be doing these things.
Yeah. Was it just?
React components, right? I think it was, yeah.
So it's. React components and you needed
to sort of follow a particular set of patterns and it gave it
gave you some extra capabilities around, you know, being able to
interact with the with the calling application and and the
window and so on. So it was yeah, it was a
slightly different direction. And to be honest, probably for
what what they needed a a better fit because it gives you more,
it probably gives you a more cohesive user experience and
also meant that the applications that were being hosted were were
in several ways more powerful because of the the kind of two
way interaction that that that enabled.
And so fortunately those two kind of ideas were looked at
side by side and anthropic or involved as well.
And then that consolidated with MCP apps.
And so MCP apps is the official extension which kind of you kind
of blends the best of all of those, all of those technologies
with so MC. PUI morphed into MCP apps,
correct? Yeah.
Yes, there was. Another one I want to say where
it allows MCP to use different components of your website
easier. Is that web MCP?
Yeah, so. Web MCP I'm not so familiar
with, but yeah I. Haven't played around with it
enough either. Yeah, I think with.
Web MCP the the idea is more that you're able to interact
with browser elements directly so it's I think the angle there
is more that you can automate what the browser's doing rather
than kind of integrating within a chat yeah having.
It come into you and and do it through there.
OK, So that is how you added MCP apps support internally.
So yes. We, we were quite early to adopt
MCPUI because, you know, as we kind of discussed a lot of, a
lot of the models that we host are multimodal in nature.
So it gave us a way to kind of embed that in a, in a quite
clean way. So something that I'm planning
to launch actually very soon is proper MCP app which starts to
use some generative UI. So for example where we were
talking about the hub query to where you could ask arbitrary
queries, we can present the data using a generated UI which is
specific for formatting the results of that query.
Been using a toolkit called Prefab which Jeremiah Lowens
roduced. Kind of found by accident.
Yeah it was funny. It was from the Fast.
MCP, I was talking to him yesterday.
Yeah, yeah, absolutely. Yeah.
So I don't know if he mentioned brief acts.
Yeah, yeah, yeah, yeah. This is quite funny.
So, so we built this query to where we were generating the
Python And returning the results.
And I was thinking, I kind of want a really nice way to turn
that into AUI. And it was it was late on a
Sunday evening and I saw on the on my gear hub feed the Jeremiah
had kind of Donna commit that was referencing sparklines.
I was like, what? What's that?
So Edward Tuft, I don't know if you ever come across Edward
Tuft, he's. So Edward Tuft.
Wrote a series of books on how you display visual information.
They're beautiful books. He self bound and published
them. What was the name?
Edward. Edward Tuft.
So yeah, one of his. Yeah, one of.
His I think most famous books was the visual display of
quantitative information. But they they're gorgeous
artefacts. You can't, you know, don't buy,
don't buy non physical copies. Yeah, it has to.
Be a coffee table book you have? Yeah.
A proper coffee table book. Yeah.
He's also famously wrote an essay called the Cognitive Style
of PowerPoint, which kind of breaks down how the, you know,
how the challenging disaster could have happened because of
the way that, you know, people lay out information on
PowerPoint. It's some kind of hide the
important information things. So he's yeah, he's there's a lot
of fun in his. Anyway, one of the terms he
coined was sparklines, which these kind of like small graphs
that fit in, fit in the space of a word.
So if you're kind of looking at, say a sequence of win losses and
you want to show that across a set of 20 football teams, then a
sparkline would kind of fit fit in the display so that you can
see that information very quickly.
So if you kind of have an up for a win and a down for a loss, you
can see lots of very rain downs data.
So I saw this GitHub commit and I was like, that's, that's
interesting. And I kind of clicked through
and found this library and it's like, hey, what's he cooking?
So kind of. Straight away he's like, well,
you know, you probably shouldn't because it's going to break.
Because it's like, really, really.
I don't care. Yeah.
Yeah, I don't care. I'm happy, yeah, happy to be
part of the experiment. And it just came.
Out they just released it like Gai, I think, or at least yeah,
an early. Version So anyway, the the short
of it is that it's a very so far it seems to be a very, very
clean way of being able to turn kind of arbitrary content into a
beautiful user experience through MCP apps and of course
the the advantage there and all Python.
Native, which is perfect for what you were doing, yeah.
Yeah. I mean, we've got, yeah, I tend
to jump between TypeScript and Python quite a lot.
But again, MCP makes that quite easy, right.
So we can kind of route, I was going to say.
TypeScript before the whole coding revolution, because I
definitely wasn't a no, it's like, all right, everything's
TypeScript, let's do it. I've got.
A fairly long history of different programming languages.
So I I tend to I'll be honest, right?
Without LLMS I would probably struggle, but I find that LLMS
helped me with the syntax, so you can kind of just get the
ideas the ideas right. So I spent, I've spent a lot of,
so quite early micrograd used to do quite a lot of software
development. I spent quite a long time doing
things that aren't software development and I've come back
to it quite late. So see, I don't, I don't have.
I'm not necessarily too attached to any particular to any
particular language. Yeah, I have.
I have things which frustrate me about all programming.
That's for. Sure, as you should as.
Yeah, as you should. That's why.
Good. Products get made on top of that
because it's like this is really painful.
Maybe let's try and see if something's out there that can
fix it. Absolutely.
And we've, we've been spoiled I think with the quality of some
of the SDKS that have appeared over the last four or five years
that have made really, really difficult jobs really quite
easy. So yeah, I think the, you know,
the software industry's got very, very good making a lot of
complex stuff really accessible. Your NCP would be one example of
that. But also if you think about the
amount of knowledge and maths and deployment skills that are
needed to run generative large language models, the fact that
pretty much anyone can build an LLM app in a few lines in a few
lines of code of it is in an. Afternoon session.
It's absolutely. Extraordinary.
Yeah. So we're super fortunate there.
I think one of the things which has changed over the last three
to four months and the way I've kind of described it is models
have got so powerful. The a lot of these kind of open
source libraries, the way I describe is they're kind of
liquefied, right? Because the models are able to
do more of the work. Yeah, the models.
Are able to kind of generate a lot of this kind of boilerplate
code. So what it means to own and
distribute a library has become quite different because, you
know, models are able to, you know, it's changed the value of
those libraries somewhat. Yeah, right.
And and again, I think that means that we have more talking
about the distribution of ideas rather than the distribution of
code, the execution. Of it and that's really.
Yeah. And I think that's, I think
that's quite an uncomfortable jump for for a lot of people.
I think the consequences of that are still kind of sinking in.
But I think certainly over the next few months that's going to
be. Are there ones that?
You're thinking of, specifically and.
I'm thinking more generally about the.
I think a lot of people call it the Opus moment, but certainly
the twin releases of Opus 4.5 and GPT 53 codecs just gave
enough of the step change in coding abilities along with
actually simplifying harnesses. The that meant that, you know,
interacting, engaging with and building code became a slight
different experience. So certainly for my own usage,
if I think back to how I was using models to generate and
write code in May or June, it's completely different to how I to
how I use them now. It is.
Wild when you hear most folks say, yeah, I haven't written a
line of code in a while now, yeah.
Yeah, like So what are? You doing?
Yeah. And it gives, you know, we, we,
it means that developers have some very, very different
trade-offs to make. So, you know, you're always
fighting entropy. And obviously, if you're kind of
working with large language models, you're always worried
about entropy. And so trying to make sure that
your code bases maintain enough integrity and that you're
putting enough manual effort into ensuring that the quality
of the outputs is high enough is kind of traded off with pure
speed, because models will give you functionality very, very
quickly. But there's a trade off around
the quality of the design. And I think that this was the
kind of trade off that good product managers were making
over the periods of months as they were building traditional
software products or Enterprise Products.
And now that kind of trade off is is kind of in front of every
developer's desk. It's in your face and you.
Have to decide it in a session like.
Oh yeah, yeah, absolutely. And.
You know, I come from I come from a world where, you know,
we'd be making P&L business cases for whether to redesign
parts of systems or to build new features.
And as I say now that now that that kind of decision is at
every developer's desk with, you know, do I do I maybe push the
model a bit harder and accept some accept some design debt for
the for the speed or do I it's yeah, it's a very, very
different way of of building things and even.
I, I heard something really fascinating the other day where
folks were talking about migrating and migrating from one
language to the next. And apparently you get better
performance if you migrate your code to Rust and then migrate it
to another language. Or just basically migrating to
Rust will give you a little bit of a, it's a cheat code because
you get better performance since it's so opinionated and you
really have to make it work with Rust.
It's like New York. If you can make it with Rust,
you can make it anywhere. Yeah, I mean, I think.
To be honest, I think that's a great observation because I
think also you can take advantage of different language
and tools, dynamism versus strictness versus performance.
I mean, something which I was been talking about the kind of
the liquification of software is we're we're now at the point,
particularly with open source, where if you if you think, well,
I kind of want this feature, I want it in my in my own product.
Do a model will happily clone a repo for you, look at the
underlying implementation and then reimplement it in a
language that that you want. So, yeah.
So again, I think you know the the great thing is ideas have
become more important than just writing code.
It is uncomfortable, but I think that because it can't be
precious about your code. Or that what you created as
being yours. And that's the whole idea of
open source, right? It's absolutely.
Yeah. You're giving it out for anyone
to use. Yeah, but now anybody can use it
and not even it's not yours. Yeah, we.
We. Do lose things, right?
We do lose things as a as a consequence of this.
And something that something I do feel quite strongly about is
that we we must make sure that software does not become a pay
to play activity for people that can afford expensive models,
right? This is I think this is one of
the the most important things that we need to we need to get
right. Well, yeah, when we.
Saw it. We were just saying that Gemma 4
came out. We haven't played around with it
yet, but that's a great I'm looking forward to.
Exactly. Because.
I've seen the initial vibe checks and it looks really
strong. And so the thing that I often
wonder about though, is that if we're not using the expensive
models, you're still having to use a lot of your time to set up
the 'cause you're not OK. I guess maybe Gemma 4, if it's a
very small model, maybe you're setting it up in a few GPU's.
Maybe it's just one GPU. Yeah, I think.
But it can get expensive. I guess I'm going to say I'm.
Going to say something which isn't necessarily cheap, but
isn't necessarily out of the out of question either,
particularly, you know, that particularly hugging face.
If you're doing something interesting, you should let us
know because obviously we're always interested in helping and
promoting open source, open source projects, building on
this stuff. But for example, Gemma, Gemma
for new to me, I don't know the model at all, not play with it,
but we'll just use it as an example.
We say, right, Well, it's it's not as strong as GPT 54 coding.
It can't be right. And if but if you wanted to use
it for cost effective coding, are there fine tunes that you
could do of the model that worked very well for particular
languages and products? Because now you have the
weights, you have the ability to to change and optimise how the
model works. So it could, you know, it could
easily be the case that through some through some application of
specialisation and thinking, right.
Well, I want to solve, I want to be able to write Python code
cheap or I want to be able to port from TypeScript to Rust.
Rust, yeah, and get. That lift, yeah, yeah, but.
The but the for some extra effort in the setup you could
you. To be honest, when you put that
kind of effort into the setup, you can then quite easily beat
state-of-the-art because you're specialising in one particular
task. So I'm again quite optimistic
that that those kind of techniques of opening up more
and more, they're becoming more and more accessible to people.
We're keen on making them very accessible to people.
Let's talk about skills. Because I know that you're
pretty passionate and you've probably got a few cool ones.
I love chatting and hearing about folks skills that they're
getting the most bang for their buck out of because a lot of
times it's not that complex and it's just something that is a
knowledge gap. Like when you tell me here's a
cool skill, I get to go implement that and it doesn't
take me hours to set up. If anything, it takes me maybe a
20 minute session to create with Claude.
It's just that I have to know what the skill is.
Yeah. So what are your most used
skills these days? So I was saying.
My most my most used skills, or certainly some of the most fun
ones, I'm not sure that necessarily fit into the most
used was one of them. So we wrote a blog post actually
that did really, really well on using Claude to train other
models, right. So you don't have to use Claude
right. But it was, it's kind of a great
headline because people get massively engaged and then.
Did. Open.
Or on sloth, they actually did it.
Yeah, yeah, yeah, yeah. Yeah.
So, yeah, so we have a, we have a model trainer skill and
similar to that, my colleague Mervy has got some image and
vision training skills so that you can kind of fine tune and
train image models, but they make it extraordinarily
accessible to actually take a model and walk you through the
options that you have. And then at the end of it, you
end up with a model that you can run and deploy locally yourself,
or you can deploy on our zero GPU infrastructure and you know,
or classify your pets, for example, if you've, if you've
trained a vision model on your pets.
So people, people love that idea.
And one of the great things about those skills is you don't
need to be a machine language researcher, but you can, you can
download the skill and it will walk you through the options
that you have and set up the environment.
And it's amazing how quick you've got something running.
How quick you can get something? Running and yeah you may need a
little patience you may need to sort of try one or two different
things but but yes in the model training skill great fun all
those researchers that. Spent years of their lives
learning that yeah, now it is a skill yeah, but we.
We want that because the more the people experiment, the more
that they learn and the more that it kind of contributes
back. Yeah, we kind of build.
Build more and more stuff. Another, another favorite of
mine is a skill the the hugging face tool builder skill.
And what that does is so this is kind of, let's call it kind of
like a blend of code mode and shell, because what the skill
actually does is it lets you build your own arbitrary Hugging
face tools. So our open API surface.
So, so the API surface is, you know, we let people create
repositories or deploy models and all those kind of things.
It's quite large. So what what the what the tool
builder does is it helps through the shell navigate our API
surface and let you build custom tools that you can then reuse or
pipe together to do other things.
So oh. Interesting.
So you build the custom tools and then you're able to do those
things that you want to do. And it's, maybe I'm getting
confused here then would you, it's not necessarily like
working with MCP, it's you have a skill that's building a custom
tool. Exactly.
And yeah, yeah, so. Maybe so maybe.
You know, a regular thing that I would want to do would be to
find image generation models that have been uploaded over the
last 20 days, find associated papers with them and download
them in markdown. And then also put a like on the
data sets that are attached to them.
So the data sets would be some of maybe some of the training
data or, or something else. And so rather than, you know,
rather than having to spend time kind of coding your own script
to do that or very inefficiently trying to get a model to do that
repeatedly, you can, you can use the skill to kind of navigate it
and then it tests it, it puts help text in there so that
models can use that. So same repeating replicating a.
Certain a certain workflow in a way precisely so you can you.
Can build arbitrarily complicated things that use our
APIs, and it is literally arbitrarily complicated and you
end up with a tested component that is then suitable for you to
use. Yourself or for models to use
because it generates the help text so you can feed feedback in
and compose them with other with other things.
So I I have a lot of fun with that right.
So yeah, that is that. Sounds very valuable yeah.
And I, I was wondering like, OK, how does this fit with the MCP
server versus you create your own tool as a skill so with MCPI
think? That we kind of still
discovering how people best want to use our products and services
with agents and chat UIS and those.
And kind of when I kind of think about MCPI normally think about
it from three perspectives. And these perspective all have
actually quite different needs and opinions.
First is kind of from the consumer or casual perspective.
So these are these could be developers, it's not just
necessarily consumers, but these people that want to quickly
consume what we're doing so that they might, you know, they might
be using claw to AI and they they want to click Figma, they
want to click linear, they want to click hugging face and they
want to be able to interact with those services quickly and
easily. They don't want to be messing
around with auth and they want a nice interactive human focused
environment to get things done. There's enterprise, which has
often similar, similar goals to the consumer because you know,
they tend to have quite a large service area of people accessing
through chat applications. They have additional needs
around auditing and all regulatory compliance security.
Scanning all that, Yeah, yeah. And they're kind of it's.
Kind of very important to them to make sure that what people
are using and how it's being deployed.
He's safe, right? Because you don't, because you
know, if you're in an enterprise, if you're giving
people arbitrary shell access to, to, to computers that
you're, you're opening up a surface that you've, you've
probably rather not. So MCP works extremely well in
those environments because it gives you that kind of right,
that right blend of security and flexibility that this kind of
super important. And again, you know, looking at
kind of that, that easy to consume nature of say things
like MCP apps or tool results because that's great.
And then the, the third community kind of normally think
about is what is the kind of developing and development and
engineering community? And I kind of put myself in that
bucket mostly. And our needs are really, really
different and our risk profiles are quite different and our
desire to get the most out of the models as quickly as we can.
You know, if a new model is released, then people want to be
experimenting with it straight away then, you know, we, we're
much more comfortable with providing the models access to
more, more of our computers, more of our resources, let them
navigate around on file systems and so on.
And so kind of between the kind of more controlled tool surface
that we have with MCP and you know what, what you can do with
providing access to to your agents with CLIS, we kind of
trying to get that right, but also I.
Think. Because only in the conversation
we were talking about the importance of reinforcement
learning and, and, and the shell access.
When we kind of think about shell access for models, that
doesn't necessarily mean an insecure Yolo mode on your own
desktop. What's really, really nice about
tools that that take bash commands is this extraordinarily
token dense surface. And it's because the kind of
commands that you that you have with batch of things like
navigate through this hierarchy. Tell me in plain text what's
here, Tell me the content of that particular file or part of
that file. So so the fact that so the fact
that those kind of navigation commands become native to the
model is something that we can exploit through all our other
talk, right. So, so when we kind of think
about giving access to shell, I think just bashes a recent a
recent piece of software that's been released.
Oh, I haven't seen that. Yes.
So it's again. It's a minimal, it's a minimal
surface area. So, you know, it doesn't give
you access necessarily to real resources of file systems, but
it does give an interface for the model to to navigate, to
navigate a safe area with shell commands because it's incredibly
token 10's and models, models have been trained to do so.
Just bash. Just bash.
Yeah. All right, I'm going to check.
That out give me a lot of homework here.
Yeah, no, it's. Yeah, that's, that's good fun.
Yeah, OK, I need to play more with it.
Agent FS is another one which was quite a while.
It was something again I'm quite interested in because again, we
can give, we can give models access to these capabilities
without the security OK concerns.
Well, yeah, that. Wraps it up nicely in my head
and that helps me bucket it for when I would be using MCP, when
I would be using just the the tool building skill.
And it also, I was thinking about it as like when I want a
very custom type of workflow, It's probably that tool building
skill that I'm going to go with. But I also AM in your case, like
a hobbyist or a developer that can run fast and loose.
I'm not doing this in my enterprise and I don't need to
worry about all the other fun enterprise Y things.
Yeah. And the the I mean.
The really kind of the fun and exciting part for well, semi for
me at the moment is, you know, I'm kind of really enjoying
having models and agents with flat so much.
You have to do all this kind of stuff really quickly.
But the fact that we can then also provide similar experiences
in a in a safe sandboxed environment exposed through
those kind of consumer applications is extraordinary.
I mean, you know, the kind of things that the people can do
with natural language and how rich we can make the experience
of people using natural languages is superb.
Right. And we, you don't lose anything
from the lower layers by doing that.
Yeah. It just makes everything more
accessible. And the more accessible things
are, the the more valuable people can add on top of it.
Because they're not, they're not struggling with, you know,
they're not struggling with things that people should, just
shouldn't be struggling with, with computers.