a rail for guiding the learning experience.
First a companion. Then a place for it to live.
ARAIL began with Buddy — a local agent to learn alongside. Buddy needed an environment. That environment became a lab: pluggable, observable, and entirely owned by you.
It is not an app you log into. It is a blueprint you assemble — a runtime, a streaming inference engine, a router, and a swarm of agents — and at its center, a knowledge base that everything writes to and learns from. Nothing leaves your hardware.
This is the whole engine. You set one measurable goal. The goal implies a theme, and the theme spins up a World — a curated, fully-sourced knowledge environment you walk into: a dictionary, a docent, and an open API. Then two engines start turning at once.
One engine runs experiments to improve the thing you chose to measure. The other builds the knowledge base the experiments stand on. They feed each other — findings get curated into the World, and the richer World gives the next experiment better footing. When the base is good enough, Nucleus bakes it into a model you own; the base log-compacts, and the loop resets for your next goal.
Pick something you can measure. The loop does the rest.
Most tools forget the moment you close them. ARAIL keeps one growing knowledge base — and points it two ways at once. Your agents draw on it to act with real context. You draw on the very same base to learn faster. One memory, compounding for both of you.
Autoresearch agents curate and structure what matters into your base.
Frontier teachers, served locally, grounded in what you actually know.
Your base becomes a model that knows — not one that looks things up.
Specialist agents put that shared context to work on real tasks.
Context you own. Intelligence that compounds. That is wisdom per watt.
Each component clicks onto the same rail — and everything feeds the knowledge base. Swap any one without rebuilding the rest.
A local agent that learns with you and drives the lab in plain language.
The center of gravity — every part reads from it and writes back to it, so context compounds.
Streams 70B–500B+ teacher models layer by layer off your disk — frontier reasoning with no GPU farm to rent.
Fans one prompt across a tier of models — fast local drafts up to frontier teachers — so you can pull answers from several at once. Deterministic, observable, written in Rust.
Specialist agents interrogate, challenge, and refine — happily waiting on deep, disk-hosted models for the most careful answer.
Scores every answer and evolves the rubrics the swarm consults — what gets measured gets better, and it all flows back into your knowledge base.
If you can measure it, we can improve it.
AutoResearch scores every answer against rubrics that evolve themselves. What gets measured gets better — automatically, in the background, while you do something else entirely.
So the swarm reaches for the deepest models there are and runs them cheaply off your disk, layer by layer, instead of renting a rack of GPUs. Because it works in the background, it doesn't mind waiting minutes for a slow, careful chain of thought. It trades speed for depth — reasoning quality no model small enough to be fast can match.
parameter frontier models — up to 671B at 4-bit — running locally, streamed from your SSD. No cluster. No cloud.
Who else is getting local inference from a 500-billion-parameter model?
QuKaiZen is obsessed with performance — and a gain is a gain, large or small. Frontier-scale reasoning shouldn't need a datacenter, and you shouldn't pay twice for the same context. So we hunt the wins everywhere they hide and stack them. That is why AeroLLM exists, and why we sweat the details like prefetch and preprocess threads, caching, shared-memory segments, and zero-copy pointer hand-offs.
Run 70B–500B+ teacher models layer by layer off your SSD — frontier reasoning with no GPU farm to rent. It is mostly a disk-and-RAM problem, not a cluster.
Stable prompt prefixes bill as cache_read — a fraction of fresh input. Reuse the context, not the cost. How caching works →
A small fast model proposes tokens; the big model checks them in one pass. More tokens out per step, same answer.
The Rust router fans one prompt across a tier — fast local drafts up to frontier teachers — so you buy expensive reasoning only when it earns its keep.
4-bit weights keep huge models on commodity hardware — up to 671B locally — without throwing away the reasoning that makes them worth running.
No network round-trip, no metered API, no queue. Inference next to your data is lower latency by default — and private as a side effect.
Frontier-scale reasoning. Wisdom per watt.
Clone the blueprint, pick your mode, and begin your journey into artificial intelligence.