Val d'Aran has about 10,000 residents, three co-official languages, and roughly 35,000 Aranese speakers worldwide when you count everyone who left. Aranese is a variety of Gascon Occitan, and it's the kind of language that shows up on the town hall's letterhead and the school curriculum but doesn't show up, in any meaningful quantity, in the training data of GPT-4, Claude, Gemini, or any other general-purpose model. Ask one of them to conjugate an Aranese verb and you'll get something confident and wrong. There just isn't enough text out there.
Maladeta Studio is based in the Val d'Aran, and over the last several months we've ended up running two separate efforts to do something about that gap. I want to write about both of them honestly, including the part that's a little uncomfortable to admit: they don't talk to each other. Not on purpose, not as some clever hedged-bets strategy — they're just two different teams inside the same small studio, working on the same underlying scarcity problem, who haven't yet had the conversation about whether to merge.
1. Two bets on the same problem
The first effort is the Aranese Corpus project, internally called ai-aranes. It's a backend and UI for collecting, curating, chunking, and exporting an Aranese-language corpus, built to eventually fine-tune Salamandra-7B — the open Catalan/Spanish-focused foundation model from the Barcelona Supercomputing Center. The stack is Python and FastAPI, Celery for the processing pipeline, Postgres with pgvector for storage and similarity search, and sentence-transformers for embeddings. Machine-translation prefill runs through DeepL, except — and this is a deliberate, documented policy — DeepL prefill is skipped entirely for Aranese-source documents, because DeepL doesn't support Aranese well enough to be worth the risk of contaminating the corpus with bad drafts. Every methodological call like that one is written down as a numbered ADR, because this work is feeding an academic paper we're submitting to LREC-COLING, and a paper needs its decisions to be defensible, not just remembered.
The second effort is Condò, which comes out of a different repo, aranes-agent-finetune. Condò is a LoRA fine-tune of Qwen3.8-27B, trained as a tool-use agent and Catalan↔Aranese translator. The name comes from Jusèp Condò Sambeat (1867–1919), the first author to write literary Aranese, whose 1915 "Vocabulari aranés" is the closest thing the language has to a foundational text. It's the first name in what we're calling "Era Votz" — a naming convention pairing each Aranese AI model with a historical figure who actually advanced the language, rather than a version number.
These two projects don't share a corpus pipeline, a model family, or an evaluation methodology. One is feeding a paper about a Catalan-Spanish foundation model; the other is a standalone agent built on a completely different base model. I don't think that's a strength I get to claim. It's an honest description of what happens when a studio this size decides a problem matters enough to attack twice before anyone's had time to ask whether it should be attacked once.
2. Teaching a model what to look up instead of what to memorize
The more interesting engineering decision is in Condò's architecture, and it's worth explaining because it's the part that generalizes. The obvious approach to teaching a small model a low-resource language is to cram vocabulary, verb tables, and grammar rules into its weights through fine-tuning. It's also close to the worst approach, because that's exactly the kind of content models hallucinate on when the language is thin — a model that's seen an Aranese verb conjugated correctly twice in training will happily invent a third, wrong, conjugation with total confidence.
So Condò doesn't try to memorize any of that. Instead, it's trained to recognize when a question needs a dictionary lookup, a verb conjugation, or a grammar rule, and to call one of six deterministic lookup CLIs for the answer — tools that live in a separate "skills" repo and just return the correct fact, every time, because they're not generating anything. The model only learns, directly through training, the things that genuinely can't be looked up in a table: fluency, natural phrasing, and sentence-level translation between Catalan and Aranese.
This is the same idea I wrote about when Lueira's WhatsApp agent started using typed tool calls instead of letting the model freely generate booking actions — don't let the model be the source of truth for anything that has an actual source of truth. It's a strange thing to see the same architectural instinct show up in a kayak-lesson booking system and a verb-conjugation lookup, but it's the same bet: models are good at language and bad at facts, so build the seam between them explicitly instead of hoping the model in front of you happens to know both.
A simplified version of what that looks like in practice:
User: Com se conjuga "anar" en preterit?
Model: [calls] conjugate(verb="anar", tense="preterit", lang="oc-aranese")
Tool: {"jo": "anè", "tu": "anères", "eth/era": "anè", ...}
Model: "Jo anè, tu anères, eth/era anè..."
The model decided which tool to call and phrased the answer. It didn't invent the conjugation table.
3. What v2 actually got right, in numbers
We've shipped two checkpoints so far: condo-27b-lora-v1 and the current condo-27b-lora-v2. v2 was retrained on a larger dataset — 30,485 examples total, with three new institutional-Aranese sources added: Conselh Generau d'Aran news posts, Parlament de Catalunya laws, and e-TAULER notice edicts. That mix matters more than it might look like — government and legal text is dense, formal, and consistently correct Aranese, which is exactly the kind of signal a small model needs when the alternative is scraping whatever informal text exists.
The training run itself: LoRA rank 16, alpha 16, on Qwen3.8-27B, on a RunPod-rented H100 80GB. Wall-clock time was 9.83 hours. Real cost was $32.33. The final eval loss was 0.05652, the best of 22 logged evaluation runs during training.
Evaluation ran on a 416-example, 50-category stratified sample. v2 scores: 97.9% tool-call correctness, 99.1% faithfulness, and 100% avoidance of over-triggering — not calling a tool when it shouldn't — measured on a 272-example subset. Compared against v1, those numbers are flat to slightly improved: v1 itself had already jumped from 82.1% to 98.1% on tool-call correctness, 91.6% to 98.8% on faithfulness, and 28.9% to 100% on avoiding over-triggering. The honest read is that the big leap happened in v1 — going from an untrained baseline to a model that reliably knows when to reach for a tool. v2's job was to consolidate that behavior on more, and more institutional, data, and it did, without regressing anywhere. That's a less dramatic story than a second big jump, but it's the right story: you don't want your second checkpoint to be exciting, you want it to be stable.
4. Where this lives today, and where it doesn't yet
Condò runs today in two places: LM Studio, using its native MLX support on Apple Silicon, and a browser-based chat UI we built with a tool-wired client rather than a bare chat prompt. That distinction matters — a bare prompt in front of this model has two specific failure modes: it hallucinates vocabulary when it can't call a tool, and it sometimes answers in the wrong language because nothing in a plain prompt firmly pins down which one it should be using. The tool-wired client fixes both directly, by giving the model somewhere to look things up and by making the target language an explicit, enforced part of the conversation rather than an inference.
That work feeds a public-facing app called enaranes, a dictionary and translator, and there are also Claude Agent Skills published for Aranese dictionary, verb-conjugation, and grammar lookups — a small repo with its own release pipeline, deliberately kept separate from the model-training work so it can ship on its own schedule.
What isn't public yet is Condò itself. The model's checkpoints live on a private HuggingFace hub, and it's explicitly internal-use-only for now. The public surface of this work today is enaranes and the Claude skills — not the base model. And the corpus project hasn't shipped a product at all; its output right now is a paper submission and a growing, curated dataset that may or may not ever feed the same model family Condò is built on.
Aranese has roughly 35,000 speakers. That's a real minority even inside Occitan, which is itself a minority language. No general-purpose AI lab is going to spend engineering time on a language that size — there's no commercial case for it at the scale labs operate at. If anything is going to exist that lets an Aranese speaker use AI in their own language, or helps a learner, or gives an institution like the Conselh Generau a tool that actually understands its own legal and administrative Aranese, it's much more likely to come from a studio that's physically embedded in the place where the language lives than from anywhere else. $32 of GPU time and 9.83 hours isn't a lot to spend to find that out.
I'd like to end this with a clean story about how the corpus project and Condò are converging into one coherent Aranese-AI strategy. They're not, not yet, and I don't think pretending otherwise would help anyone. Two teams looked at the same scarcity problem and built two different answers, and right now that's just true, and mildly inefficient, and also kind of the point — a language this small getting two independent, real attempts at AI support is already more than it would get almost anywhere else.