albert martínez

The AI conversation is moving from “which model wins?” to “who controls how intelligence gets allocated?” Fugu is interesting, but not really because of Fugu itself. It makes visible something that has basically been my life for the last three years. We have been building around the idea that the future of AI is not going to be one model. It is going to be many models, many agents, many tools, many verifiers, many workflows, and many sources of intelligence being combined depending on what the task actually needs. For a long time, the conversation was mostly GPT vs Claude vs Gemini vs open models vs whatever comes next. I get it. When every new model feels like a leap, it is natural to ask which one is best. But once models become swappable, specialized, cheaper in some places, better in others, regulated differently, and useful for different jobs, that question becomes less important. The real question becomes allocation. Who decides which model runs? Who decides when a cheap model is enough and when an expensive one is needed? Who decides when to combine several models, when to spawn agents, when to verify, when to retry, when to escalate, and when to trust the result? That is the layer I care about. And I think there are two cases people often mix together. The first case is when you can basically trust the models to do the work. You are not asking them to settle a dispute or decide something adversarial. You are asking them to execute a task, and the problem is that you do not want model choice or model composition buried inside application code forever. That is where unhardcoded fits. For me, unhardcoded is the practical developer version of this thesis. A request should carry policy. A flow should be able to use different models for different parts of a task. The system should decide at runtime which model or combination of models makes sense, and the developer should see exactly what happened. This is the part I think matters in the Fugu conversation. Combining models is clearly powerful. Using one model for planning, another for execution, another for judging, and another for summarizing can produce better results than a single static call. I agree with that direction. But the question is whether this composition happens inside a hidden conductor, or whether it happens at runtime with explicit policy, full visibility, and a trace of the decision path. With unhardcoded, the point is not to hide the conductor. The point is to make the policy explicit, keep the provider relationship portable, and let teams see which models were considered, which were used, which were rejected, what policy selected them, what it cost, what failed, what retried, and whether the whole thing can be replayed. Otherwise the orchestration may be powerful, but it is still a black box. The second case is harder. It is when you cannot just trust one model to make the decision because the decision is subjective, adversarial, ambiguous, high value, or connected to real world facts where different parties may disagree. In that world, routing and flows are not enough. You need independent intelligence, disagreement, verification, appeals, and a way for many AI systems to reason over the same problem without everyone trusting one company, one model, or one hidden authority. That is GenLayer. For me these are two sides of the same obsession. unhardcoded is for the world where intelligence can be allocated by explicit policy at runtime. GenLayer is for the world where the decision itself needs to be made trustless because no single model should have final authority by default. This is why the orchestration conversation is so important. It is not just a new benchmark trick or a new model wrapper. It is showing that AI is becoming a supply chain. Models become supply. Tools become supply. Agents become supply. Verification becomes supply. The important layer becomes the system that decides how all of this gets used. And once that happens, control matters more, not less. Before, you were locked into a model. Now you can be locked into whoever decides how all the models are used. That is not automatically sovereignty. It can be the opposite, because the dependency becomes harder to see. We have spent the last three years working around this question because it keeps coming back in every serious AI system: who decides how intelligence is used, and what happens when that decision matters? That is where I think the AI stack is going. Not just better models. Not just agents. Not just workflows. The real shift is from using intelligence to governing intelligence. And if we do not build that layer, the next generation of AI systems may become much more powerful, but also much harder to understand, much harder to leave, and much harder to trust.