IQuest-Q1: Advancing Foundation Capabilities for Agentic CLI Systems

IQuest-Q1. Advancing Foundation Capabilities for Agentic CLI Systems. By A. Jian Yang and one hundred and seventy-six others, from IQuest Research. Published on the twenty-second of October. No code repository is linked to it.

IQuest-Q1 is an agentic foundation model, released as open source. It is aimed at agentic coding, the kind of work a command-line system does.

It is a sparse Mixture-of-Experts model. It has three hundred and twenty billion parameters in total. Of those, fifteen billion are activated at a time. According to the authors, the resulting model shows capabilities in both coding and general tasks.

It was built in three stages. The first is stable and efficient pre-training. It combines Stable SplitNorm, Muon, and muP with a two-stage curriculum, whose second stage increases the share of coding data in the mixture. The stated goal is to preserve a wide stability margin between the safe learning rate and the optimal one.

The second stage is fine-grained mid-training. It expands the data mixture across domains and formats, and progressively extends the context. The third is post-training across multiple scaffolds and multiple versions. It combines SFT, domain-specialized RL, and MOPD across various scaffolds, to integrate complementary training signals and strengthen agentic coding. Finally, model merging combines different experts, and checkpoints from different stages, while mitigating conflicts among their parameter updates.

The model is released to support community research and development, for anyone working on foundation models for agentic coding and command-line agents.

The abstract reports no benchmark figures. What it offers instead is the recipe: a stability-minded pre-training curriculum that leans into code, a mid-training stage that widens data and context, and a post-training stage that blends several training signals and then merges the results into one open model.

IQuest-Q1. Advancing Foundation Capabilities for Agentic CLI Systems. By A. Jian Yang and one hundred and seventy-six others, from IQuest Research. Published on the twenty-second of October. This is the long version: the whole paper rather than the abstract.

The command line has become one of the most general ways a language model can act on the world. Through a terminal it can use tools, open files and run code. The paper's premise follows directly: a more capable agent needs stronger command-line skills, and those skills have to hold up whichever agent harness wraps the model. A model tuned inside one scaffold can stumble in another. IQuest-Q1 is an open-weight answer to that problem: a sparse mixture-of-experts model with three hundred and twenty billion parameters in total, of which fifteen billion are active for any given token.

Two ideas carry the rest. The first is that this is a report on a whole training pipeline, not on one trick. Pre-training, mid-training, supervised fine-tuning, reinforcement learning, distillation from several expert models, and finally merging of checkpoints. Each stage is aimed at the same destination: an agent that works in a terminal. The second idea is about scale. Every architecture and optimizer recipe has a learning rate that trains most efficiently, and a larger one beyond which training collapses. If the efficient rate is comfortably below the collapse point, there is headroom. If the two meet, the model is as large as that recipe can safely go.

Start with the architecture. Attention layers mostly look at a sliding window of four thousand and ninety-six tokens, with a full-attention layer after every three windowed ones. The more distinctive choice is a normalization scheme the paper calls Stable SplitNorm. The stream entering attention is normalized; the stream entering the feed-forward block is left unnormalized. The aim is the stability of the usual arrangement together with better use of the deeper layers. Done naively that became unstable at scale, so the attention output is normalized as well. Learning rates are tuned on a small proxy model with eighteen layers and transferred to the full model with no further search. Against a baseline modelled on Qwen3 and trained on identical data, the design reached the same training loss with about fifty-two percent of the compute. Extrapolating the learning-rate trends puts the Critical Model Size near five hundred and seventy-two billion active parameters, well beyond this model.

Pre-training then raises the share of code from forty to seventy percent across its phases, and mid-training stretches the context step by step up to five hundred and twelve thousand tokens. Post-training is where the command line takes over. Tasks are synthesized at scale, many of them as containerized software environments, with a rule that the reference solution must pass and a do-nothing solution must fail. Reinforcement learning runs one shared policy across several harnesses, Claude Code, Codex and their different versions, and attributes each failure before learning from it. Errors caused by the policy become training signal. Faults in the environment or harness are masked out. A faulty evaluator stops the sample from being used at all. Four frozen experts, covering user experience, multiple harnesses, long-horizon work and general agent tasks, are then distilled into one student, and the results are merged across stages.

The cleanest controlled result is that scaling comparison, because it holds the data fixed. The benchmark table is a different kind of evidence: it sets the finished model against other finished models trained in other ways. There IQuest-Q1 scores sixty-four point six on DeepSWE, eighty-three point two on Terminal-Bench two point one, and eighty-four point five on CyberGym, generally above the open models it is compared with and below Claude Opus 5. The newest terminal benchmarks tell a harder story. On Terminal-Bench three point zero it scores seventeen point nine, against thirty for GLM-5.3-Flash and forty-two point seven for Claude Opus 5.

The paper also shows the model working on its own development. An agent built on it traced thirty-five tool-call errors on an unfamiliar schema, back across six thousand and fifty-four tool calls, to training data skewed toward a single tool-call format. It proposed cleaning and mixing in other schemas, humans approved the run, and the agent implemented it at a cost of nine hundred and thirty-eight point seven GPU hours. Separately, security experts assisted by the model produced thirty validated vulnerability reports in a three-day deployment.

The paper does carry a limitations section. It says the model takes text only, with no image, audio or video input. Its code and explanations may be wrong and should be reviewed or tested. Tool calls use an IQuest-specific format that needs compatible parsers. On real command-line work it may overlook constraints, repeat failed attempts or leave issues unresolved, so human supervision remains necessary. Beyond what it states, the evidence has its own limits. Several baseline scores come from the authors' own testing. IQuest-CLIBench, used to measure interaction quality, is a proprietary in-house benchmark. And the self-improvement example describes the retrained checkpoint being evaluated on held-out and familiar schemas without reporting what that evaluation found.

The idea to carry away is that agentic skill here is built in layers and protected at every one. A normalization and learning-rate recipe with measured headroom to grow. A data mixture that shifts steadily toward code and long context. Then environments engineered so that cheating fails and blame lands in the right place, with environment faults masked and evaluator faults discarded. The bet is that a terminal agent is mostly made by its training environments, and that the model can start helping to build the next ones under human review.