Inspiration
A finished model is a frozen mind. It can answer, but it cannot change itself for the task in front of it. If the job needs more code and less prose, or a sharper plan and a lighter voice, the usual answer is another training run, another checkpoint, another product. That is too slow to be how general intelligence actually works.
We started from a different idea. A model should be able to look at a task, edit its own weights, and bring a new version of itself into existence - a child that is better at that task than the parent. It should test the child against the parent, keep the one that wins, and only then perform the work. The parent stays intact. The experiment stays on record. The next task can begin from a stronger place.
That is Evolith. Not a bigger static model. A system in which intelligence branches.
What it does
Evolith is built toward a loop we call Evolve. Five moves, in order:
- Inspect. Read the task, the architecture, the adapter weights, and what the current model is actually good at.
- Design. Propose a weight mixture or a learning update aimed at this task, not at a generic average of every skill.
- Create. Form a child model. The child is not a copy-paste of the parent and not a new foundation trained from scratch. It is the parent plus a deliberate edit: specialist skills, combined in exact proportion, with the lineage preserved.
- Evaluate. Run the child against the parent on the same work. If the child is not better, the parent remains the one that acts. Improvement has to be shown, not assumed.
- Perform. The selected model does the task. The blend, the comparison, and the outcome stay attached to that decision.
The implications are larger than a slider. Skills stop being separate products and become material a mind can recombine. Coding, writing, humor, and thinking can exist as learned updates on one shared foundation, then be fused into a child that did not exist a second ago. An agent stops being a prompt wrapped around a fixed checkpoint. It carries a model that can branch: same objective, new weights, a measured reason for the change.
This hackathon we made that edit real and put it in a person’s hands. Four specialists — coding, humor, thinking, and writing — train once on a single pinned base, Qwen/Qwen2.5-0.5B-Instruct. The studio forges a child by composing their updates live, compares it with the base and with each specialist, and can export the child as a real adapter. The agent workspace already pins a model recipe to a reusable agent, versions its instructions, branches the agent or the model, and records the run. The autonomous loop, where the model itself chooses the child and decides it is better, is the direction we are building. The composition engine is the part that now runs.
A child is a sum of weight updates, not a vague mix of personalities:
[ \Delta W^* = \sum_i w_i \Delta W_i ]
Each (w_i) is a coefficient on a specialist the parent already knows how to be. The result is a new model, traceable to its sources, ready to be tested before it is trusted.
How we built it
The hard part of “a model edits itself” is doing it without destroying the parent and without training a new giant every time.
We fine-tune small LoRA adapters, offline, from one immutable checkpoint. Each specialist learns a delta, (\Delta W_i = (\alpha_i / r_i) B_i A_i), and the base never moves. A child is created by concatenating those factors so the merged update is exactly the weighted sum above. We do not average the matrices separately, and we do not approximate with SVD. Different ranks are allowed. The base, the revision, the modules, and the shapes must match, or the merge is rejected. Unsupported tricks — bias, DoRA, RS-LoRA — are rejected too. A bad edit should fail loudly.
The parent stays loaded. Forging a child only swaps a small adapter. Zero on every skill is the original mind, untouched. Recipes remember coefficients, source hashes, and the base revision, so a child can be rebuilt later without repeating the fine-tune. Comparisons and benchmarks put the parent, the specialists, and the child on the same prompt and the same settings. The point of the machinery is selection: you should be able to see whether the child earned the right to act.
Around that, a FastAPI service and a React studio, SQLite for recipes, runs, and agent history, Colab notebooks for the GPU training path, and a rehearsal mode so the whole interaction can be shown with no weights downloaded. Live generation never pretends. If the model fails, the run fails.
Challenges we ran into
An edit that is real. Almost-right merging invents weights the specialists never learned. Concatenation along the rank axis keeps (\Delta W^*) equal to the sum of the scaled deltas. We checked the tensors against that sum. Exactness costs rank: a child that uses every specialist is heavier than any one of them. That is an honest price for a mind that contains more than one skill.
A child that might be worse. Combining useful specialists can dull the thing each one was good at. The system is built so that outcome is visible. The parent is always in the comparison. A child that loses does not get to overwrite the story. The benchmark we ship is a first instrument — structure for code, instruction-following for prose — not a final verdict on intelligence. Humor and reasoning are not scored yet. We would rather show a narrow measurement than invent a general one.
One living model, many possible children. Warmup, adapter swaps, generation, comparisons, and benchmarks share one loaded checkpoint. They take turns. Jobs can be cancelled between generations. A restart marks unfinished work interrupted instead of completing it on paper.
Lineage you can trust. A child is only interesting if you can say what it was made from. Hashes, revisions, seeds, and versioned agent configs are how a branch stays a branch. The agent workspace can fork a model or an agent without silently changing the parent.
Accomplishments that we're proud of
We made weight-level branching something you can do in a browser. A person moves four skills, forges a child, and watches it stand next to the parent that produced it. The child can leave as a real adapter, with provenance, and run somewhere else on the same base.
We built the memory around that act. Recipes, comparisons, benchmark reports, agent versions, blueprints, and run traces all persist. An agent can be paused, branched, or saved as a blueprint another agent starts from. Two read-only tools already run inside that trace: search over notes the agent was given, and a simple text measurement. The workspace is a single-user prototype. It is also the first shape of an agent whose model is not a constant.
And we kept the parent safe. Every child is an edit applied beside the foundation, not a mutation of the only copy. That is the property the rest of the vision depends on. You cannot select a better mind if creating one destroys the original.
What we learned
General intelligence, if it arrives, will not be a single checkpoint that is finished. It will be a process that can specialize on contact with a task and refuse the specialization when the evidence says no.
We learned that the process needs a physics. LoRA gives a model a way to grow a skill without retraining the world. Exact composition gives those skills a way to become a new mind in one shot. Evaluation gives that mind permission to act. Remove any of the three and you have a demo of mixing, not a step toward a system that improves itself.
We also learned the discipline inside the idea. A child is not better because it is new. The parent remains the default. The record of the experiment matters as much as the weights.
What's next for Evolith
Close the loop. Today a person chooses the coefficients. Next, the model inspects the task and proposes the child. It designs the mixture, creates the branch, evaluates it against itself, and performs only with the version that won. Failed children stay in the lineage as evidence. Winning children become parents for the task that follows.
From there, the edits get richer than blends of adapters we trained in advance. The system should be able to train a new update for a hole it finds, test it in isolation, and fold it in only when the parent loses. Agents grow external tools, identity, and permission around that same rule: change the mind when the task demands it, and prove the change first.
The destination is a model that does not wait for the next training run to become someone more capable. It edits itself, meets the task with a child that earned the job, and keeps what the experiment taught it.
Tracks Participated In:
SpaceXSI Track: I built Evolith with a team of Grok bots, organized like a small company instead of one long chat. Seven workers reported to two managers, and those two managers reported to a single lead. I only talked to the lead. He broke the work apart, handed it down, and brought finished pieces back. The seven workers were specialists. Four lived on the frontend: the scroll-driven home page, the blending studio, the agent workspace, and the visual system that ties them together. Three lived on the backend: the LoRA merge and inference engine, the job and benchmark pipeline, and the agent API with its versions, branches, and run traces. Each worker stayed inside one surface, so a slider change never wandered into the database, and a merge fix never rewrote the homepage. The two managers ran those groups. The frontend manager kept the studio, the home page, and the agent screens on the same product: one recipe, one set of skills, one handoff from the site into the app. The backend manager kept the merger, the live model, the evidence jobs, and the workspace API on the same contract. When a child model was forged in the UI, the backend manager already knew the shape of the recipe, the hashes, and the comparison the screen had to show. The lead sat above both. I described the outcome I wanted: a child model, a comparison against the parent, an agent that can branch , and he turned that into manager-sized briefs. He decided what could proceed in parallel, what was blocked on the other side, and what was done enough to come back to me. I was not coordinating seven threads. I was steering one. That structure saved a lot of time. Frontend and backend moved at the same time. Workers went deep without dragging the whole codebase into every reply. Managers caught mismatches before they reached me: a slider that did not match the API, a trace that did not match the run, a screen that described a blend the merger could not actually build.
NMC2 Track: I built Evolith to answer the NMC track’s challenge: make AI agent setup reusable so people can focus on what their agents should accomplish. Evolith brings model configuration, instructions, tool selections, knowledge, and monitoring preferences into one workspace. Users can save an agent’s setup as a reusable blueprint, then create independent agents from it and adapt their objectives without repeating the entire configuration process. The platform also includes a registry of custom model recipes, with adjustable coding, humor, thinking, and writing influences. Users can branch model recipes and agents while preserving their parent lineage, inspect configuration history, and export setups for reuse. Monitoring views bring together run histories, tool steps, outcomes, and the configuration associated with each run. These features address enterprise needs for consistency, traceability, and controlled experimentation. For example, a team could establish a customer-support blueprint, reuse it across departments, and maintain separate configurations for each use case.
Log in or sign up for Devpost to join the conversation.