Multi-agent pipelines
Specialist agents plan, research, code and verify together, so hard tasks are split, checked and merged instead of guessed in one pass.
Named after Abhimanyu, the warrior born from Varchas, son of Chandra the Moon. NEXAUR's sovereign 14B model plans, researches and codes locally and sends nothing to anyone.
Abhimanyu is the first public step: a sovereign reasoning model, a multi-agent pipeline around it, and a research pipeline that turns every result into the next experiment. We build it to generalize, not to memorize.
Specialist agents plan, research, code and verify together, so hard tasks are split, checked and merged instead of guessed in one pass.
Every model goes through the same loop: hypothesis, training, held-out evaluation, red-teaming and a published report.
We measure on data the model has never seen, so a high score means the skill is learned and not just the test.
It runs on your own hardware with zero telemetry. Your prompts, code and sessions stay with you.
Built on a distilled 14B architecture that fits on a single consumer GPU.
Install it on a laptop, workstation or private server. Your prompts and files never leave your hardware.
Abhimanyu patches code with precise diffs instead of regenerating whole files, so reviews stay short.
It breaks a hard question into sub-questions, reads sources in parallel and returns a cited answer.
One model is good. A pipeline of specialists that verify each other's work is better, and it is the road to general intelligence we are building.
A hard request moves through five agents. Nothing reaches you until the Verifier has checked it.
Splits the goal into small, ordered sub-tasks.
Reads sources in parallel and keeps every claim linked to its source.
Writes precise diffs instead of regenerating whole files.
Runs tests and cross-checks claims, then sends weak results back.
Merges verified results into one clear answer.
Every release follows the same five steps, and what we learn feeds the next one.
State what should improve and how we will know.
Teach the student from the 671B teacher's reasoning.
Score on sets the model never saw in training.
Try to break it and record every failure.
Share the results, the limits and how to reproduce them.
A 671B teacher writes out its reasoning. The 14.2B student learns the teacher's soft-target probabilities by minimizing KL divergence, then runs on one consumer GPU.
Try the tools inside the Abhimanyu desktop app. Everything below runs in your browser as a demo.
Five evaluations across reasoning, code, agents, response quality and generalization. Swipe through them.
Every model gets the same prompts, one attempt per prompt and fixed random seeds. Test sets are held out: they are never used for training, distillation or tuning, and we check them for overlap with training data before each run. Prompts, settings and results are listed in the evaluation report.
A model that overfits looks great on a leaderboard and fails on your real work. We design the evaluation to catch that.
Final scores come from sets that are never used to train or tune the model.
We look for overlap between test data and training data before every run.
Same prompts, same seeds, same settings, so anyone can repeat a result.
Each report says where the model trails, not only where it leads.
Run Abhimanyu on your own machine today, or talk to the team about research and partnerships.
Ask a hard question. Watch the model plan, search, cross-check and write.
Short answer: for focused refactors, a local 14B model with diff-based editing can match hosted models on patch correctness, and it removes network latency and data exposure.
Where it trails: very long multi-repository reasoning still favors larger models. Treat that as a limit, not a rounding error.
Choose your system, copy the command and run it in a terminal.
curl -fsSL https://nexaur.online/get-abhimanyu.sh | bash