From One-Model-Fits-All to Personalized AI: How Tongyan Lingzhi Moves Personalization into Model Parameters

Large language models are becoming more capable, but a fundamental challenge remains: how can a single general model develop long-term, personalized capabilities for each individual, project, or organization? Tongyan Lingzhi (通衍灵智), a company spun out of the Beijing Institute for General Artificial Intelligence (BIGAI), addresses this by moving personalization from external mechanisms (prompt, RAG, memory) into the model parameters themselves.

Beyond External Memory: The Limits of Prompt, RAG, and Memory

Current personalization relies on prompt engineering, retrieval-augmented generation (RAG), and external memory. These approaches let the model "look up" information but not "learn" it. RAG re-retrieves relevant snippets for every query; the model's parameters never change, so closing the conversation resets everything. Three key limitations emerge:

The model cannot accumulate judgment patterns from many interactions (e.g., learning when a team prefers refactoring vs. conservative fixes).

Tacit knowledge that is never written down cannot be retrieved.

When retrieved information conflicts with the model's internal knowledge, the model hallucinates to reconcile them instead of expressing uncertainty.

As a16z's "Why We Need Continual Learning" argues, LLMs are compression algorithms; training compresses knowledge into parameters, forcing the discovery of structure and generalization. Deployment stops that compression. In-context learning is temporary; true learning requires parameter updates.

Industry Signals: Personalization Moving into Model Training

Major labs are converging on this direction. OpenAI's Dreaming extends ChatGPT personalization to long-term memory across sessions. Meta's Muse combines long-term memory, proactive execution, and user preferences in a single agent, and Zuckerberg stated that personal agent capabilities must enter model training earlier. Meta subsequently revealed Muse Spark Open, a personalized model. The signal is clear: personalization is moving from prompt, memory, and agent orchestration into the model itself.

Shared Base Model + Personal LoRA Parameters

Tongyan Lingzhi's architecture: a shared base model provides general capabilities; lightweight Personal LoRA adapters carry each user/project/enterprise's exclusive capabilities. Unlike traditional vertical models that differentiate domains (finance vs. healthcare), this approach differentiates within the same domain — e.g., Project A vs. Project B coding styles, or Investor A vs. Investor B judgment patterns. The scarce knowledge in a mature software project is not generic language/framework knowledge but years of implicit engineering rules: why an architecture was chosen, which legacy modules are fragile, when the team trades elegance for compatibility, what passes code review. Much of this lives in code changes, PR reviews, accept/reject decisions, refactoring choices, and senior engineers' intuition — not in documents.

RSI: Recursive Self-Improvement as the Core Engine

The real barrier is not "can train" but "can continuously evolve." Tongyan's core is RSI (Recursive Self-Improvement), an evaluator-driven continuous evolution loop, not a single algorithm. For coding:

Developers' real actions (accept, reject, modify, code review) naturally signal what results meet project standards.

These signals train a project-specific Evaluator that learns "what counts as a good result for this project."

The Evaluator selects effective positive/negative samples from real interactions to form training data.

Personal LoRA is incrementally updated with this data.

The new model's outputs are re-evaluated by the Evaluator; if better, it enters service; if not, rollback.

Each round's effectiveness data (which filtering strategies removed noise, which updates caused regression, which sample constructions yielded stable gains) feeds back to improve the Evaluator's judgment criteria and update strategies — AI iterating AI.

RSI learns not just "what happened" but "what counts as good for this specific user/team/project" and "how to learn better next time." This differs fundamentally from memory: memory stores history; evaluator establishes judgment; parameters carry repeatedly verified long-term patterns; the whole loop upgrades itself each round.

Engineering challenges include catastrophic forgetting, noisy feedback pollution, version management, regression, update stability, and rollback — plus stability and safety of the learning strategy itself. The company states the core technical path and product architecture are defined; modules are being engineered; the fully automated loop is the current productization focus.

TIP (Training-Inference Parallelism) and Paged LoRA: Infrastructure for Scale

RSI requires solving two infrastructure problems: continuous training cost and massive concurrent parameter serving.

TIP: Unifying Training and Inference Scheduling

Traditional infrastructure separates training and inference clusters, suitable for infrequent base model updates but not for millions of frequently updated Personal LoRAs. TIP merges them into a unified GPU scheduler with fine-grained compute units. Incremental training dynamically uses compute and memory not occupied by online serving. Serving gets priority under load; training fills gaps. The value is not a higher GPU utilization percentage but making training part of the online system, changing the cost structure of continuous learning.

Paged LoRA: Virtual Memory for Adapters

When Personal LoRAs scale from dozens to millions, VRAM becomes the bottleneck. Traditional multi-LoRA serving allocates whole adapters, causing VRAM fragmentation and latency spikes during frequent swap-in/out. Paged LoRA borrows OS virtual memory paging: adapters are split into fixed-size pages, mapped and loaded on-demand. Different Personal LoRAs no longer need contiguous VRAM blocks resident long-term.

Benchmark (Qwen2.5-72B-Instruct, 8×NVIDIA H800, equal 5.79 GB LoRA VRAM budget): at 1–30% LoRA request ratio, Paged mode P50 latency significantly beats Flat; metadata construction ~2.2× faster; P99 tail latency also better. At 50% LoRA load, synchronous page-in and frequent eviction degrade P50, guiding next steps: async page-in, hot adapter prefetch, parallel loading.

Conclusion: From Static Delivery to Living Systems

Individually, LoRA, RL, continual learning, and GPU scheduling are not new. But when RSI stitches them into a long-running Personal AI system, the problem nature shifts. RSI's requirement for continuous parameter evolution forces: parameters from "deployment assets" to "runtime state"; training and inference no longer strictly separated; memory management must dynamically serve massive parameters. Tongyan Lingzhi's stack is built layer by layer around RSI: base model for general intelligence, personal parameters for exclusive capabilities, RSI as the evolution engine, TIP as the economic foundation for long-term operation, Paged LoRA as the runtime foundation for massive concurrency. The shift from "one model for ten thousand" to "thousand faces for thousand people" is not just model count — it's turning static "train once, use six months" delivery into a living "use, learn, evolve" system. Tongyan is building the infrastructure to sustain that living system.