How Far Can a Single Vector Carry a Language? Mechanistic Limits of Inference-Time Steering for Low-Resource Devanagari Languages
This paper investigates the mechanistic limits of inference-time steering to generate low-resource Devanagari languages (Maithili, Nepali, and Bhojpuri) using Hindi representations in large multilingual models, finding that while a single vector shift can induce target language adherence, it inevitably causes fluency collapse, revealing that steerability is constrained by linear separability rather than model competence or vocabulary overlap.
Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Large language models are the engines behind many modern tools that write, translate, and converse in dozens of human tongues. These systems are trained on vast amounts of text, learning to predict the next word in a sentence by recognizing patterns in how words fit together. While they are incredibly powerful, they come with a built-in list of languages they officially support. If a language is not on that list, the model often treats it as unknown, even if it shares the same alphabet and many words with a language it does know. Researchers have long wondered if they could nudge these models to speak an unsupported language without retraining them from scratch. Instead of teaching the model new facts, they tried a different approach: finding a specific "direction" inside the model's internal math that points toward the missing language. This idea relies on the concept that the model's understanding of different languages exists as distinct shapes or paths within its digital brain, and perhaps a single push could shift its output from one path to another.
A team of researchers set out to test the limits of this idea using four languages that share the Devanagari script, a writing system used across South Asia. Hindi is a major language supported by most large models, while Maithili, Nepali, and Bhojpuri are closely related "sister" languages that are often left out of official lists despite being spoken by millions. The researchers asked a simple but deep question: if they took the model's internal understanding of Hindi and tried to push it toward one of these unsupported sisters using a single mathematical nudge, how far could they go? They did not change the model's weights or feed it new data. Instead, they analyzed the model's behavior as it processed text, identified the average "center" of how it represented Hindi, and compared it to the center for the target language. The difference between these two centers created a vector, a fixed direction in the model's internal space. During the process of generating text, they added this direction to the model's flow of information, hoping to steer the output away from Hindi and toward the target language.
The researchers discovered that the model's internal structure resembles an hourglass. At the beginning of its processing, the representations of the different languages are distinct. As the information moves deeper into the network, these paths merge into a shared, common core where the languages become indistinguishable. Near the end, just before the model produces its final words, the paths separate again. Surprisingly, the researchers found that they could successfully steer the model toward a target language only during the middle section of this journey, while the languages were still merging. Once the paths began to separate again near the output, the nudge had no effect. This was counterintuitive because one might expect that the point where the languages are most clearly different would be the easiest place to switch between them. Instead, the model was most responsive to the nudge when the languages were most blended together.
When they applied this steering technique, the results were a mix of success and failure. The model could be pushed to produce text that used the correct vocabulary and grammar markers of the target language, such as Nepali. In one specific test, the model achieved a high score for speaking the target language, reaching a level where a human judge would recognize it as mostly Nepali. However, this success came at a steep cost. As the model was pushed harder to speak the new language, it lost its ability to speak fluently. The text began to repeat itself, looping over the same words or phrases, and the sentences became broken. The researchers found that there was no setting where the model could speak the target language fluently and correctly at the same time. The nudge could change the surface identity of the language, making it look like Nepali, but it could not restore the natural flow and coherence of a fluent speaker.
To ensure this was not just a fluke or a trick of the specific model, the team compared their results against a different method called few-shot prompting, where they simply showed the model examples of the target language before asking it to write. This alternative method allowed the model to produce fluent, natural-sounding text in the target languages, proving that the model actually possessed the ability to speak them. This confirmed that the failure of the steering method was not due to a lack of knowledge in the model, but rather a limitation of using a single, straight-line push to move between complex language states. The study also revealed that the choice of the starting language mattered immensely. Using Hindi as the starting point worked far better than using English, even though English is the dominant language in the model's training. This happened because Hindi is linguistically closer to the target languages, sharing more vocabulary and structure, which made the path between them shorter and easier to navigate.
The study concludes that while a single mathematical direction can shift a model's output to mimic a new language, it cannot fully unlock the fluency of that language. The technique acts more like a probe, revealing where in the model's internal structure language identity is flexible, rather than serving as a practical tool for deployment. It showed that the model's ability to speak these languages exists, but accessing it requires more than a simple nudge; it requires the context and examples that few-shot prompting provides. The researchers also noted that the effectiveness of this method depends heavily on how closely related the starting language is to the target, with Hindi proving to be a much better bridge than English. Ultimately, the work maps the boundaries of what is possible with inference-time steering, showing that while we can nudge a model toward a new language, we cannot force it to become fluent in that language without more substantial changes or context.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.