Sage A1.5 Tested: Intern's 35B Agentic Research Model Explained
Sage A1.5 is a 35B MoE agentic model from InternScience, tested locally on physics simulation and fact-checking tasks against GLM and Kimi benchmarks.
What is Sage A1.5?
Sage A1.5 is a 35 billion parameter mixture of experts model built by InternScience (the group behind the earlier Agent A1 model) on top of Qwen 3.5 MoE. It’s designed for agentic research and engineering work: deep search, scientific analysis, and software fixing, with an emphasis on multi-step tasks rather than single-shot answers. The model can split work across sub-agents, verify its own intermediate results, and revise its approach mid-task when something doesn’t check out.
TL;DR
- Sage A1.5 is a 35B MoE model from InternScience built on Qwen 3.5 MoE, aimed at long-horizon agentic work in science and engineering rather than chat.
- The model uses a two-stage training pipeline: separate teacher models trained per domain (search, engineering, science), then merged into one model via joint post-training that combines outcome rewards with token-level distillation from the teachers.
- Sage A1.5 adds two execution layers on top of its domain skills: orchestration (delegating to parallel sub-agents) and verification (checking evidence and adjusting course).
- In a hands-on test, the model correctly simulated a Voyager-style Jupiter gravity assist, matching its numerical simulation (9.996 km/s speed gain) against the analytic prediction and producing a working animated HTML visualization.
- A second test asked it to fact-check astrology by running three parallel sub-agents (astronomer, physicist, statistician) and merging their findings into a single report, which it completed with coherent, cited reasoning.
- The model card shows Sage A1.5 competing with or beating GLM, Kimi K3, and GPT-class models on agentic benchmarks, though the tester notes benchmark claims should be verified against actual task performance.
- It runs locally via llama.cpp at roughly 38GB of VRAM, with further reduction possible by lowering the context window, making it accessible on a single high-end consumer or prosumer GPU setup.
Remy.
How was Sage A1.5 trained?
The training process behind Sage A1.5 happens in two distinct stages, and it’s arguably the most interesting part of the model’s design.
In the first stage, InternScience builds separate “teacher” models for different skill domains: long-horizon search, software engineering, and scientific research. Each teacher trains inside its own environment suited to that task type. The best trajectories (the most successful reasoning and action sequences) get selected, then run through supervised fine-tuning followed by reinforcement learning. This produces several narrow specialists, each very good at one kind of agentic work.
The second stage merges those teachers into a single model through a joint post-training step. This step combines two signals: standard reward for reaching correct outcomes, and on-policy distillation, where each teacher gives token-level feedback on what the merged student model generates as it trains. The result is one 35B model that inherits skills from all the specialist teachers, including the ability to orchestrate sub-agents and verify its own evidence while reasoning.
This matters because it’s a different approach than just training one generalist model on a mixed dataset. By training specialists first and distilling their behavior token-by-token into a single model, InternScience is trying to avoid the usual tradeoff where a jack-of-all-trades model gets worse at each individual skill.
What does “orchestration and verification” actually mean in practice?
According to InternScience’s own description, Sage A1.5 is built around four domain skills (search, software engineering, ML engineering, and science) plus two execution layers that sit on top of them.
Orchestration is the model’s ability to break a task into pieces and hand those pieces to parallel sub-agents, then integrate what comes back into one coherent output. Verification is the model gathering evidence, reviewing its own judgment, and adjusting its next move if something doesn’t add up, rather than committing to a first answer and moving on.
In a hands-on test run through Hermes Agent, this showed up directly. Given a prompt to simulate a Voyager-style gravity assist around Jupiter, check the simulated speed gain against the analytic prediction, and produce an animated visualization, the model worked for more than an hour, made four tool calls to different sub-agents, and returned a Python simulation script alongside an animated HTML file. The simulation’s calculated speed gain (9.996 km/s) matched the analytic prediction to three decimal places, and the HTML output rendered a working animation of the flyby from both Jupiter’s frame and the Sun’s frame.
| Vendor | Tier | Risk | ApprovalNEW |
|---|---|---|---|
| Northwind Supply | Tier 1 | Low | Approved |
| Acme Logistics | Tier 2 | Medium | Approve |
| Helios Data | Tier 1 | High | Pending |
| Granite Freight | Tier 3 | Low | Approved |
| Pinecrest Labs | Tier 2 | Low | Approve |
A second test pushed the orchestration angle further: fact-checking astrology by explicitly asking the model to delegate the problem across three sub-agents working in parallel (an astronomer checking planetary positions, a physicist comparing the gravitational pull of Mars against a delivery room midwife, and a statistician modeling why vague predictions feel personally accurate). The model ran all three sub-agents concurrently, verified results with an additional checking agent, then merged everything into a single web report. The output included specific findings (Mars pulling less on a newborn than the midwife does, and roughly 47% of people finding two or more vague predictions that felt true by chance) packaged into clean, readable HTML.
A third test, framed as a “forensic physicist” prompt analyzing a photo for seatbelt physics, time of day, season, and region, showed the model stating confidence percentages next to its inferences and explicitly flagging what it couldn’t determine from the image. That tendency to admit uncertainty rather than guess confidently is a meaningful signal for anyone worried about hallucination in agentic pipelines.
How does Sage A1.5 compare to GLM, Kimi, and GPT-class models?
InternScience’s own benchmark figures position Sage A1.5 as competitive with, and in some cases ahead of, larger and better-known models including GLM 5.3, Kimi K3, and GPT-5.6 class systems, as well as clearly surpassing its own predecessors (Agent A1 and Ordinance 1.5). The model card’s benchmark charts show it leading its parameter class and closing gaps with much larger frontier models on agentic tasks specifically.
That said, benchmark leaderboards for agentic models are easy to game or overfit to, and a chart topping other named models doesn’t guarantee real-world task reliability. The more convincing evidence from hands-on testing is the actual task output: a physics simulation whose numeric result matched theory, and a multi-agent research report that held together logically once all three sub-agent outputs were merged. Benchmarks suggest where a model sits relative to peers; agentic tasks with checkable answers (like a Jupiter flyby velocity) show whether the model’s verification behavior is real or just marketing language in a model card.
Can you run Sage A1.5 locally?
Yes. At 35B parameters as a mixture of experts model, Sage A1.5 is large but not out of reach for local inference. Testing with llama.cpp showed VRAM consumption around 38GB, which fits on a single high-end GPU with generous memory (think workstation or prosumer cards in the 40GB+ class, or dual consumer GPUs pooled together). VRAM use can be reduced further by lowering the context window, trading off how much conversation or task history the model can hold at once.
The model is distributed on Hugging Face under the Apache 2.0 license as safetensors checkpoints, split across multiple shards, which is standard for a MoE model of this size. Because it’s released openly rather than gated behind an API, it’s one of the more accessible agentic-research-focused models for anyone running local inference rather than calling a hosted API.
Is Sage A1.5 worth using for agentic research tasks?
For workloads that specifically need multi-step reasoning with built-in self-checking, physics or science-heavy problem solving, or tasks that benefit from splitting work across parallel sub-agents, Sage A1.5 looks like a strong open option based on the tests described here. It handled a real orchestration task (three parallel sub-agents feeding into one merged report) cleanly, and its physics simulation output matched theoretical predictions exactly, which is a meaningful bar for a model marketed around scientific verification.
Where it’s less clear is general-purpose chat or tasks outside its target domains of search, software engineering, ML engineering, and science. The model is explicitly trained toward agentic research and engineering workflows, not optimized as an all-purpose assistant, so expectations should be set accordingly.
Frequently Asked Questions
What company made Sage A1.5?
Sage A1.5 was built by InternScience, a research group based in Shanghai that previously released the Agent A1 model. Sage A1.5 builds on both Qwen 3.5 MoE and lessons from that earlier model.
How big is Sage A1.5 and what architecture does it use?
It’s a 35 billion parameter mixture of experts (MoE) model, built on the Qwen 3.5 MoE architecture. It supports text generation, tool use, and image-text-to-text input, making it usable as a vision-capable agentic model as well as a text-only one.
How much VRAM does Sage A1.5 need to run locally?
Running the model locally through llama.cpp used roughly 38GB of VRAM in testing. That figure can be lowered by reducing the context window length, at the cost of how much task history the model retains during a session.
How does Sage A1.5 compare to GLM and Kimi K3?
InternScience’s benchmark charts show Sage A1.5 matching or exceeding GLM 5.3, Kimi K3, and GPT-5.6 class models on several agentic benchmarks within its model class. Independent hands-on testing with real tasks (physics simulation, multi-agent fact-checking) also showed strong, verifiable results, though broader independent benchmarking is still limited since the model is newly released.
What kinds of tasks is Sage A1.5 best suited for?
It’s built for agentic research and engineering: deep search, scientific analysis, software engineering, and ML engineering tasks that benefit from breaking work into sub-tasks and verifying intermediate results. It’s not primarily designed as a general chat assistant.
