Artificial intelligence is consolidating into the hands of a few people with very large buildings, very patient investors, and electricity bills that could make a small nation sit down for a minute.
There are obvious reasons for this.
Bigger models are proving smarter. Not magically smarter, not spiritually smarter, but more capable because they have more parameter cardinality in the fog of weights. More room for patterns. More room for weak signals. More room for concepts to fold over other concepts and become something that looks suspiciously like understanding. Probably apperception, but that is another post and I would like to keep one fire contained at a time.
The problem is that the useful version of this trick is expensive. The resources required to train and run the frontier systems are already beyond normal reach, and the demands keep climbing. Memory, graphics processors, power, cooling, networking, data, inference capacity, specialist staff, procurement patience, and the quiet ability to set money on fire while calling it research.
Then the politicians arrive, because artificial intelligence has become a topic of national importance. That changes the temperature. What was once a technical race becomes infrastructure, regulation, procurement, defence, sovereignty, lobbying, and people in suits saying "innovation" while looking as though they have just been introduced to a spreadsheet.
And the big companies, naturally, would quite like to pull the ladder up. That is not a conspiracy theory. It is a business model with stationery. If the commodity being protected is called artificial intelligence, then perhaps monopoly was always going to be its most fitting packaging.
The ladder problem is simple: the best models are becoming more useful precisely as the ability to own them is becoming less available.
The Wrong Comparison
The useful question is not: how does an individual possess the useful ability that the largest artificial intelligence companies currently control?
Some things really do have a narrow ownership path. If you want to own a Picasso, the usual options are: buy one, inherit one, steal one, or discover that the attic has been keeping secrets. The menu is short. The insurance conversation is long.
Gold is different. If you want gold, you do not have to own an industrial-scale Super Pit mine. You can pan for it, detect for it, buy a small amount, recover it from old electronics, join a small claim, or work a narrow seam that would be meaningless to a mining company but very meaningful to you.
The giant mine matters. Of course it matters. It makes common gold more available than it would be if everyone were wandering around with a pan and a heroic hat. But the price, availability, and permission structure of the giant mine's gold are controlled by the giant mine.
That is closer to where we are with artificial intelligence. The frontier labs have the Super Pits: enormous models, enormous data, enormous compute, enormous capital. Trying to copy that directly is not a strategy. It is cosplay with a cooling problem.
But intelligence is not quite like gold. Gold has to be sold or shared to become useful to someone else. Intelligence can be profitable precisely because it is not shared: it can be kept inside the company, used to compound advantage, sold back as access, and wrapped in policy that says yes today and no tomorrow.
That is the problem I am conscious of. The danger is not simply that large artificial intelligence systems exist. It is useful that they exist. The danger is that intelligence becomes a metered commodity controlled by a few super-pits.
We have to make sure there is not a monopoly on intelligence.
So the question becomes: how do you get useful intelligence locally without copying the frontier lab?
The trick is not to beat the giant at being giant. The trick is to stop playing the same game.
The Open-Source Window
There is an important piece missing if we leave the story there: the open-source large language model community.
Right now, that community is the reason any of this is possible. It is producing the models, runtimes, quantisation methods, adapter tooling, inference engines, evaluation habits, training recipes, and operating knowledge that let ordinary people run serious systems on local hardware. Without that work, "own your intelligence" would be a nice slogan printed on a very expensive invoice.
So this is not an argument against open-source models. It is almost the opposite. Open source is giving us the tools we need at exactly the moment we need them.
But the window may be temporary.
As open models become more capable, they will run into the same gravity as the frontier systems: regulation, licensing pressure, distribution friction, hardware constraints, compliance demands, platform policy, and the general nervousness that appears whenever a technology becomes genuinely useful. The more ability these models have, the more people will try to put gates around them.
The open-source moment is precious because it is giving individuals the raw material for local intelligence before the rules around that material harden.
That is why the next step matters. It is not enough to celebrate that good local models exist today. We need to build the systems that let them accumulate private, local, durable intelligence before access to the base capability becomes more constrained.
The Nuance Problem
A lot of work is consistent and repeatable. Artificial intelligence infrastructure, ordinary software deployment, configuration, monitoring, documentation, build systems, data movement, incident response, all of it has a thick layer of recognisable pattern. A good model trained on public documentation can be genuinely useful there.
Until it hits your system.
Your system is never quite the public version. It has the old migration nobody wants to mention. The naming convention from three teams ago. The one environment variable whose name is lying. The deployment step that exists because a vendor once had a very bad Thursday. The local rule. The awkward exception. The thing everyone in the room knows and no documentation quite says because apparently we enjoy archaeology.
That nuance matters. If you are a data engineer, it can be 95 percent of the work. The other 5 percent is writing the SQL everyone assumes was the hard bit.
Large models are excellent at the public mean: the vanilla version, the documented path, the average way the world says a thing should work.
But your useful work usually lives in the deviation from that mean.
So we stuff the nuance into context. We paste notes. We attach files. We write long instructions. We add project summaries, policies, diagrams, conventions, caveats, examples, and tiny pleas like "please do not delete the migration directory; it is load-bearing."
This works, but only in the way carrying your entire kitchen into a restaurant works. Possible, perhaps. Not elegant. The waiter will remember you.
The Context Trap
Context looks like the escape hatch because it lets a general model borrow local detail at runtime. But context is still a resource. It has size, cost, precision, retrieval quality, attention pressure, and failure modes.
As the context grows, it starts to resemble the original model problem in miniature. You need somewhere to store it, a way to select it, enough memory to hold it, enough attention to use it, enough precision to preserve it, and enough money to keep doing that every time.
A larger context window helps, but it does not abolish the problem. It just gives the suitcase more zips. The real issue is that the nuance is still luggage, not memory.
If the model has to be reminded of the same local truth every time, then the user is renting competence by the token. Again. Different invoice, same architecture.
The Nibbler Move
Nibbler starts from a different assumption: maybe the base model only needs to be good enough.
Good enough to read, reason, generalise, use tools, follow contracts, and understand ordinary technical material. Small enough to run on modest local hardware. Available enough that the operator can own the runtime instead of asking permission from a remote service every time the machine has a thought.
Then teach it the nuance.
Not by dumping a giant private archive into one heroic fine-tuning run and hoping the resulting model is "better" in some smooth, spreadsheet-friendly way. That is the old instinct again: bulk scale, now wearing a homemade jumper.
Nibbler is deliberately smaller and more fussy than that. It teaches by nibbles.
The simple version is this:
That last line is the important difference. The source material does not merely sit in the prompt like a sticky note with commitment issues. It becomes a controlled behavioural change, but only after the system can show what changed and why it was accepted.
This is the heart of it. The local model does not merely receive another note in a prompt. It receives a controlled change to its behaviour. A tiny, inspected, recoverable change. Then another. Then another. The system accumulates local competence as a first-class artifact rather than as a very long preamble.
Atoms, Not Sludge
The first architectural choice is atomization. Nibbler does not treat source material as a mystical soup of wisdom. It slices approved material into small learning units with provenance.
The distinction matters. A model cannot audit sludge. A person cannot sensibly review sludge. A learning system cannot recover cleanly from half-learned sludge, unless we are all prepared to use the phrase "sludge rollback" in a meeting, which I am not.
Atoms make learning accountable. This claim came from this source span. This is the target answer. These are the probes. This is the ledger state. This was accepted, rejected, revised, or tombstoned. The model may be probabilistic, but the operation around it does not have to behave like soup.
Nibbler is strict about what may become training material. Approved source truth controls learning, not whatever the model happens to invent with a confident face.
Learning As A Transaction
The second architectural choice is that learning is a transaction, not a vibe.
For each atom, Nibbler can score the model before training, train a bounded low-rank candidate, score it after training, and accept only if the target improves or is already stable while protected behaviour stays within limits.
That is not a casual prompt memory. It is more like accounting. Slightly less glamorous, much more useful. The important bit is not that every atom is guaranteed to learn. It is that every attempt leaves evidence, and failure does not silently become personality.
Why Low-Rank Matters
Nibbler's selected learning architecture is additive Low-Rank Adaptation. The reason is not fashion. It is composability.
Each accepted atom should remain independently auditable, mergeable, reversible, and usable in an aggregate adapter. Plain additive low-rank updates give the system a way to accumulate local knowledge without pretending the base model has to be rewritten from scratch every afternoon.
The base generation stays immutable. Accepted deltas become the durable knowledge record. A served model pointer moves only after validation and promotion evidence exists. In plain English: the system learns, but it does not smear learning over the furniture and call the mess intelligence.
The Local Operator
This changes the role of the person using the model.
In the incumbent world, the individual is mostly a tenant. You rent access to a general intelligence endpoint. You feed it private context. You hope the remote system remembers enough for this turn and forgets enough for privacy. You accept whatever product boundary, pricing boundary, policy boundary, and availability boundary the provider gives you.
In the Nibbler world, the individual becomes an operator. You approve source material. You control what may become durable. You observe what changed. You can recover, roll back, inspect, promote, and keep the whole loop local.
This is not merely a privacy story, though privacy is a very good reason to care. It is an ownership story. It is the difference between a machine that helps because a company allows it today, and a machine that improves because you are deliberately teaching it what your world is like.
The Company Memory Problem
This matters inside companies as much as it matters for individuals.
Suppose someone has been using a company Nibbler for two years. Not just chatting with it, but teaching it the shape of the place: the runbooks, the deployment scars, the strange customer exceptions, the real data lineage, the undocumented policy edges, the hard-won taste for what is normal and what is quietly on fire.
In most companies, that knowledge is partly in documents, partly in tickets, partly in meetings, and partly in one person's head while they are trying to eat lunch. When that person leaves, the company keeps the documents and loses a frightening amount of the actual working intelligence.
A company Nibbler changes that. If the source material is approved and the learning loop is explicit, the company's nuance can stay with the company. The intellectual property does not have to walk out the door disguised as "tribal knowledge," which is a charming phrase for "the system is depending on Derek remembering why the production table is named final_final_2."
And it should go both ways. The employee also develops intelligence while doing the work. They build judgement, taste, debugging habits, architecture instincts, and working methods. A fairer separation is not one side pretending all knowledge belongs to the company, or the other side quietly carrying everything away in memory. The fairer version is explicit: this source belongs to the company, this learned practice belongs to the person, and both sides leave with something real.
That has significant value. It makes the company less fragile, because knowledge is retained. It makes the employee less disposable, because their accumulated intelligence is visible and portable. It makes the boundary more honest, which is not a small thing in a world where everyone says "knowledge work" and then stores the knowledge in a private Slack thread from 2023.
Why This Can Scale
There is another reason this matters now: the models that are good enough to do most ordinary work are getting smaller and more efficient.
The largest proprietary systems are still improving, and they are still extraordinary. But a lot of their improvement is moving into a shrinking band of work that needs genuinely frontier capability: deep research, very broad synthesis, exotic reasoning, large multimodal tasks, and the kinds of jobs where being average over the whole internet is actually useful.
Most company work is not that. Most company work is repeatable, contextual, policy-bound, historically awkward, and full of local nouns. It does not always need the biggest model in the world. It needs a good enough model that knows the local reality.
As capable local models get smaller, the value shifts from who owns the largest general model to who owns the best local adaptation loop.
That does not mean large proprietary models stop mattering. It means they need not do everything, and probably should not. Use the frontier model when the work genuinely benefits from frontier scale. Use the resident model when the work benefits from accumulated local fit. The important part is that the organisation is no longer dependent on one remote provider for every act of intelligence.
Nibbler is designed for that mixed world. You can have both: external general intelligence when it is worth paying for, and internal resident intelligence that captures company knowledge, supports employees, reduces provider dependency, and levels the field around who gets to own intelligence.
The Disruption
The incumbent advantage is scale. More parameters, more data, more hardware, more distribution, more capital, more gravity. That advantage is real. It should not be waved away with a sticker that says "local first" and a brave little laptop fan.
But the incumbent weakness is also scale. A frontier model has to be useful to everyone. It has to carry the public world, the average workflow, the generic answer, the broadly safe behaviour, the median documentation path, the acceptable response across jurisdictions, customers, languages, and product tiers.
Your best assistant does not need to be average across the planet. It needs to be unusually good at your work.
Nibbler disrupts the ladder by changing the scarce thing from raw intelligence to accumulated local fit.
The new dichotomy is not simply big model versus small model. That is the wrong axis.
A rented general intelligence will usually know more about the world. An owned resident intelligence can know more about your world, and it can improve without asking the centre for permission.
Why It Matters
If artificial intelligence becomes only a remote utility, then intelligence becomes another meter. Turn the tap. Pay the bill. Accept the terms. Hope the landlord likes your use case.
If local resident learning works, the shape changes. Individuals, small teams, laboratories, workshops, studios, and companies without frontier budgets can accumulate private competence over time. Not as a pile of notes, not as a search index taped to a chatbot, but as durable model behaviour under local control.
That is the philosophical reason behind Nibbler.
It is an answer to consolidation that does not require matching the consolidators. It says: keep the general model good enough, keep the learning loop local, keep the source truth approved, keep every change recoverable, and let the machine become specific.
Why Nibbler?
The name is a nod to Nibbler from Futurama. Small, likeable, apparently ridiculous, and then, inconveniently for everyone who underestimated him, one of the cleverest beings in the room. He also saves the galaxy on several occasions, which is a useful reminder that scale is not always the same thing as importance.
There is also the pleasingly literal overlap. Nibbler consumes things much larger than itself. Quietly. Continuously. With alarming efficiency. That is not a bad metaphor for a small local model digesting source material into durable resident intelligence. It does not need to be the biggest thing in the room. It needs to keep eating the right things.