By Billy P. · Founder Notes #3.
So I was talking to my buddy Dan the other day and he mentioned something that actually made me stop and think for a bit.
He said GCF kind of reminded him of Hermes, because Hermes is an AI agent that can learn and remember stuff over time.
My first reply was basically “I don’t think it’s the same.” Then I started listing out all the differences. And the more I explained it, the more I realised this is probably something I actually need to talk about, because I can see why people looking at GCF from the outside might think it’s just another AI agent.
It isn’t.
That doesn’t mean Hermes is bad either. I actually think what they’re doing is interesting. But GCF is trying to solve a different problem. Hermes is an agent. GCF is the framework around the intelligence. That is probably the easiest way I can explain it.
“I don’t think it’s the same.”
That was my first reply, and after I said it I had to actually sit down and explain why.
When people hear about AI agents, memory, tools, learning and autonomy, they normally think of the AI itself. How smart is it. What can it do. Can it remember things. Can it use tools. Can it improve. All of that matters.
ISAC will have those things too. It already has parts of that architecture and over time I want it to become much more capable.
But the thing I keep coming back to with GCF is not just how do I make the AI smarter. It is what happens when it does get smarter. Because making something more intelligent does not automatically mean it should be given more control.
That is one of the biggest things behind GCF. I want intelligence and authority to be two separate things.
An AI might know how to delete a file. That does not mean it should be allowed to. It might know how to modify a system. That does not mean it should automatically get permission to do that either. It might know how to use a tool, call another model, change memory, or interact with something outside the system. Again, that does not mean it should just be allowed.
That is where GCF comes in.
What GCF actually is
The whole idea is to put a governed layer around things like memory, tools, permissions, resources, actions, and model access.
ISAC is the first system I am building on top of that.
So when Dan compared GCF to Hermes, I realised the comparison is probably closer between Hermes and ISAC than Hermes and GCF. Because ISAC is the agent. GCF is what sits underneath and around it.
And honestly I think that difference is going to matter more and more as agents get better.
We are already moving toward AI systems that can remember things, use computers, use tools, act for longer periods of time, and make more decisions without someone constantly telling them what to do. That is useful. But it also means the architecture around them matters more.
I do not want ISAC to become more capable and then just automatically get access to everything. I want it to earn or be given access based on rules, context, and permissions. And when something should not happen, I want the system to be able to stop it before the action actually happens.
bugs are part of the plan
That is a big part of what I have been testing during the current audit. I actually found bugs during the audit too, which is kind of the whole point. I would rather find them now while I am actively trying to break the foundation than find them later after I have added even more complexity.
And before someone asks, no, I am not going to list the bugs publicly until they are fixed. The whole point of the audit is to find them, fix them, and confirm the fix actually holds. After that, some of them will probably end up in a writeup because they are useful examples of the kind of thing you only catch when you go looking on purpose.
About the models
Another part of this that I think people might misunderstand is the model side. Right now GCF is being built so it is not tied to one model or provider. That is intentional. I want it to be able to work with different models depending on what the system needs.
But long term I also want us to start making our own models. And when that happens, those models will be built to run on GCF from the start.
That is where I think things get really interesting. Because instead of taking a random model and trying to bolt governance onto it afterwards, we can build models knowing that memory, tools, permissions, and actions are already controlled by the framework around them.
I want the smaller models to be the underdogs
I know that probably sounds a bit strange. A lot of AI development is focused on bigger models, more compute, more parameters, and more hardware. And obviously bigger models can be extremely capable. I am not pretending a tiny model is magically going to beat a massive one at everything. That is not the point.
The question I am more interested in is how much more useful we can make a smaller model if the system around it is better. If a smaller model has proper memory, good routing, specialist models, tools, context, and the ability to ask for help when it needs it, maybe it does not need to do everything itself.
It could handle the easy work. It could handle the stuff it is good at. Then if it hits something harder, GCF could route that work somewhere else. Maybe that is another specialist model. Maybe it is a larger model. Maybe it needs a tool. Maybe it just needs more context.
The smaller model becomes part of a bigger system instead of trying to be the whole system.
That is what I mean by the underdog. I want smaller models to be able to punch above their weight. Not by pretending they are smarter than they are, but by giving them better support.
Why this matters
And that is also why I do not really see GCF as just another agent framework. The end goal is bigger than that.
It is about how intelligence is organised, controlled, and allowed to act.
The model matters. The agent matters. Learning matters. But the thing around them matters too. And I think that becomes even more important the more capable these systems get.
So Dan was not wrong for making the comparison. If anything, him saying it actually helped me explain the project better. Hermes can learn. ISAC will learn too. But GCF is not the thing doing the learning. GCF is the thing deciding how that intelligence fits into the wider system, what it can access, what it can do, and where the boundaries are.
That is the difference. And honestly, I think I am going to end up explaining that difference a lot more as GCF gets further along.
— Billy P.
This is the third post in Founder Notes. The first covered the formation of GCF FramWorks LTD. The second covered Stage 35 finishing and the foundation audit. This one covers a misconception I want to get ahead of: GCF is not the agent. ISAC is the agent. GCF is the layer that decides what the agent is allowed to do.
Tested on the GCF 2.0 frozen framework, SHA eeae2bc8a426b063c687e40f9724adbb1dc3a61a. Dan was right to ask the question. The answer matters.