AkiliCode-14B Research Preview: Reinforcement Learning Experiments at MsingiAI
Over the past few weeks at MsingiAI, we have been running a series of reinforcement learning experiments on compact coding-reasoning models.
Today, we are releasing the first research preview of that work: AkiliCode-14B.
This is not a frontier-model announcement. It is a transparent research preview from an active experimentation pipeline focused on:
robustness,
semantic reasoning,
repair-oriented learning,
and reinforcement learning for compact coding models.
At MsingiAI, our mission is to build AI systems that truly understand Africa while making advanced intelligence more accessible, deployable, and useful for emerging markets.
We believe the future of AI will not belong only to the largest models or the largest labs. It will also belong to teams building efficient, robust systems capable of operating in real-world environments where infrastructure and compute remain constrained.
AkiliCode is part of that broader direction.
The Core Question
A large number of coding models today optimize heavily for first-pass benchmark success.
We became interested in a different question:
Can coding models become more robust by learning directly from their own failures?
This question shaped the entire AkiliCode training pipeline.
Instead of focusing exclusively on:
next-token prediction,
supervised imitation,
or generic RL continuation,
We explored:
repair trajectories,
hidden-test robustness,
semantic correction behavior,
and targeted replay of failed generations.
One of the most important lessons from these experiments was that scaling reinforcement learning blindly is not enough.
In several cases, additional continuation RL improved shallow task completion while degrading robustness on hidden or adversarial tests.
That observation ultimately led to the strongest stage of the project.
Training Progression
Stage 1 — Supervised Fine-Tuning
The first phase established a strong coding baseline.
This stage focused on:
Python generation,
instruction following,
syntax discipline,
software engineering patterns,
and structured code completion.
The resulting model achieved:
low syntax failure rates,
stable generation behavior,
and strong baseline coding capability.
At this stage, AkiliCode was primarily a capable code generator rather than a reasoning-oriented repair model.
Stage 2 — Generic RL Continuation
The second phase introduced reinforcement learning continuation training.
Initially, this improved:
hidden-test robustness,
semantic correctness,
and reasoning-style behavior.
However, after extended continuation RL, several metrics began to plateau or regress:
HumanEval+ weakened,
MBPP+ weakened,
BigCodeBench stopped improving meaningfully.
This became one of the most important findings of the project:
More RL alone did not automatically produce better reasoning.
The model was increasingly optimizing for easier completion paths while becoming weaker on edge-case robustness.
That observation motivated a major shift in strategy.
Stage 3 — Failure-Focused Replay
The strongest gains in the project came when we changed the data distribution itself.
Instead of replaying generic RL tasks, we trained on:
failed generations,
runtime failures,
plus-test failures,
repair-oriented trajectories,
and edge-case mistakes.
The training objective shifted from:
“solve the task”
to:
“understand why the previous solution failed and repair it.”
This produced the strongest checkpoint in the project so far.
Current Research Preview Metrics
The promoted checkpoint is:
Stage 3 — checkpoint-20
Official Benchmark Results
Benchmark | Score |
|---|---|
HumanEval+ | 62.80 |
MBPP+ | 65.61 |
BigCodeBench-Instruct | 45.09 |
CRUXEval-O | 49.75 |
LiveCodeBench v6 Official | 11.37 |
These evaluations include:
official-style LiveCodeBench evaluation,
private-test execution where available,
deterministic extraction,
and full 8-GPU evaluation runs.
One of the Most Important Findings
What excites us most is not only the benchmark scores.
It is the model’s failure profile.
On official LiveCodeBench:
extraction failures dropped to zero,
Syntax-valid generations reached 98.58%.
Most remaining failures are now:
semantic reasoning failures,
algorithmic correctness failures,
and planning failures,
rather than:
parser collapse,
formatting issues,
or malformed code.
That feels like a meaningful transition for a compact 14B model.
In many ways, AkiliCode evolved from:
code completion
toward:
repair-oriented semantic reasoning.
What AkiliCode Is Good At
The current research preview performs strongest on:
structured Python generation,
repair-oriented coding behavior,
hidden-test robustness,
software engineering tasks,
and syntax-stable execution.
The model now demonstrates strong generation discipline:
100% extraction success on official LiveCodeBench,
98.58% syntax-valid generations,
and stable execution behavior across evaluation pipelines.
Current Limitations
AkiliCode still struggles significantly on:
difficult algorithmic reasoning,
deep combinatorial planning,
frontier competitive-programming tasks,
and long-horizon reasoning problems.
The current LiveCodeBench breakdown makes this especially visible:
strong improvement on easy tasks,
much weaker performance on medium and hard tasks.
This suggests the remaining bottleneck is no longer code formatting or syntax generation.
The remaining bottleneck is reasoning depth itself.
What Comes Next
The next phase of experiments at MsingiAI will likely focus on:
verifier-guided repair,
algorithmic reasoning traces,
test-time reranking,
counterexample generation,
and LiveCodeBench-specific failure replay.
The goal is not only to improve benchmark numbers.
The broader goal is to better understand how compact reasoning models:
detect mistakes,
recover from failures,
and improve semantic robustness over time.
Why This Research Matters
One of the clearest findings from these experiments is that:
targeted failure replay may improve robustness more effectively than prolonged generic RL continuation for compact coding models.
That is the central idea we are continuing to investigate.
AkiliCode-14B is still a research preview.
But the experiments so far suggest that compact, efficient reasoning systems can become significantly more robust through carefully designed repair-oriented training pipelines.
And that direction remains one of the most exciting areas of research for us at MsingiAI.