Rio's Homegrown AI Exposed as Merged Model

Rio de Janeiro’s proudly announced “homegrown” municipal artificial intelligence was exposed as a merged model after independent machine learning researchers proved its underlying weights were mathematically blended from existing open-source models rather than trained independently on proprietary local data.

The controversy erupted shortly after civic officials unveiled what was framed as a pioneering indigenous Large Language Model (LLM) engineered specifically to manage public services, understand regional Portuguese dialects, and assert technological sovereignty. However, within days of its public deployment, open-source software practitioners and forensic data analysts on developer forums noticed unmistakable technical anomalies. Rather than an original foundational model born of complex localized pre-training, the release was identified as a composite created using off-the-shelf model merging tools.

This revelation has ignited critical discussions across the international technology ecosystem regarding corporate and governmental transparency, intellectual honesty in public procurement, and the accelerating prevalence of “AI washing.” For technology practitioners, public administrators, and enterprise architects—particularly in emerging tech powerhouses like India where sovereign AI deployment is actively pursued—the Rio incident provides vital lessons on the operational boundaries, compute economics, and architectural realities of modern open-source artificial intelligence.

Key takeaways

• The Reality Behind the PR: Independent code audits confirmed that Rio’s civic LLM was created by mathematically blending the weights of pre-existing open-source models rather than executing ground-up pre-training.
• Forensic Evidence: The system was identified through identical tokenizer structures, parameter weight cosine distributions, and inherited behavioral quirks unique to existing foundational parent models.
• Radical Cost Discrepancy: Foundational pre-training demands hundreds of crores of rupees in enterprise GPU compute, whereas model merging can be executed on consumer-grade hardware in under an hour for virtually zero cost.
• Legitimate Technique, Flawed Attribution: Model merging is a respected, resource-efficient open-source methodology; the ethical breach stemmed entirely from misrepresenting a merged derivative as an indigenous foundational breakthrough.

Why Was Rio’s Homegrown AI Exposed as a Merged Model?

The controversy surrounding Rio de Janeiro’s municipal LLM began when technical observers noted an irreconcilable gap between the timeline of the model’s development and the computational realities required to build a foundational system. Creating an indigenous model from scratch requires gathering hundreds of billions of tokens, architecting custom tokenization algorithms, filtering raw web and administrative data, and allocating high-density GPU clusters for months at a time.

When technical artifacts were published to public model repositories, researchers on platforms such as Hacker News and GitHub conducted immediate digital forensics. The public files did not exhibit the structural signatures of an isolated training run:

1. Unaltered Tokenizer Dictionaries: The model used an identical vocabulary table and token boundary system matching common variants of Meta’s Llama family, without optimization for local administrative vocabulary or regional Brazilian idiomatic structures.
2. Weight Correlation Matrices: When researchers computed the layer-by-layer weight differences against known checkpoints hosted on Hugging Face, the parameter delta matched standard linear combinations produced by automated merge scripts.
3. Identical Edge-Case Behaviors: The municipal model produced specific, known hallucination patterns and safety refusals verbatim from pre-existing open weights, confirming that no independent alignment or ground-up reinforcement learning from human feedback (RLHF) had occurred.

Instead of acknowledging that civic developers had built a low-cost, merged experimental pipeline, administrative statements had positioned the release as an indigenous scientific breakthrough. This misrepresentation transformed an otherwise practical engineering exercise into a public case study of AI washing.

Understanding the Machine Learning Hierarchy: Pre-Training vs Fine-Tuning vs Merging

To understand how the technical community detected the composite architecture, it is necessary to examine where model merging sits within the broader spectrum of artificial intelligence development. As explored in our architectural guide on the difference between AI, machine learning, and deep learning, modern generative models depend on complex layers of deep neural representations. How those layers are populated dictates whether a system is truly original, specialized, or simply combined.

1. Foundational Pre-Training (The Ground-Up Approach)

Pre-training represents the most resource-intensive phase of AI engineering. A foundation model begins with randomly initialized weights. The neural network processes vast corpuses—often exceeding 10 to 15 trillion tokens of text, mathematical notation, and computer code—predicting subsequent tokens across billions of parameters.

This process requires vast compute clusters. As of 2026, renting an enterprise cluster of thousands of Nvidia H100 or Blackwell-generation GPUs for pre-training runs costs tens to hundreds of crores of rupees in electricity and cloud infrastructure. Because of this astronomical capital barrier, only well-funded sovereign entities, multinational cloud providers, or elite research institutions successfully execute foundational pre-training.

2. Fine-Tuning (Task-Specific Domain Adaptation)

In fine-tuning, developers take a fully pre-trained base model and continue training its parameters on a curated, domain-specific dataset (such as municipal zoning laws, judicial rulings, or regional health records).

Fine-tuning adjusts existing weights or injects lightweight adapter layers via techniques like Low-Rank Adaptation (LoRA). While compute requirements are radically lower than pre-training—often costing between Rs. 50,000 and Rs. 10,00,000 depending on dataset depth and parameter counts—fine-tuning still requires verified domain data, specialized training scripts, gradient calculations, and loss evaluation.

3. Model Merging (Weight-Space Arithmetic)

Model merging bypasses backpropagation, gradient descent, and training data entirely. Instead of training neural networks through iterative data exposure, model merging treats the weight matrices of two or more compatible models as mathematical arrays that can be blended together.

Practitioners select models that share the exact same underlying architecture (such as two different fine-tunes of Llama-3-8B). Using linear or non-linear weight combination algorithms, developers combine the mathematical parameters of both models directly in memory.

Crucially, model merging requires zero GPU training hours. A developer running a standard desktop computer or modest cloud instance can merge two 8-billion parameter models in less than 30 minutes using open-source utilities like Mergekit.

How Does Model Merging Actually Work?

Model merging relies on the insight that neural network weights fine-tuned from the same foundational checkpoint occupy compatible basins within the loss landscape. When multiple fine-tuned variants learn different skills—such as one specializing in coding and another in conversational Portuguese—their weight differences can often be blended without destroying overall model coherence.

According to academic literature published on platforms like arXiv, several mathematical methods have become standard across the machine learning community:

Spherical Linear Interpolation (SLERP)

Traditional linear interpolation simply calculates the average between two weight vectors. However, high-dimensional neural network weights do not move along flat Euclidean planes; their relationships are geometric and spherical. SLERP calculates an interpolation path along the surface of a hypersphere, preserving the vector magnitude and angular relationships of parent weights. This prevents the combined model from suffering severe degradation in output quality.

TIES-Merging (Trimming, Electing Signs, and Merging)

When combining multiple specialized fine-tuned checkpoints, different models often attempt to shift the same parameter in opposing directions, creating destructive interference. TIES-merging resolves this through a three-step pipeline:

• Trimming: It isolates the top percentage of parameter shifts that matter most, setting minor changes back to zero to eliminate noise.
• Electing Signs: It determines the dominant directional sign (positive or negative) across all candidate models for each parameter to resolve conflicts.
• Disjoint Merging: It averages only the parameter updates that agree with the dominant direction, maintaining distinct skills from diverse parent models.

DARE (Drop And REscale)

DARE utilizes random pruning alongside mathematical scaling. It discards up to 90% of the fine-tuned delta weights from parent models at random, then scales the remaining active weights proportionally to maintain total signal strength. This allows practitioners to fuse multiple specialized models into a single architecture without bloating parameter sizes or triggering cognitive collapse.

These mathematical procedures explain why the creators of the Rio model were able to produce a functioning, Portuguese-capable model without training infrastructure. They did not invent new capabilities; they imported them mathematically from models developed by external engineering teams.

How Digital Forensics Unmasked the Rio LLM

In modern software engineering, artificial intelligence releases are not black boxes. When public sector bodies release model checkpoints to the open-source community, developers inspect the binary tensors with automated verification pipelines.

+--------------------------------------------------------------------+
|                Forensic Footprints of Merged Models                |
+--------------------------------------------------------------------+
|  1. Tokenizer Signatures: Exact dictionary overlap with parent LLMs |
|  2. Tensor Cosine Similarity: Weight deltas match known blends     |
|  3. Behavioral Quirks: Replicates parent model hallucinations      |
|  4. Missing Training Checkpoints: Zero loss curves or step logs     |
+--------------------------------------------------------------------+

1. Tokenizer Fingerprinting

An indigenous model built from scratch to serve a specific region always uses a custom tokenizer optimized for local syntax, slang, and administrative vocabulary. Tokenizers compress natural language into numerical IDs; an unoptimized tokenizer wastes context window space and degrades performance on non-English text.

When researchers examined the Rio model, the tokenizer was not trained on regional Brazilian Portuguese. Instead, it was an exact duplicate of an existing public tokenizer, displaying identical token split boundaries and byte-fallback rules.

2. Tensor Cosine Similarity and Weight Subtraction

By comparing the numerical values of the model’s tensors against known public base models, researchers performed weight subtraction:

$$\Delta W = W_{\text{Rio}} - W_{\text{Base}}$$

If a model is genuinely pre-trained, the difference vector $\Delta W$ will appear completely unrelated to other fine-tuned models on the web. In the case of the Rio release, the difference vectors matched linear combinations of publicly available Hugging Face checkpoints with statistical certainty, exposing the exact recipes used during merging.

3. Inherited Benchmark Anomalies and Hallucinations

Merged models inherit both the strengths and the flaws of their parents. When evaluated on standard edge-case prompts, the Rio model reproduced the exact idiosyncratic failure states, refusal phrases, and factual errors found in specific upstream community models. These behavioral fingerprints confirmed that the model had not undergone an independent alignment pipeline.

Sovereign AI and the Economics of Compute

The underlying driver behind the Rio controversy is the global scramble for “sovereign AI”—the principle that nations and municipalities must retain ownership over their foundational data, algorithms, and digital infrastructure rather than remaining subservient to foreign corporate providers.

Historically, organizations relied on external software providers via standard web APIs. However, concerns regarding data privacy and infrastructure lock-in have mounted. Many organizations avoid foreign APIs due to sensitive corporate disclosures and restrictive enterprise retention windows, such as the Anthropic data policy and enterprise retention requirements that dictate how prompt inputs are archived or audited. Similarly, mounting geopolitical tensions and corporate policy shifts—exemplified by recent scrutiny surrounding corporate platform crackdowns on AI models—have convinced international governments that relying entirely on third-party cloud infrastructure is an unacceptable strategic vulnerability.

However, sovereign AI cannot be achieved through public relations alone. The economics of foundational model training impose strict capital requirements:

1. Compute Infrastructure: Procuring a modest cluster of 512 high-performance AI accelerators requires capital outlays exceeding Rs. 150 Crores, alongside specialized data center facilities capable of handling massive electrical and cooling densities.
2. Data Curation Pipeline: Cleaning, deduplicating, filtering, and tokenizing public administrative records, legal codes, and cultural datasets requires dedicated engineering teams working for months.
3. Talent Retention: Machine learning scientists capable of configuring multi-node distributed training frameworks (such as Megatron-LM or DeepSpeed) command competitive global salaries.

In India, national initiatives managed by the Ministry of Electronics and Information Technology (MeitY) under the IndiaAI Mission have tackled this capital hurdle directly by subsidizing common GPU compute infrastructure for domestic startups and academic institutions. By providing shared access to thousands of graphics processors, the initiative lowers the barrier to genuine model development.

When regional governments attempt to bypass these infrastructure realities without dedicated funding, the result is frequently the shortcut witnessed in Rio: using free community weights, applying a mathematical merge, and dressing the result in the rhetoric of digital sovereignty.

The Problem with “AI Washing” in Public Procurement

Model merging is not an inherently problematic practice. In fact, within the open-source developer ecosystem, model merging represents a breakthrough in democratic, low-energy AI development. It enables researchers to combine capabilities without expending megawatts of electricity or millions of dollars in compute capital.

The problem lies exclusively in misrepresentation and AI washing.

+----------------------------------------------------------------------+
|             Ethical Engineering vs. AI Washing Practices             |
+----------------------------------------------------------------------+
|  Transparent Engineering:                                            |
|  - Acknowledges parent base models explicitly                        |
|  - Publishes merge recipes, weights, and method (SLERP/DARE)         |
|  - Accurately positions the release as an efficient composite        |
|                                                                      |
|  AI Washing:                                                         |
|  - Claims "indigenous" ground-up foundational pre-training           |
|  - Conceals upstream open-source dependencies                        |
|  - Justifies public expenditures on misleading technical claims      |
+----------------------------------------------------------------------+

When public institutions engage in AI washing, three distinct hazards emerge:

1. Misallocation of Public Funds

If municipal administrations allocate budgets running into lakhs or crores of rupees for “cutting-edge artificial intelligence research and development,” but the deliverable is a composite file assembled in an afternoon using free scripts, taxpayers have been misled. Public funds intended for digital transformation are absorbed by administrative overhead and marketing rather than real technical capacity.

2. Licensing and Intellectual Property Violations

Open-source models are governed by specific legal frameworks, including the Apache 2.0 license, the MIT license, and custom open-weight agreements (such as Meta’s Llama Community License). These licenses almost universally mandate proper attribution and the propagation of specific commercial terms and acceptable use policies. Rebranding upstream models as proprietary civic inventions creates legal liabilities for public institutions.

3. Erosion of Public Trust in Local Innovation

When an administrative body is caught exaggerating its technical achievements, the fallout damages legitimate domestic innovators. Local research groups that are genuinely investing time to curate native-language datasets, train domain-specific adapters, and build compliant software face increased cynicism from investors, oversight committees, and the public.

What Engineering Teams and Public Bodies Should Do Instead

Organizations seeking to build specialized, localized artificial intelligence without spending hundreds of crores on foundational training can pursue honest, highly effective engineering pathways.

Explicit Model Merging with Full Disclosure

There is no dishonor in releasing a merged model. If an organization combines two open models to produce a system that excels at both civic document summarization and regional language fluency, publishing that accomplishment transparently is valuable. Documenting the merge recipe, the parent weights, and the hyperparameter configurations via tools like Mergekit contributes directly to the open-source commons.

Parameter-Efficient Fine-Tuning (PEFT) on Native Datasets

Rather than attempting to claim base model ownership, engineering teams should allocate their resources toward high-quality data curation. By creating structured, verified datasets of regional policies, tax codes, and citizen service workflows, teams can train lightweight LoRA adapters on top of established base models. This achieves high-accuracy local performance at a fraction of the cost while maintaining technical integrity.

Modular Retrieval-Augmented Generation (RAG)

For administrative applications, fine-tuning or merging weights is often less reliable than Retrieval-Augmented Generation. RAG separates the reasoning engine (the foundational LLM) from the knowledge repository (the municipal database). This ensures that responses cite verifiable civic records, eliminates hallucination risks, and allows administrators to update regulations instantaneously without re-merging or re-training model weights.

FAQ

What does it mean when an AI is described as a “merged model”?

A merged model is an artificial intelligence system created by mathematically combining the parameter weights of two or more existing neural networks without running traditional training algorithms. Instead of exposing a model to text datasets via gradient descent, tools like Mergekit blend the pre-existing weight tensors using mathematical methods like SLERP or TIES.

How did researchers prove Rio’s AI was not built from scratch?

Researchers analyzed the published model files and discovered identical tokenizer configurations matching known public models, verified that the model’s weight matrices were linear combinations of existing open-source checkpoints, and identified shared edge-case hallucinations unique to specific parent models available on Hugging Face.

Is model merging considered illegal or unethical in software development?

Model merging is entirely legal and considered an innovative, resource-efficient engineering technique within the open-source community, provided that upstream licenses are respected. It becomes unethical only when organizations misrepresent the merged output as an original, ground-up foundational model to mislead the public, claim unjustified technical prestige, or misappropriate research funding.

Why don’t municipalities train their own foundation models from scratch?

Training a foundation model from scratch requires massive digital infrastructure, including specialized data pipelines and thousands of enterprise GPUs running for months. As of 2026, the financial cost of foundational pre-training routinely ranges from tens to hundreds of crores of rupees, making it economically impractical for most individual cities.

Conclusion

The exposure of Rio de Janeiro’s municipal LLM as a merged model serves as an enduring cautionary tale for the global technology sector. As governments and private enterprises navigate the high-stakes race for sovereign artificial intelligence, the temptation to substitute marketing assertions for computational reality will remain strong.

Model merging remains one of the most exciting, democratizing developments in modern machine learning, enabling cost-effective innovation on modest budgets. However, sustainable technological progress demands radical architectural honesty. Public institutions and enterprises must recognize that true innovation lies not in rebranding existing open weights behind inflated civic claims, but in transparently engineering reliable, verifiable solutions that genuinely serve their communities.

• Tags:
• Artificial Intelligence
• Large Language Models
• Model Merging
• Sovereign Ai
• Open Source Ai
• Tech Governance