Replit CEO Amjad Masad on how general models could train smaller, domain-specific models on the fly: "There's a lot of talk of recursive self-improvement, but there's something I don't think is getting a lot of discussion, which is models training their replacements." "You can think of it as a... just-in-time compiler. As you're executing dynamic code, the interpreter realizes there's an opportunity to optimize, and it emits machine code on the fly that's a lot more optimized." "You can imagine general models, you're doing something with Operator or Astra, some of the big models, and they realize the use case is limited, or some other agent observing realizes the use case is limited." "General agents have all these flaws, but there's also more potential for them to be harmful, more potential for them to go off the rails." "So the model, on the fly, trains a model that could be its replacement, but is a lot more domain specific. Therefore it's cheaper, less vulnerable to prompt injections, and less harmful for you, because it's less capable." "It's almost like a system that's training machine learning models for specific use cases as it's monitoring the entire system." Amjad Masadshow more

@amasad is 100% correct. General intelligence works for teaching. Specialized intelligence is for executing and super intelligence is for orchestration. A football team is made up of players who play specific positions but understand the game of football.

I have an idea to basically carry around a “desk drawer” of fine tuned 14b models for specific domains on an ssd sandisk pocket sized drive which I can plug into any computer and access via hermes, lm studio etc

Literally what I am building. But I don't have gpus so I've taken a slight side track to create a chromatic neural network. Basically, a native RGBD tensor library rather than numerical codecs so I can use light instead of numeric weights for all the heavy lifting. (LEDs I can afford)

available now at :)

The JIT analogy only works if there's a deopt path. A compiled function that hits a case it wasn't built for falls back to the interpreter, so the narrow model needs a way to hand off to the general one on unfamiliar input. Otherwise it fails quietly outside its lane.

Why can’t it code a child agent that inherits a set of rules from its experiences,and so it self learns,each will be made to solve a specific issue that needs time to solve.

the model upgrade path is now writing its own changelog, generate better docs and we’ll route next quarter’s traffic to you.

if a general model trains a domain-specific replacement, who owns that trained model, who can see what it learned, and who decides whether it ships? this becomes a governance problem.

Specialisation could help with cost, but I wouldn’t use smaller capability as the security boundary. A narrow model with permission to refund a payment can still do damage. The replacement needs scoped tools, adversarial tests and a way to decline the task.

It’s like least cost routing in telecom. You would do token spend then make up some variable called htokens aka harm tokens then you minimize that

the big models are now the interns training their replacements

Models training their own replacements on the fly keeps showing up in our notes. Nobody around us has a clean eval for that loop yet.

Yeah, us...

Yes

Models training their replacements is the first time in history the intern trains the boss.

Models training their replacements sounds kinda wild honestly

Right here. I have it.

i just got replaced by a smaller model and somehow still have to attend the meeting

Cheaper specialist. I still confirm before it spends.

Funny .

Distilling task specific models on the fly saves huge inference overhead.

the JIT compiler for intelligence is a savage move

training its replacements could change how quickly AI evolves

Could also use to train self learning enabled small domain specific models on the fly, privately. Automatically fine-tuned from grounded knowledge via our integrated knowledge graph. Built so anyone could easily create and quickly use their own models.

这个即时编译的类比很顺，但 JIT 真正的麻烦在别处，是生成出来的那段代码和解释器对同一件事的理解要对齐。 放到这里就是，窄模型拿到的是训练那一刻的任务定义。任务挪一点，它自己看不出来，而且它越窄越不会说我不适用了。通用模型至少见过别的场景，有可能会停下来问一句。 我们那边有一条判据正好是这件事。一个进程拿着过时的游标来预定事件序号，现在的行为是直接报错，而不是产出一条和别人重叠的事件流。以前会默默重叠，它不报错、不丢数据，只是把两条时间线搅在一起。 所以训练替代品这件事，我觉得成败可能不在训练本身，在于替代品能不能说出我这条已经不适用了。 至于提示注入那条我只同意一半。能力更弱确实危害更小，但注入利用的是权限边界，窄模型接了哪些工具才是那条线。

The JIT compiler analogy makes so much sense.

The first generation to train their replacements: us. The second: the models.

Models training their replacements could accelerate AI development rapidly

Agency version of this: a general model is fine until you need Webflow CMS, Figma props, and B2B SaaS homepage taste in the same pass. Domain muscle still wins on marketing sites.

generating targeted lightweight models dynamically solves both the security vulnerabilities and high overhead of general agents