The short answer

Can a 1.5TB large language model run on an ordinary computer with only 25GB of RAM? Surprisingly, yes. Should an enterprise treat it as production-ready? Absolutely not.

That tension is exactly why the Colibrì project is important. Built by the Italian engineer known online as JustVugg, Colibrì demonstrates that a massive Mixture of Experts model, GLM-5.2 from Z.ai, can be executed locally by loading only the required expert components from storage at each step. The result is technically impressive and commercially premature: roughly 0.05 to 0.1 tokens per second, which means even a simple response may take hours.

But dismissing it because it is slow would be a mistake. The project is not interesting because it replaces cloud AI today. It is interesting because it challenges one of the strongest assumptions in enterprise AI planning: that frontier-level models require frontier-level GPU infrastructure.

The real signal is not speed. The real signal is architectural optionality.

What Colibrì actually proves

Most large language models are dense models. In simple terms, the entire model participates in generating each token. That is computationally expensive and memory hungry.

GLM-5.2 uses a Mixture of Experts architecture. Instead of activating everything at once, the model contains many specialized sub-models, or experts. For each token, a routing mechanism selects the experts most relevant to the task at hand. Only a fraction of the full parameter count is active during inference.

Colibrì pushes this idea to an extreme. Rather than loading the whole 1.5TB model into memory, it streams the required experts from NVMe storage into RAM when needed. The expert selection logic is implemented with minimal dependencies, and the model is quantized to reduce its footprint.

The concept is elegant:

  • Keep the full model on fast storage.
  • Load only the selected experts into limited RAM.
  • Generate the next token.
  • Release memory and repeat.

The price is latency. Storage bandwidth becomes the first bottleneck. Once that improves, RAM bandwidth becomes the next bottleneck. After that, CPU performance becomes the limit. This is not one obstacle; it is a chain of constraints.

Why enterprises should care, even if they cannot use it yet

For enterprise leaders, the immediate question is not whether Colibrì can power a customer service chatbot tomorrow. It cannot. The practical question is what happens when this type of approach improves from 0.1 tokens per second to 2, 5, or 10 tokens per second.

At that point, local frontier-class AI becomes relevant for non-interactive workloads:

  • Large-scale document classification
  • Offline legal or regulatory review
  • Internal knowledge extraction
  • Batch content generation
  • Sensitive data analysis
  • Back-office process automation
  • Local agent execution in regulated environments

Many business processes do not require a conversational experience. They require reliable throughput, privacy, cost control, and governance. If a process runs overnight and eliminates hundreds of hours of manual review, it does not need to feel instant.

This is where the economics become interesting. Cloud AI is convenient, but usage-based pricing can become expensive at scale. For organizations handling sensitive financial, legal, medical, defense, or operational data, the issue is not only cost. It is also control: where the data goes, who can access it, how prompts are logged, and whether the organization can prove compliance.

Local inference will not replace cloud models across the board. It will become another deployment pattern in the enterprise AI portfolio.

The lesson is not “run everything locally”

A common mistake in AI strategy is turning every technical milestone into a simplistic conclusion. A local 1.5TB model does not mean companies should abandon Claude, OpenAI, Microsoft Copilot, or managed AI platforms.

The correct conclusion is more nuanced: enterprises need model deployment flexibility.

Some workloads belong in managed cloud platforms. Some belong in secured private cloud environments. Some will eventually belong on local infrastructure. Some will use smaller specialized models rather than frontier models. The winning architecture will be hybrid, not ideological.

This matters because AI is not a purely technical decision. It combines computer science, domain expertise, operational design, governance, finance, and management. A model that looks impressive in a benchmark may fail inside a business process. A smaller model, properly integrated into the right workflow, may produce far greater value.

That is why deep AI knowledge and real business experience matter. The market is full of self-appointed AI experts who present every experiment as a revolution. Large enterprises can usually filter that noise. Small and mid-sized companies are more exposed to poor advice, especially when the advice ignores process design, security, implementation complexity, and change management.

Where this fits in the agent conversation

The Colibrì experiment also intersects with a bigger shift: the rise of AI agents.

Enterprises should advance on two tracks at the same time:

  • AI literacy, so employees learn how to communicate effectively with models and use AI tools responsibly.
  • Agent development, so organizations build managed systems that execute business processes with limited friction for employees.

These two tracks are not identical. AI tools often require employees to change their work habits. That can be difficult. Agents, when designed well, may require less behavioral change because they operate inside or alongside existing workflows.

The future IT department will not only manage software licenses, permissions, and integrations. It will increasingly act like an HR department for AI agents: onboarding them, assigning responsibilities, monitoring performance, managing access, retiring ineffective agents, and auditing behavior.

This is why every serious organization needs an efficient platform for creating, managing, and governing AI agents. Microsoft Copilot Studio is a reasonable option for organizations deeply invested in the Microsoft ecosystem. Tools such as n8n are also entering larger enterprise environments in ways that would have seemed unlikely only a few years ago. Claude remains one of the most compelling systems for broad enterprise work, especially with tools such as Claude Code, although security architecture must be handled carefully. Copilot is improving as well, even if Microsoft often moves more slowly than smaller AI-native companies.

The point is not vendor loyalty. The point is capability building.

Human-in-the-loop must scale, not block

Local models and agents both raise the same governance question: where does the human fit?

Human-in-the-loop is essential, especially in non-deterministic processes that involve judgment, risk, ambiguity, or customer impact. But if every AI step requires one person to approve one output, the organization has not transformed anything. It has simply added a slower interface to an old process.

The correct target is different: a person who previously executed or supervised one process should now be able to supervise hundreds of AI-assisted processes.

That requires:

  • Risk-based escalation rules
  • Confidence thresholds
  • Sampling and audit mechanisms
  • Clear ownership of agent decisions
  • Operational dashboards
  • Model and prompt version control
  • Exception handling workflows

This is where local inference may become highly valuable. If sensitive batch processes can run locally and only exceptions are escalated to humans, organizations can reduce cost, improve privacy, and scale decision support without turning people into bottlenecks.

The hardware story is just beginning

Today, Colibrì is constrained by storage speed, memory bandwidth, and CPU performance. But hardware roadmaps are moving in the right direction. Server-class CPUs with higher memory channel counts and significantly greater bandwidth could make this approach more practical. Future architectures may reduce the gap between what is theoretically possible and what is operationally useful.

That does not mean every company should wait for new hardware. It means technology leaders should start designing AI infrastructure with optionality in mind.

Questions worth asking now include:

  • Which AI workloads are latency-sensitive, and which can run asynchronously?
  • Which workloads involve data that should not leave the organization?
  • Which tasks require frontier models, and which can use smaller models?
  • Where would local inference reduce cost or regulatory exposure?
  • What monitoring and governance layer will manage models and agents across environments?

These questions belong in the boardroom as much as in the engineering meeting.

My view: this is a proof of direction, not a product

Colibrì is not an enterprise solution today. It is too slow, too experimental, and too narrow for production deployment. But it is an important proof of direction.

It shows that model architecture matters as much as raw compute. It shows that MoE models may create new deployment possibilities. It reminds us that the future of AI infrastructure will not be limited to one pattern, one vendor, or one cloud contract.

Anthropic, OpenAI, Microsoft, Z.ai, and others are all pushing the market from different angles. Anthropic in particular continues to show impressive product creativity, while OpenAI still offers strong and diverse foundation models. The competitive field is healthy. Enterprises should benefit from that competition, not lock themselves into shallow assumptions.

The serious organizations will not ask, “Which AI model is the best?” They will ask, “Which model, in which environment, governed by which process, creates measurable business value?”

That is the professional standard AI now demands.