What GPU Does Sage A1.5 Need? Local VRAM and Agent Tests

What hardware does Sage A1.5 need to run locally?

In one hands-on test, Sage A1.5 served through llama.cpp used roughly 38 GB of VRAM. The tester said that figure drops if you shrink the context window. The quantization and context length behind the 38 GB number were not stated, so treat it as a ballpark, not a spec. In practice that points to a single 48 GB card or a multi-GPU setup, and not a typical 24 GB consumer GPU, unless you cut context or quantize harder.

What is Sage A1.5?

Sage A1.5 is a 35B mixture-of-experts agentic model. The model card says it is based on Qwen3.6 (the linked base is Qwen3.6-35B-A3B) and on Agents-A1. It was built for long-horizon scientific problem solving, and the card names three headline capabilities: agentic orchestration, verification, and open scientific discovery.

The intended uses are agentic research and engineering. That covers deep search, scientific analysis, ML engineering, and fixing software, with a tilt toward science.

The weights ship in Hugging Face Transformers format. The card says they are compatible with Transformers, vLLM, SGLang, and similar tooling. The llama.cpp run in the hands-on test implies a converted format, but the sources don't say which one.

How does Sage A1.5 handle orchestration and verification?

Two features separate it from a plain chat model.

Orchestration. The model delegates work to parallel sub-agents that each keep an isolated context. The card says this lets tasks be decomposed and handled concurrently while reducing interference between sub-agents. The sub-agents can challenge assumptions and refine conclusions, and the main agent synthesizes the results.

Verification. The card describes this as an opt-in mode that lives inside the model's own chain of thought. The model pauses mid-trajectory, reviews what it has established and what has failed, and acts on a revised direction in the same turn. There is no external critic. The goal is to recognize unproductive search paths and try something else.

How was Sage A1.5 trained?

Training happens in two stages.

1. Separate teachers. Intern built different teacher models for different areas, including long-horizon search, engineering, and scientific research. Each teacher got its own training environments. The best trajectories were selected, then used for supervised fine-tuning followed by reinforcement learning.
2. Merge into one student. The teachers were merged into a single model through a joint post-training step. It combines two signals: rewards for reaching the correct outcome, and on-policy distillation, where a teacher gives token-level feedback on what the student itself generates.

The result is one 35B model that carries skills from all the teachers. The card lists four domain skills (search, software engineering, ML engineering, science) with orchestration and verification layered on top.

What do the benchmarks say?

The model card reports results across six areas: long-horizon search, engineering, instruction following, scientific research, general agentic tasks, and scientific agentic tasks. These are Intern's own numbers. A selection:

Some context on reading this. The card claims overall best results on XBench-DS-2510, IFBench, PinchBench, FrontierScience-Olympiad, FrontierScience-Research, CMT, and OmniDocBench. On GAIA it scores 95.1, above every larger model listed, though Agents-A1 scores 96.0. On other tests the larger models still lead: BrowseComp (91.2 for Kimi-K3 against 81.7 for Sage without orchestration), SWE-bench Pro, and HLE with tools (55.1 against 64.5 for GPT-5.6-sol).

Orchestration helps on some tasks. BrowseComp rises from 81.7 to 82.8, and DeepResearch-Bench2 from 43.7 to 47.5. Against its predecessor A1, the card cites gains of +17.6 on SWE-bench Pro, +14.0 on SWE-bench Multilingual, +13.1 on PinchBench, and +21.3 on MLE-Lite.

How did it perform in hands-on agent tests?

A creator ran three tasks in Hermes Agent, with the model served locally through llama.cpp. These are single demonstrations, not a controlled evaluation.

Jupiter gravity-assist simulation

The prompt asked for a Voyager-style Jupiter gravity assist, a check of the simulated speed gain against the analytic prediction, and an animated HTML output. After more than an hour of thinking and four tool calls across different sub-agents, the model produced a Python simulation. The simulated gain was 9.996 km/s, and the analytic prediction was also 9.996 km/s. The HTML replayed the flyby in Jupiter's frame next to the spacecraft's speed relative to the Sun.

This test matches the verification behavior the card highlights: simulate, compare against theory, fix any mismatch. The long runtime matters if you plan to use it interactively.

Parallel sub-agent astrology fact-check

The prompt told the model to delegate to three parallel helpers: an astronomer checking where the planets were, a physicist checking whether Mars pulls on a newborn more than the midwife does, and a statistician simulating why vague predictions feel true. The main agent then had to combine the answers into one web page.

Hermes Agent ran the three sub-agents in parallel, and another agent verified the output. The final page reported that Mars pulls on a newborn less than the midwife does, and that about 47% of people find two or more vague predictions that fit by luck. A judge model also reviewed the result. The creator credited recent improvements in Hermes Agent's sub-agent orchestration for part of the smooth run, so some of the credit belongs to the harness.

Forensic physics from a photo

The model got a photo and was asked to act as a forensic physicist with a sense of humor. It had to audit a seat belt with real physics, infer time, season, and region from the scenery, and rank hypotheses with probabilities. It followed all four parts in order. The math checked out with assumptions stated and a confidence percentage on each guess. It also said what it could not know. The humor was flat, and a few claims were wrong, including a remark about left-hand drive.

Is Sage A1.5 worth running locally?

It depends on what you have and what you need.

Reasons to try it:

• A 35B MoE model that fits in about 38 GB is within reach of a single high-memory GPU.
• Native function calling and sub-agent delegation fit agent harnesses like Hermes Agent.
• Self-checking behavior showed up in the physics test, where it compared its output with theory.

Reasons to hold back:

• Runs can be slow. The Jupiter task took over an hour.
• The benchmark numbers come from the developer, and larger models still win several tests.
• Creative and humorous output was weak, and small factual slips appeared in the photo task.
• Exact quantization and context settings behind the 38 GB figure are unknown, so budget extra headroom.

If your work is long-running research, scientific analysis, or software repair with tools, it is worth a test on your own tasks. For quick chat, the latency and VRAM cost are hard to justify.